WO1994002895A1 - Utilisation d'un langage a interprete embarque pour la realisation d'un outil interactif de definition d'interface utilisateurs - Google Patents

Utilisation d'un langage a interprete embarque pour la realisation d'un outil interactif de definition d'interface utilisateurs Download PDF

Info

Publication number
WO1994002895A1
WO1994002895A1 PCT/FR1993/000749 FR9300749W WO9402895A1 WO 1994002895 A1 WO1994002895 A1 WO 1994002895A1 FR 9300749 W FR9300749 W FR 9300749W WO 9402895 A1 WO9402895 A1 WO 9402895A1
Authority
WO
WIPO (PCT)
Prior art keywords
widget
interactive
tool according
list
wool
Prior art date
Application number
PCT/FR1993/000749
Other languages
English (en)
Inventor
Colas Nahaboo
Vincent Bouthors
Original Assignee
Bull S.A.
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Bull S.A. filed Critical Bull S.A.
Priority to US08/211,133 priority Critical patent/US5696914A/en
Priority to KR1019940700954A priority patent/KR0136349B1/ko
Priority to JP50421894A priority patent/JP3348853B2/ja
Publication of WO1994002895A1 publication Critical patent/WO1994002895A1/fr

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/30—Creation or generation of source code
    • G06F8/38—Creation or generation of source code for implementing user interfaces

Definitions

  • the present concerns the use of an on-board interpreter language for the creation of an interactive user interface definition tool.
  • the aim of the invention is to propose a particularly flexible interface development tool which can be used whatever the application.
  • This interface was for example developed for the field of UNIX systems using X / INDOW and X / MOTIF trademarks respectively registered by the M.I.T and the Open Software Foundation.
  • the language has a similar representation for data and programs.
  • the definition program cooperates with a library of interactive "idgets" command objects "X / MOTIF” and a library of graphic objects "GO”.
  • the application program consists of a mixture of instructions on the one hand in C language which is a high level portable assembler handling objects and on the other hand of instructions in interpretable language.
  • the interpreter is object-oriented in LISP language.
  • the interpreter uses tables.
  • the core of the interpreter is constituted as a two-dimensional matrix, one of type containing lists, strings, numbers, the other of selector, containing functions such as "eval, print, free, add, ... ".
  • the WOOL interpreter comprises a garbage collector or cell gleaner (Garbage collector,
  • this cell gleaner
  • the cell gleaner uses reference counters and a mechanism for grouping objects by size to limit the fragmentation of the memory.
  • the functions of the tool interactive are described in the form of an interpreted program.
  • the archiving of the presentation of the interface edited and carried out like that of a WOOL program is carried out like that of a WOOL program.
  • the interactive specification of the assembly geometry of these objects is translated into a file usable by an application that can be archived on disk containing the presentation of a user interface in the form of a program in "WOOL" language.
  • the dynamic behavior of interactive objects is defined by a set of callback procedures written in "WOOL” language and which designates functions of the application called by the toolbox. "X / MOTIF" when an entry event is received by one of the "widgets”.
  • the interface definition program is extensible by the addition of classes of "widgets” carried out by describing in WOOL language the new types of attributes of this class to make the new "widgets” editable.
  • each "widget” is pointed to by a "WOOL” object of the "WOOL” class corresponding to the class of the "widget", the additional attributes being attached directly to the "WOOL” object.
  • each WOOL object is a structure in autotyped C language, containing the type of the object and the information of the reference account.
  • each interactive "widget” object is associated with a unique "WOOL" identifier allocated in an incremental manner.
  • the interactive interface definition tool "EGERIA” comprises a program allowing the display of a basic menu comprising an editing function "edit”, a creation function “create” and a geometry function “geometry”.
  • the creation function allows the creation of any "widget” from a menu, and after selecting a menu line, changes the shape of the cursor and a mouse click in an interactive object containing "widget container” will install the object of the type chosen in this interactive container object ("container").
  • the editing function allows the editing of the attributes of a "widget” in a separate window and makes it possible to cut, paste, copy or duplicate the set of selected “widgets” as well as to edit the attributes of the "widgets "parent of a selected” widget "or make the parent of a currently selected” widget “the new selected” widget ".
  • the geometry function "geometry" makes it possible to manage the geometry of a set of selected “widgets" which can be aligned by the top, by the bottom, by the right side, by the left side or have their width or identical height.
  • an editing function allows the display of an editing window for the attributes of a "widget" divided into two zones, one comprising the functions called for the application of callback procedures, the other comprising the attributes materialized by a set of sub-editors.
  • the first sub-editor consists of a toggle button for entering Boolean attributes.
  • the second sub-editor consists of a push button displaying a menu displaying the lists of values of an enumerated type (ex: alignment of a text to the left, to the right or centered).
  • the third sub-editor consists of a text zone for entering texts or numerical values.
  • the function of editor of interactive objects of the "Shell widgets" type of MOTIF ie representing a window (X / Windows) of first level, is launched by first selecting the menu for selecting parent "select parent” and then the attribute edit function "edit attribute".
  • FIG. 1 schematically represents the architecture of the interface definition software
  • FIG. 2 represents the main window presented by this software for the definition of an interface
  • FIG. 3 represents a window displayed by this software allowing the shape editing of an object.
  • FIG. 4A and 4B represent a window displayed by this software allowing the editing of the attributes of an interactive object, and respectively of the recall procedures.
  • FIG. 5 represents the window defined for a particular application by the interface definition software.
  • the interactive interface definition tool (1) "Egeria" is constituted as shown in Figure 1:
  • This interactive interface definition tool (10) must be associated, in order to function, with a library of interactive command objects called the command object toolbox, "X / MOTIF" (20) in the UNIX environment. , and a toolbox of graphic objects constituted by a library of "GO" graphic objects (21).
  • This powerful library in C ++ language provides graphic services which are not available to date in the UNIX environment and which allow to create and order rectangles, ellipses, polygonal lines, texts editable in several fonts and images .
  • the definition tool also cooperates with an Xlib library (3) which constitutes the protocol layer specifying the coding of the flow of information circulating between the application and the window server and the library layer constituting the programming interface making it possible to access the windowing system.
  • EGERIA covers the presentation layer which describes static the set of objects constituting an interface, ie their hierarchy and their attribute, and the dialogue layer which describes the dynamic aspect of the interface, ie its behavior.
  • an additional layer (5) is constituted by the application which comprises the semantic layer containing what in the application does not concern the interface.
  • the interpreter "WOOL.LIB” (11) is a small Lisp interpreter written in C language in which the memory is managed explicitly by reference counter and which includes an internal typing allowing the type checking, the triggering of procedure by sending of messages according to an object oriented approach.
  • the interpreter provides a set of basic data types such as atom, list, integer, real number, character string.
  • This set of basic type is extensible in that one can introduce a new basic type such as a "widget” allowing the controlled manipulation of objects "MOTIF” in "WOOL".
  • Each object in "WOOL” is formed as shown in fig. 1B, a header which includes a pointer to the class which is the type (31) of the object and the reference counter (Ref Cnt) and finally other information (attributes) which depend on the type of the object .
  • Each "widget" object is associated with an identifier allocated incrementally.
  • Each widget created by EGERIA is assigned a unique identifier of the type "@ 000012 @”. The uniqueness of this reference is guaranteed for the entire duration of the EGERIA session. If such references are used in the text of callbacks in "WOOL” attached to widgets, a backup (or cut) followed by a restoration (or a paste) maintains the mutual consistency of the references. This is not the case if the mutual references are made using atoms in "WOOL”: in this case an atom having only one value, the two callbacks would refer to the same widget.
  • EGERIA changes the callback code associated with the duplicated button to:
  • Such a method makes it possible to avoid having to manually change the code of the callbacks during a duplication.
  • the type of the object allows access in the kernel of the "WOOL" interpreter (WOOL KERNEL) to a class (110) which contains a list of methods, each method (Method) is a function such as for example the "Print" function.
  • Method is a function such as for example the "Print" function.
  • the classes constitute the columns of the matrix table of figure 1B and the methods the lines of the table.
  • This interpreter offers a set of easily extensible "Lisp” primitives.
  • the garbage collector constituted by the old reference counting method requires taking extra care when creating self-referencing structures.
  • the interpreter "WOOL.LIB” includes a garbage collector or cell gleaner (Garbage collector, GC) which allows from time to time and in a cyclic way to scan the memory in search of unused objects whose space can be reused, which is done without interrupting use.
  • This cell gleaner (Garbage Collector, GC) is incremental.
  • the cell gleaner uses reference counters allowing the allocation of objects of any size and a mechanism for grouping objects by size to limit fragmentation.
  • WOOL.LIB implements a cell gleaner (garbage collector, or GC), allowing the automatic recovery of unused memory, which allows the programmer not to worry about allocation and deallocation objects used.
  • GC garbage collector
  • the GC of "WOOL.LIB” is incremental in that it operates continuously and on low volumes of data, unlike conventional GCs which are called only occasionally, for recovering a large volume of memory; in this case, the period during which the GC is active results in a perceptible halt in the interpretation of the current program, which can be very annoying for the user of an interactive program.
  • An incremental GC guarantees that the interpretation proceeds smoothly, the excess due to the GC being uniformly distributed over the whole execution of the interpreted program.
  • EGERIA contains the references necessary for editing links.
  • interface object classes push button, scrollbar, menubar, etc.
  • primitives toolskit-init, "widget” create, etc ..., for example on XmNinputCallback of the "widget” XmDrawingArea cf ( 432) annex 4)
  • EGERIA The structure of EGERIA (10) is characterized by a main loop for reading the input which distributes the events (mouse click, keyboard action) received to the various program components.
  • An example of such a loop (511 appendix 5) appears in the example of application given later in appendices 4 and 5.
  • This loop is responsible for calling the read function reason and then distribute the input received. This means that there is a programming level where you can decide for each X / Window event and therefore for each "Reason” event of the entity responsible for processing the event. It can be "Reason” which will call the callback procedures defined for the "" widget "" associated with the event or another component such as EGERIA.
  • a "callback” such as for example “call-back dog: draw” written in Lisp (cf 435 appendix 4) or “call-back dogrstep” (cf 4412 appendix 4) is formed by a call of the main entry point (530 respectively 531 appendix 5) of the interpreter "WOOL.LIB” which will execute the associated method (523 respectively 525 appendix 5) written in C language and gives back the hand as quickly as possible.
  • FIG. 1B represents the structure of the core (WOOL KERNEL) which is organized according to a table, each column of which corresponds to a type of object. An object being referenced by its type which thus gives access to the method of processing messages that the object can process.
  • the "WOOL.LIB” interpreter (11) essentially has the task of loading the file (13) of interface description, for example constituted by appendix 4, when this interface has been developed. "WOOL.LIB” executes this interface description file (14) as a program in WOOL language to reconstruct the interface of the application and then interprets all the events occurring in from the MOTIF toolbox for either reacting dynamically in the interface without waking up the application, or sending the event to the application via an entry point for it.
  • the EGERIA editor (10) mainly has two modes of operation, editing and execution.
  • the “edition” mode is the one in which you can freely modify the interface of the application and the "execution” mode allows you to test the behavior of the interface.
  • Objects can be classified into two categories, elementary objects and containers ("container widgets") which can contain several objects. Among the containers, some such as the parent or shell interactive objects (“shell widgets”) have no container and are created at the first level (example “Top level Shell” appendix 4).
  • a MOTIF FORM widget is a "containing" widget whose threads are automatically positioned or resized when the FORM widget is resized.
  • the interactive specification of the behavior of the children of such a widget is carried out using a special form, called form editor "FORM EDITOR", which makes it possible to easily define all the behaviors provided by MOTIF.
  • the behavior of a child of the FORM widget is specified by giving the value of an attachment for the 4 edges of the widget, respectively designated by top (322), right (323), left (324), bottom (325).
  • An attachment can be NONE (no attachment (323)) FORM (attachment relative to the corresponding edge of FORM (322,324)), POSITION (attachment proportional to the horizontal or vertical dimension of the FORM widget (3262)) or WIDGET (attachment relative to a child widget of the same FORM (325)).
  • FIG. 3 representing the form editing form "FORM EDITOR”
  • four menus can be displayed to specify the type of attachment of the child widget considered.
  • an interactive arrow (328) shows which attachment is “current”. The selection of any attachment results in the "current" of the positioned attachment.
  • Two text boxes describe the offset (3261) and the position (3262) (when the attachment is POSITION) of the widget corresponding to the current attachment. When the current attachment changes, these text boxes are updated. When the attachment is not POSITION, the text box marked "position" is inactive, and its title appears in gray, as in Figure 3. It is possible to move or resize interactively with the mouse the child widget; in this case the command is executed as if it had been placed from the FORM editor, and the text zones corresponding to the offset and / or to the position are updated.
  • the editor allows the creation of elaborate objects (container "widget”) which can consist of several objects but which are considered as simple objects, that is to say that we can paste, cut and copy them in one operation.
  • This main menu (200) additionally comprises the classic file (201) "file” and help (206) "Help” functions and the specific functions "EDIT”, “CREATE”, “GEOMETRY”, “TOOLS”.
  • the appearance of the interface is edited either directly with the mouse by modifying the size or position of the "widgets" inside their container, or by using forms containing the different attributes of one or more multiple objects.
  • use the function (202) "Edit” which allows the attributes of an object to be edited in a separate window and allows the attributes of the parent objects of a selected object to be edited and also to cut, paste, assemble, copy a set of selected objects.
  • the interface editor allows to modify the geometry of the presentation by calling on the function (204) "geometry” which allows for example to align a set of objects selected by the vertex, the side or the base, or to vary the dimensions of all of these objects, either in width or in height.
  • the creation menu (203) "CREATE” includes, as shown in FIG.
  • the attribute part is carried out with a set of sub-editors. These sub-editors are automatically created by reading a description of the classes in the "X / MOTIF" library (11). There are three kinds of sub-publishers. A toggle button sub-editor for entering Boolean attributes, a push-button sub-editor displaying a menu for listed types and a text box sub-editor for text or numeric values, such as those appearing in appendix 4 under the reference (436 ).
  • This selection causes the display of a window of the type represented in FIG. 4A which includes a menu consisting of several superimposed cards (311, 312) accessible by buttons (3110 to 3114 and 3121 to 3124) playing the role of 'tab.
  • Each card groups the attributes corresponding to a "widget” category. These categories are the appearance launched by the button 3110, the geometry launched by the button 3111, the behavior launched by the 3112 button, the constraints launched by the 3113 button, and the "callback" procedures launched by the 3114 button. This allows the user to conveniently access an attribute among the very many attributes provided by the X / software. PATTERN.
  • buttons 3111, 3112, 3113.3114 shown depressed that is to say in the background.
  • the appearance attribute editor corresponding to this button represented in the foreground was activated by a mouse click on the button area, and displays the corresponding window (313) to allow editing of attributes.
  • this will be the window of which the part 313 comprises the attributes making it possible to define the appearance of the "widget" being edited.
  • These attributes are made up of a text area used to define the background in the area 3130, in the area 3131 the background of the point matrix, in the area 3132 the thickness of the default shadow of button, in area 3133 depth, in area 3135 the font list, in area 3136 the foreground, in area 3137 the dot matrix label, in area 3138 the label of the chain, here in this case XmPushButton, in zone 3139 the type of labels, and in zone 31390 the appearance as a default.
  • the attributes displayed in the window part 313 are the visible attributes which appear when the button 3101 bearing the label "current” (CURRENT) is pressed.
  • the definition of the attributes is done in a conventional way, by clicking with the mouse arrow on the text zone of the desired attribute and by entering the textual or numerical values on the keyboard.
  • Selecting the button 3124 carrying the view command makes it possible to pass an attribute name from the list of visible attributes to the list of invisible attributes and vice versa.
  • This button (3124) by clicking the mouse arrow on the button area triggers in the attribute editor a window display function 3110 allowing you to view both the visible attributes represented in the area 313 and the invisible attributes represented in an area 314 of the window 3110.
  • This window 3110 also includes functional buttons making it possible to validate with the OK button the selection made, to invalidate by the button 316 the selection or the modifications made, to move by the button 317 an attribute from the visible zone to the invisible zone or vice versa, to load by the button 318 attributes and by the button 319 to save the selection or the selection modifications which have been made.
  • an additional command 310 available in the attribute edit sheet (view ail attributes) in the form of a radio button, makes it possible to ignore the specification of visibility and d display all the attributes in window 313.
  • the current radio button 3101 is selected, only the attributes bearing the visible specificity are displayed in window 313.
  • Selecting the "geometry” card with the 3111 button allows you to launch an editing function allowing you to display the attributes for selecting and modifying the geometry of a widget.
  • the "behavior” card by activating the button 3112 allows to launch an editing function allowing to display the attributes defining the behavior of a widget and to define what will be its behavior according to the selected attributes.
  • Selecting the 3113 button activates the stress editing function and displays the attributes of the constraints s - attached to a given object.
  • the publishers are deactivated.
  • buttons 3113, 3123 For example, for pushbuttons whose attributes are defined in window 31, the constraint editing and global validation function are inactive and in this case, the title appears grayed out as shown in buttons 3113, 3123.
  • the callbacks procedure part is simply a text area where it is possible to edit the callbacks procedures of the interactive "widget" object. This part is shown in enlarged form in FIG. 4B. Above this the dialog box concerning callback procedures is a text box allowing to display information on the edited "widget" such as its name and reference number.
  • a callback procedure is coded here in WOOL language.
  • a basic model is given for each possible callback procedure for a widget. For example to edit the WOOL code executed when a push button is clicked, the basic model is (on XmN activate callback (widget)).
  • XmN create callback A nickname "callback" XmN create callback was added, it is called by EGERIA when an interface description (14) is loaded, after all its child “widgets” created in the same description file have been created. Additional initializations can be done inside XmN create callback.
  • parent objects such as for example: XmDrawingArea which is the parent of XmFrame, XmLabel, XmScale and XmSeparator from appendix 4) is not possible directly in order to edit the attributes of a "Shell” object "or of a general" Top level widget "object (XmTopLevelShell), it is necessary to use the” Select parent "command and then to start editing attributes.
  • XmDrawingArea which is the parent of XmFrame, XmLabel, XmScale and XmSeparator from appendix
  • the interactive objects created depend a lot on the current state of the X / defaults file, the names given to the objects can be used to set the default values of the created objects if these values have not been set with l 'editor.
  • a minimum and useful set of default values which can be used by EGERIA can be those defined in appendix 1 in the file X / Defaults (13).
  • a translation table contained in the X / defaults file can also be used to activate functions internal to Egeria, from UNIX events.
  • the event (21) of appendix 2 will make it possible to select with the left button and to move the "widget" (s) selected by the pointer.
  • the "EgSelect” function allows the selection of a "widget” under the pointer and the EgMove function allows the movement of the selected "widget”.
  • the left mouse button operated at the same time as the "Shift" key allows, as represented by line 22 of appendix 2, to add the designated object to the list of selected objects.
  • the EgSelect or UnSelect function allows you to select or deselect an object designated by the pointer. This function works like a toggle.
  • a second minimum translation table defined in appendix 3 is also installed in the X / Defaults file to enable the main editing functions from the keyboard.
  • This table calls the Eg WOOL Exec function which executes an expression in WOOL language which is the value of the atom given as an argument.
  • the atoms prefixed with the term "Custom" are defined in the Edcustom.G file. This is the standard way to customize the basic behavior of the editor.
  • FIG. 5 An example of application of the interface editor described in relation to FIGS. 1 to 4 will be given below for editing an interface making it possible to display, as shown in FIG. 5, a dog (45) running while allowing by action on a button "One step” (42) to advance the dog of a step, by action on a button "Quit"
  • the application will include several successive images stored in a "Pix ap pdog” memory (52) which will be displayed by moving them in a “DrawingArea” drawing area.
  • a "Shell widget” which in our example will be a general “widget”, a "top level”, that is to say “XmToplevelShell” (40) which has the identifier " ⁇ 000001 ⁇ ", for parent” eg: widget-root "and containing another object (41)” DrawingArea ".
  • the editor has known functions, cut, paste, copy and the list of objects created or selected can be manipulated using the left button which allows you to select or move the "widgef's", using the left which when the "Shift" key is pressed makes it possible to add the designated object to the list of selected objects, to the right button of the mouse which makes it possible to select all the "widgets" inside a rectangular area defined by two corners, namely the place where the button is pressed, and the place where it is released.
  • the "widget” selected becomes the father of the one who been selected, this is essential to select a "widget” hidden by his or her children, for example a "Shell” or a menu.
  • the "widgets” can then be changed in position and size using the mouse by pressing the left button to select and move the selected "widget” (s), which involves the events of line 21 of l Annex 2.
  • the action on the right button of the mouse to draw a rectangle in which the objects will be selected involves the commands of line 23 of appendix 2.
  • the action on the button of the middle of the mouse, as indicated by line 24 of appendix 2 allows you to change the size of one or more "widgets".
  • a "Resize” operation from this "Geometry” menu makes it possible to give the selected objects the same size in width or in height, or a minimum or maximum size.
  • the "Distribute” operation allows you to distribute the selected objects at regular intervals, they can be distributed horizontally or vertically using the enclosing rectangle or inside their father.
  • the attributes are edited by selecting the operation (2021) "Attribute” from the "Edit” menu to display a data sheet containing all the attributes as shown in FIG. 4A. Certain attributes cannot be modified after the creation of the "widget". This is the case, for example, of the attributes XmNscrollingPolicy and XmNscrollBarDisplayPolicy.
  • the "widget” parameter is available, it indicates the “widget” currently activated, ie here the "PushButton Quit” push button.
  • the call_data parameter is not available.
  • the application is initialized by calling the init function with the "call-back init” instruction (4311) which defines the “callbacks” of the draw and step application, and which calls at code C: “InitCallback (widget, client-data, call-data) and InitPixmaps” (532) loads the point images (pixmaps) corresponding to the different states of the dog by the "InitPixmaps" procedure defined in (5221).
  • the step function causes the dog to start from the left each time it leaves the "DrawingArea” drawing area on the right.
  • the window-width variable is updated each time the width of the "widget" changes by the WOOL instruction:
  • drawing-area widget (434) to identify it from the C code which creates the pi aaps. This is done with the EgVariableGetValue ("drawing-area", ...) function see appendix 5 reference 522. it would have been easier to pass the "widget” as an init parameter but this will allow us to see (further on) how to consult a LISP variable from code C.
  • the PushButton "START” makes the dog run.
  • the work-proc (441) function which stores an expression which is then evaluated each time there is no event to process originating from X. This expression must be evaluated in a short time. In our example, it increments a counter (4411) and advances the dog thanks to the step function (4412 or 4413)) when a certain value is reached. The increment is the value of a Scale "widget"
  • the identifier of a "widget” is displayed when it is selected. It can easily be copied and pasted. His class and possibly his name are also displayed.
  • the counter is initialized when creating the "widget":
  • PushButton "Stop” allows to stop the dog's race. This is also done by a call to work-proc cf 442:
  • EGERIA provides the file "eg_toolkit.h containing all the public declarations of the MOTIF" toolkit "(see 50):
  • EGERIA is given control of the execution thanks to the EgMain function.
  • InitCallback registers the "callback” which initializes the application and registers the other callbacks. This "callback” is called explicitly from the interface by (call-back init).
  • the InitCallback callback has two roles: initializing the application and recording the links between the interface and the application.
  • InitCallback Widget widget; / * UNUSED * / caddr_t client_data / * UNUSED * / caddr t call data / * UNUSED * / ⁇
  • EgCallbackDefine Draw, DrawCallback
  • EgCallbackDefine step, StepCallback
  • StepCallback Widget widget; / * UNUSED * / caddr_t client_data / * movement * / caddr t call data / * UNUSED * /
  • XCopyArea (DISPLAY, pdog [current], drawingAreaWindow, gc, 0, 0, wdog [current], hdog [current], xdog, ydog);
  • EGPATH .: / User / local / lib / Xll / eg dog -edit &.
  • EgVERSION 2 #define EgREViSION 0 #define EgVersion EgVERSION 1000 + EgREViSION
  • EgLayer layers [] ⁇ ["Egeria”, EgVersion ⁇ , "Xt”, XtVersion ⁇ , ["MOTIF”, XmVersion ⁇
  • WIDTH 0; / * sizes * /
  • ReadPixmap (name, & ppixmap [i], & wpixmap [i], & hpixmap [i])) ⁇ fprintf (stderr, " file% s is not found ⁇ n ", name); exit (-1);
  • XCopyArea EgDisplay, ppixmap [current], drawingAreaWindow, gc, 0, 0, wpixmaptcurrent], hpixmaptcurrent], xpixmap, ypixmap
  • Widget widget / * UNUSED * / caddr_t client_data; / * UNUSED * / caddr_t call_data; / * UNUSED * /
  • Widget widget / * UNUSED * / caddr_t client_data; / * movement * / caddr_t call_data; / * UNUSED * /
  • XCIearArea EgDisplay, drawingAreaWindow, xpixmap, ypixmap, WIDTH, HEIGHT, False
  • XCopyArea (EgDisplay, ppixmapicurrent], drawingAreaWindow, gc, 0, 0, wpixmaplcurrent], hpixmaplcurrent], xpixmap, ypixmap); ⁇ void l ⁇ itCallback (widget, client_data, call_data)
  • Widget widget / * UNUSED * / caddr_t client_data, 7 * UNUSED * / caddr_t call_data, 7 * UNUSED * /
  • EgPointerDefine (dog: window-width”, EgClassInt, &windowWidth);
  • EgTypedCallbackDefine ("dog: draw”, DrawCallback, EgClassAny);
  • load-pathname '[W2] directory path used by load provide [W2] [CI_ 277] manage file loading require [W2HCL 277] manage file loading setf [W2] [CL 124] gênerai assignation setq [W2HCL 122,121] variable assignement set [W2] [CL 122,121] variable assignment
  • [W2] prevent evaluation with possible internai evaluations backquote [W2] prevent evaluation with possible internai evaluations defmacro [E1] define a WOOL macro defmacro [W2] [CL 76, 1 95] define a WOOL function defunq [W1] define a WOOL function defun [W1] define a WOOL function defun [W2] [CL 76, 1 95] define a WOOL function of [W1] define a WOOL function df [W1] define a WOOL function dm [E1] define a WOOL macro flambda [W1 ] define a WOOL function lambdamacro [W2] [CL 76, 195] define a WOOL function lambda [W1] define a WOOL function lambda [W2] [CL 76, 1 95] define a WOOL function
  • class-is-subclass [E1] tests if a class is subclass of another class-super-class [E1]
  • XtRemoveEventHandler [E1] (T] add or remove an event handler call-back [E1 & 2] call a callback function eg: callback-make-from-string [E1] T ⁇ create a callback from a string eg: callback-make [ E1] 7 create a callback from an expression widget-add-callback [E1] [T] adds or remove callback in a widget widget-add-event-handler [E1] [2 add or remove an event handler widget-remove-callback [E1] [?] Adds or remove callback in a widget widget-remove-event-handler [E1] [?] Add or remove an event handler work-proc [E1]
  • XtResize [E1 & 2]
  • XtMakeGeometryRequest moves or resizes to widget
  • XtSetValues [E1 & 2] Set MOTIF resources of a widget
  • widget-set-menu-position [E1] [Tjget the position of a menu eg-widget-shell-children [E1] [TJthe list of chiidren widgets popup-shell-create [E1 & 2] creatures a widget widget-create [E1 & 2] creates a widget-destroy widget [E1 & 2] destroy a widget and ail its chiidren widget-geometry-request [E1 & 2] moves or resizes a widget widget-get-values [E1 & 2] get MOTIF resources of a widget widget-manage [E1 & 2] manage or unmanage a child widget widget-map [E1] ⁇ Tj map or unmap a child widget widget-move [E1 & 2] moves or resizes a widget
  • XmListAddltem [E1 & 2] add an item or a list of items to a list
  • EgVariableSetCValue [E1 & 2] set or get a WOOL variable
  • EgObjectDecreaseRef [E1 & 2] decrease or increase the reference count of an object
  • EgObjectEqual [E1 & 2] Test equality of two objects EgObjectEval [E1 & 2] Evaluâtes an object EgObjectGetCValue [E1 & 2] Gets C value of an object EgObjectlncreaseRef [E1 & 2] decrease or increase the reference count of an object
  • EgObjectlnternEval E1 & 2] Evaluâtes an object EgObjectlsSubclass [E1 & 2] Checks the class of an object EgObjectModify [E1] [T] Sets C value of an object EgObjectPrint [E1 & 2] Prints the wool object APPENDIX 6 (continued)
  • EgListAppendltem [E1 & 2] append an object to a list EgListContainltem [E1]
  • EgListCreateFromArray [E1 & 2] create a list from an array
  • EgListCreateN [E1 & 2] create a list
  • EgListlnsertltem [E1 & 2] insert an object in a list
  • EgListMoveltem [E1 & 2] move an element inside a list
  • EgListSetltem [E1 & 2] get or set an item in a list
  • EgClassSetMethod [E1 & 2] set or get a method of a class
  • An active value may be viewed as a variable or as a function in the same time.
  • the principle is that a specifies function is called when you assign or when you consult an active value.
  • the get function has no parameters and returns an EgObject
  • the set function has one parameter (the value set) and returns an EgObject.
  • WOOL verb can be used as a function or a variable like: CAUTION: Both set and get functions must return an bf EgObject value.
  • the active value being defined by: int value Active 1;
  • EgArgumentMust be check the type of an argument void EgArgumentMustBe (number, object, class) int number; EgObject object; EgClass class;
  • EgClass superClass char * name
  • EgClass EgTooIkitClassCreate name, class, toolkit ype
  • EgClass class char * name; caddr t toolkit_type; EgClass EgTooIkitSynonymousClassCreate (name, class, toolkitjype)
  • EgClass class char * name; caddr_t toolkit_type; EgClass EgTooIkitEnumerationClassCreate (name, toolkitjype) char * name; caddr_t toolkit_type;
  • EgClassInt "UnsignedLong”
  • EgClassTranslationTable EgTooIkitClassCreate
  • EgTooIkitSynonymousClassCreate does no. really create a new class but make it available in C and WOOL APPENDIX 7 (continued)
  • EgClassDestroy Destroyes a class void EgClassDestroy (class); EgClass class;
  • EgMethodName method void EgClassSetMethod (class, methodName, methodFunction)
  • EgConvenientWidgetClassCreate EgNormaIWidgetClassCreate Record a new widget class
  • EgNormaIWidgetClassCreate prefix, wool ame, toolkit Jd
  • char * prefix char * wool_name
  • WidgetClass toolkitjd
  • EgConvenientWidgetClassCreate prefix, wool iame, toolkitjd, creator
  • char * prefix char * wool_name
  • WidgetClass toolkitjd EgWidgetCreator creator
  • CAUTION Convenient class must be recorded after their real class.
  • EgFunctionDefine allows to create a new function.
  • tne name of the îunc on as it will be called from WOOL APPENDIX 7 (cont'd) function is the function.
  • arity indicates the number of arguments expected. It may vary from 0 up to 5 or may be be NARY.
  • EgArgumentMustBe (0, objectO, EgClassInt);
  • EgArgumentMustBeO, objectl, EgClassInt); resuit ((int) EgObjectGetCValue (objectO)) - ((int) EgObjectGetCValue (objectD); return EgObjectCreate (EgClasslnt, resuit);
  • Widget widget caddr_t closure; caddr_t callData;
  • EgFunctionDefine ("sub", substraction, 2); EgFunctionDefine ("add”, addition, NARY);
  • EgListAppendltem - append an object to a list void
  • EgListAppendltem (list, item) EgList list; EgObject item;
  • EgListContainltem (list, item) EgList list; EgObject item;
  • EgListCreate create a list
  • EgList EgListCreate () EgList EgListCreateO 0 EgList EgListCreate 1 (object) EgObject object;
  • EgList EgListCreate2 (objectl, object) EgObject objectl, object2;
  • EgList EgListCreate3 (object l, object2, object3) EgObject objectl, object2, object3;
  • EgList EgListCreate4 (objectl, object2, object3, object4) EgObject objectl, object2, object3, object4;
  • EgList EgListCreate ⁇ (object l, objectl, object ⁇ , object4, object ⁇ ) EgObject objectl, object2, object3, object4, object ⁇ ;
  • EgListCreate and EgListCreateO are identical.
  • EgListCreatel, EgListCreate ⁇ are provided for convenience.
  • Thesis functions use EgObject- IncreaseRef. See also EgList-CreateFromArray.
  • EgList EgListCreateOfSize size, item int size
  • EgObject item
  • EgListCreateOSize creates a list of a given size. The following example creates the list (nil nil nil).
  • CAUTION the array must not be free. It must not be modified directiy to avoid error with reference jount of items or length of the list.
  • EgListGetltem EgListSetltem get or set an item in a list
  • EgList list int position; int EgListSetltem (list, position, object)
  • EgList list int position; int object;
  • EgListGetltem returns EgNIL if position is not correct.
  • EgListSetltem returns True if done and False otherwise
  • EgListGetPosition - get the position of an object in a list int EgListGetPosition (list, item) EgList list; EgObject item;
  • EgListlnsertltem - insert an object in a list void
  • EgListlnsertltem (list, position, item)
  • EgList list EgList list; int position; EgObject item;
  • Insert an object in a. list at a given position except if position is less than O (insertion is done at the begining of the list) or if position is more than the length of list (insertion is done at the end of the list).
  • the first position in the list is given by 0. See also: EgListAppendltem.
  • EgListMoveltem - move an element inside a a list int EgListMoveltem (list, ofdPosition, newposition) EgList list; int oldposition; int newposition;
  • EgListRemoveltem l Removes one item int EgListRemoveltem (list, position) EgList list; int position;
  • Thiese are the same functions as corresponding UNIX ones. See also: MALLOC (3).
  • the resuit is equal but not necessarily eq. For a list, only the top level is copied.
  • the second function EgObjectCreateFromXtArgVal is intended only for EXPERT who uses the resuit of toolkit functions which return XtArgVal values such as XtGetValues or XtConvert.
  • EgObjectDecreaseRef EgObjectlncreaseRef - decrease or increase the reference count of an object
  • WOOL use a reference count garbage collection algorithm. When an object is referenced from an other one, its reference count must be incremented. And when an object is no longer referenced, its reference count must be decremented. WOOL destroys objects with a reference count equal to 0.
  • This function has the same semantic as the WOOL function equal.
  • Evaluation of many objects returns the object itself. Evaluation of list calls the function found as first item with following items as parameters.
  • EgObjectEval returns EgERROR if an error occurs.
  • EgObjectlnternEval doesn't care of errors. So it must not be used except if you are quite sure that the code using it is executed from a WOOL function.
  • EgObjectlsSubclass - Checks the class of an object int EgObjectlsSubclass (object, class) EgObject object; EgClass class;
  • EgObjectModify Sets C value of an object void
  • EgObjectModify object, anyCValue
  • object anyCValue
  • object anyCValue
  • object anyCValue
  • object anyCValue
  • object anyCValue
  • object anyCValue
  • object anyCValue
  • object anyCValue
  • object anyCValue
  • object anyCValue
  • EgPointerDefine To Define a variable shared by the interpreter and the application, use EgPointerDefine.
  • the shared value is always an integer.
  • EgPointerDefine ⁇ name, pointer) char * name; EGCValue tip " APPENDIX 7 (continued)
  • EgVariableSetCValue The difference with EgVariableSetCValue is that the argument is not a WOOL value but an address to a C value. This allows the interpreter and the application to set the value of the same memory address. From the WOOL side, an object of type Integer is created to hold this value.
  • EgPutChar print on current output stream void EgPrintf (char * string, void * arg) void EgPutsfc * string) void EgPutChar (char c)
  • EgVariableGetObject EgVariableSetObject - get or set wool value of a variable void EgVariableSetObject (name, object) char * name;
  • EgObject object EgObject EgVariableGetObject (name) char * name;
  • Thiese functions are different from EgVariableSetCValue and EgVariableSetCValue which manipulate C values and implicitly create a WOOL object.

Abstract

La présente demande concerne un outil interactif de définition d'interface utilisant un langage interprété ayant une représentation similaire pour les données et les programmes et à interpréteur embarqué avec le programme de définition d'interface constitué d'un mélange d'instructions en langage 'C' et d'instructions en langage interprétable qui coopère avec une bibliothèque d'objets interactifs 'widget' de commande 'X/MOTIF' et une bibliothèque d'objets graphiques 'GO'.

Description

i UTILISATION D'UN LANGAGE A INTERPRETE EMBARQUE POUR LA REALISATION D'UN OUTIL INTERACTIF DE DEFINITION D'INTERFACE UTILISATEURS.
La présente concerne l'utilisation d'un langage à interprète embarqué pour la réalisation d'un outil interactif de définition d'interface utilisateurs.
Les logiciels ' interactifs ont des contraintes très spécifiques, dont la plus important et qu'ils peuvent être changés très souvent. En effet, pour des raisons ergonomique, il est difficile de développer des programmes d'utilisation aisée en une seule fois. La première version est toujours un échec et nécessite de nombreux changement.
Par ailleurs, il peut être souhaitable de changer la façon de déclencher une même action, pour s'adapter à un contexte ou un utilisateur différent.
Enfin, un bon programme qui dispose d'une mauvaise interface peut connaître un succès commercial mitigé.
Le but de 1'invention est de proposer un outil de développement d'interfaces particulièrement flexible qui soit utilisable quelque soit l'application. Cette interface a par exemple été développé pour le domaine des systèmes UNIX utilisant X/ INDOW et X/MOTIF marques respectivement déposées par le M.I.T et l'Open Software Foundation.
Ce but est atteint par le fait que l'outil interactif de définition d'interface utilisant un langage du type LISP interprété et 1'interpréteur ( OOL) est embarqué avec le programme de définition d'interface de l'application et aussi avec l'application produite
Selon une autre particularité le langage a une représentation similaire pour les données et les programmes. Selon une autre particularité, le programme de définition coopère avec une bibliothèque d'objets interactifs " idgets" de commande "X/MOTIF" et une bibliothèque d'objets graphiques "GO" .
Selon une autre particularité le programme de l'application est constitué d'un mélange d'une part d'instructions en langage C qui est un assembleur portable de haut niveau manipulant des objets et d'autre part d'instructions en langage interprétable.
Selon une . autre particularité 1 ' interpréteur est orienté objet en langage LISP.
Selon une autre particularité l'interpréteur utilise des tableaux.
Selon une autre particularité le noyau de 1 ' interpréteur est constitué comme un matrice a deux dimensions, l'une de type contenant les listes, les chaînes, les nombres, l'autre de sélecteur, contenant des fonctions telles que "eval, print, free, add, ... " .
Selon une autre particularité 1' interpréteur WOOL comporte un ramasse-miettes ou glaneur de cellules (Garbage collector,
GC) qui permet de temps à autre et de façon cyclique de balayer la mémoire à la recherche d'objets inutilisés dont l'espace peut être réutilisé, ce qui se fait sans interrompre
1'utilisation.
Selon une autre particularité, ce glaneur de cellules
(Garbage Collector, GC) est incrémental.
Selon une autre particularité le glaneur de cellules utilise des compteurs des références et un mécanisme de regroupement des objets par taille pour limiter la fragmentation de la mémoire. Selon une autre particularité les fonctions de l'outil interactif sont décrites sous forme d'un programme interprété.
Selon une autre particularité 1'archivage de la présentation de l'interface éditée et effectué comme celui d'un programme WOOL.
Selon une autre particularité la spécification interactive de la géométrie d'assemblage de ces objets est traduite en un fichier utilisable par une application archivable sur disque contenant la présentation d'un interface utilisateur sous la forme d'un programme en langage "WOOL".
Selon une autre particularité le comportement dynamique des objets interactifs ("widgets") est défini par un ensemble de procédure de rappel ("callbacks") écrit en langage "WOOL" et qui désigne des fonctions de l'application appelées par la boite à outils "X/MOTIF" lorsqu'un événement d'entrée est reçu par l'un des "widgets".
Selon une autre particularité le programme de définition d'interface est extensible par l'ajout de classes de "widgets" effectué en décrivant en langage WOOL les nouveaux types d'attributs de cette classe pour rendre les nouveaux "widgets" éditables.
Selon une autre particularité chaque "widget" est pointé par un objet "WOOL" de la classe "WOOL" correspondant à la classe du "widget", les attributs supplémentaires étant attachés directement à l'objet "WOOL".
Selon une autre particularité chaque objet WOOL est une structure en langage C autotypé , contenant le type de 1'objet et l'information du compte de référence.
Selon une autre particularité à chaque objet interactif "widget"" est associé à un identifieur "WOOL" unique alloué de façon incrémentale. Selon une autre particularité l'outil interactif de définition d'interface "EGERIA" comporte un programme permettant l'affichage d'un menu de base comprenant une fonction d'édition "edit", une fonction création "create" et une fonction de géométrie "geometry".
Selon une autre particularité la fonction création permet la création de tout "widget" à partir d'un menu, et après sélection d'une ligne de menu, change la forme du curseur et un clic souris dans un objet interactif contenant "widget container" installera l'objet du type choisi dans cet objet interactif contenant ("container") .
Selon une autre particularité la fonction édition permet 1'édition des attributs d'un "widget" dans une fenêtre séparée et permet de couper, coller, copier ou dupliquer le jeu des "widgets" sélectionnés ainsi que d'éditer les attributs des "widgets" parent d'un "widget" sélectionné ou de rendre le parent d'un "widget" couramment sélectionné le nouveau "widget" sélectionné.
Selon une autre particularité la fonction géométrie "geometry" permet de gérer la géométrie d'un ensemble des "widgets" sélectionnés qui peuvent être alignés par le sommet, par le bas, par le côté droit, par le côté gauche ou avoir leur largeur ou hauteur identique.
Selon une autre particularité une fonction édition permet l'affichage d'une fenêtre d'édition des attributs d'un "widget" divisée en deux zones, l'une comportant les fonctions appelées de l'application des procédures de rappel "callback", l'autre comportant les attributs matérialisés par un jeu de sous-éditeurs.
Selon une particularité le premier sous-éditeur est constitué d'un bouton bascule pour entrer des attributs booléens. Selon une autre particularité le second sous-éditeur est constitué d'un bouton poussoir affichant un menu affichant les listes des valeurs d'un type énu éré (ex : alignement d'un texte à gauche, à droite ou centré) .
Selon une autre particularité le troisième sous-éditeur est constitué d'une zone de texte pour la saisie des textes ou des valeurs numériques.
Selon une autre particularité lε fonction d'éditeur des objets interactifs de type "Shell widgets" de MOTIF, c'est à dire représentant une fenêtre (X/Windows) de premier niveau, est lancée en sélectionnant d'abord le menu de sélection de parent "sélect parent" et ensuite la fonction d'édition d'attribut "édit attribute".
D'autres caractéristiques et avantages de la présente invention apparaîtront plus clairement à la lecture de la description ci-après faite en référence aux dessins dans lesquels :
La figure 1 représente de façon schématique l'architecture du logiciel de définition d'interface,
La figure 2 représente la fenêtre principale présentée par ce logiciel pour la définition d'une interface,
La figure 3 représente une fenêtre affichée par ce logiciel permettant l'édition de forme d'un objet.
La figure 4A et 4B représente une fenêtre affichée par ce logiciel permettant l'édition des attributs d'un objet interactif, et respectivement des procédures de rappel.
La figure 5 représente la fenêtre définie pour une application particulière par le logiciel de définition d'interface. L'outil interactif de définition d'interface (1) "Egeria" est constitué comme représenté à la figure 1:
- d'un éditeur (10) permettant de créer ou de modifier une interface,
d'une bibliothèque interpréteur "WOOL.LIB" (11) dont l'édition de lien avec le code de l'application donnera 1'application complète,
et d'une bibliothèque éditeur "Edit.LIB" (12) dont l'édition de lien avec le code de l'application donnera un éditeur permettant l'exécution réelle des fonctions de l'application. Ces deux bibliothèques "WOOL.LIB" et "Edit.LIB" sont fournies ensemble dans la bibliothèque "libEg.a".
Cet outil interactif de définition d'interface (10) doit être associé, pour fonctionner, avec une bibliothèque d'objets interactifs de commande appelée boite à outils d'objets de commandes, "X/MOTIF" (20) dans l'environnement UNIX, et une boite à outils d'objets graphiques constituée par une bibliothèque d'objets graphiques "GO" (21) . Cette bibliothèque puissante en langage C++ fournit des services graphiques qui ne sont pas disponibles à ce jour dans l'environnement UNIX et qui permettent de créer et de commander des rectangles, des ellipses, des lignes polygonales, des textes éditables en plusieurs fontes et des images.
L'outil de définition coopère également avec une librairie Xlib (3) qui constitue la couche protocole spécifiant le codage du flux d'informations circulant entre l'application et le serveur de fenêtrage et la couche bibliothèque constituant 1'interface de programmation permettant d'accéder au système de fenêtrage.
EGERIA (10) couvre la couche présentation qui décrit de façon statique l'ensemble des objets constituant une interface, c'est à dire leur hiérarchie et leur attribut, et la couche dialogue qui décrit l'aspect dynamique de l'interface, c'est à dire son comportement.
Enfin une couche supplémentaire (5) est constituée par l'application qui comporte la couche sémantique contenant ce qui dans l'application ne concerne pas l'interface.
L'interpréteur "WOOL.LIB" (11) est un petit interpréteur Lisp écrit en langage C dans lequel la mémoire est gérée explicitement par compteur de référence et qui comporte un typage interne permettant la vérification de type, le déclenchement de procédure par envoi de messages conformément à une approche orientée objet.
L'interpréteur fournit un ensemble de type de données de base telles que atome, liste, nombre entier, nombre réel, chaine de caractères.
L'interpréteur "WOOL LIB" (11) utilise des tableaux pour le stockage des listes, ce qui permet d'accélérer le balayage des listes.
Cet ensemble de type de base est extensible en ce que l'on peut introduire un nouveau type de base tel qu'un "widget" permettant la manipulation contrôlée des objets "MOTIF" en "WOOL".
Chaque objet en "WOOL" est formé comme représenté fig. 1B, d'une entête qui comporte un pointeur sur la classe qui est le type (31) de l'objet et le compteur de référence (Ref Cnt) et enfin d'autres informations (attributs) qui dépendent du type de l'objet. Chaque objet "widget" est associé à un identifieur alloué de façon incrémentale.
Chaque widget crée par EGERIA se voit allouer un identifieur unique du type "@000012@". L'unicité de cette référence est garantie pour toute la durée de la session EGERIA. Si de telles références sont utilisées dans le texte des callbacks en "WOOL" attachées aux widgets, une sauvegarde (ou un couper) suivie d'une restauration (ou d'un coller) maintient la cohérence mutuelle des références. Ce n'est pas le cas si les références mutuelles sont réalisées en utilisant des atomes en "WOOL" : dans ce cas un atome n'ayant qu'une valeur, les deux callbacks feraient référence au même widget.
L'utilisation des identifieurs uniques de widgets dans le code de dialogue permet de construire des fenêtres dont les comportements sont facilement duplicables. Prenons par exemple une fenêtre éditée interactivement et contenant un bouton et un texte. Le callback associé au bouton est le suivant :
(onXmNactivateCallback (widget) (widget-unmap @00002@))
Lorsque le bouton est enfoncé en mode exécution, le texte disparaît (la commande "unmap" ayant pour objet de rendre invisible le widget donné par son argument) .
Si par une opération de couper/coller on duplique la fenêtre, le comportement sera également dupliqué, EGERIA change le code du callback associé au bouton dupliqué en :
(on XmNactivateCallback (widget) (widget-unmap 00005@))
si il se trouve que §000005§ est 1•identifieur unique généré pour le texte dupliquée.
Un tel procédé permet d'éviter d'avoir à changer manuellement le code des callbacks lors d'une duplication.
Le type de l'objet permet d'accéder dans le noyau de l'interpréteur "WOOL" (WOOL KERNEL) à une classe (110) qui contient une liste de méthodes, chaque méthode (Method) est une fonction telle que par exemple la fonction "Print". Ainsi la fonction "Print" d'un objet sera adaptée au type de l'objet traité. Les classes constituent les colonnes du tableau matriciel de la figure 1B et les méthodes les lignes du tableau. La liste des méthodes embarquée dans l'interpréteur WOOL.LIB, c'est à dire livrée avec l'éditeur (figure en annexe 6) .
Dans l'interpréteur "WOOL.LIB" (11) un atome peut seulement avoir une seule valeur alors que dans les langages Lisp traditionnels, on peut donner à une variable et à une fonction le même nom sans conflit.
Cet interpréteur propose un jeu de primitives "Lisp" facilement extensibles.
Enfin l'interpréteur "WOOL.LIB" est écrit d'une façon orientée objet et les objets sont typés de façon interne à 1'interpréteur.
Une autre particularité de l'interpréteur est qu'il est réentrant, ceci signifie qu'une fonction lancée par lui peut à nouveau relancer une interprétation qui aura accès à la même pile de données WOOL.
Le ramasse-miettes constitué par la vieille méthode de comptage de référence nécessite de prendre un soin supplémentaire quand on créé des structures qui s'auto- rêférencent. L'interpréteur "WOOL.LIB" comporte un ramasse- miettes ou glaneur de cellules (Garbage collector, GC) qui permet de temps à autre et de façon cyclique de balayer la mémoire à la recherche d'objets inutilisés dont l'espace peut être réutilisé, ce qui se fait sans interrompre l'utilisation. Ce glaneur de cellules (Garbage Collector, GC) est incrémental. Le glaneur de cellules utilise des compteurs des référen is permettant l'allocation d'objets de taille quelconque et un mécanisme de regroupement des objets par taille pour limiter la fragmentation. L'interpréteur "WOOL.LIB" met en oeuvre un glaneur de cellules (garbage collector, ou GC) , permettant la récupération automatique de la mémoire inutilisée, ce qui permet au programmeur de ne pas se soucier de l'allocation et de la désallocation des objets utilisés. Un tel système permet une programmation très rapide, car les programmes n'ont nul besoin de contenir le code pénible à concevoir et à vérifier qui est traditionnellement celui de la gestion explicite de la mémoire utilisée.
Le GC de "WOOL.LIB" est incrémental en ce qu'il opère de manière continue et sur de faibles volumes de données, contrairement aux GC classiques qui ne sont appelés qu'occasionnellement, pour la récupération d'un volume important de mémoire ; dans ce cas, la période pendant laquelle le GC est actif se traduit par un arrêt perceptible de l'interprétation du programme en cours, ce qui peut être très gênant pour l'utilisateur d'un programme interactif. Un GC incrémental garantit que 1'interprétation se déroule sans à-coup, le surcroît dû au GC étant uniformément réparti sur l'ensemble de l'exécution du programme interprété.
La propriété d'incrémentalité du GC de "WOOL-LIB" est obtenue :
- en maintenant un compteur de référence pour tout objet alloué, celui-ci n'étant libéré que lorsque ce compteur passe à zéro.
- en considérant que la plupart des objets alloués sont en fait désalloués très rapidement après leur création : de manière régulière (après l'exécution de toute instruction contenue dans une séquence d'expressions) , une zone spéciale est balayée, à la recherche de tels objets.
Les noms qu'EGERIA donne aux widgets "X/MOTIFS" sont compatibles avec les conventions imposées par X/Window et X/Motif qui permettent la paramétisation des interfaces (fichier X default, option de lancement des programmes) .
Le code contenu dans EGERIA contient les références nécessaires à l'édition de liens.
Dans l'utilisation d'EGERIA avec la boite à outils "X/MOTIF" (20) on place nécessairement dans le code d'EGERIA (10) :
- la description des types de bases ("widget", procédure de rappel "callback", etc..., par exemple XmTopLevelShell cf(40) annexe 4) ,
les classes d'objets de l'interface (push button, scrollbar, menubar, etc..) et les primitives (toolkit-init, "widget" create, etc..., par exemple on XmNinputCallback du "widget" XmDrawingArea cf(432) annexe 4)
- les types dérivant de types de base (énuméré, dimension, etc... , par exemple XmNwidth de XmTopLevelShell)
- les attributs propres à chaque classe
Des fonctions de haut niveau écrites à partir des primitives seront placées dans le fichier externe (14) . Ceci permet de rajouter de nouvelles classes d'objets de l'interface.
La structure d'EGERIA (10) se caractérise par une boucle principale de lecture de l'entrée qui distribue les événements (clic souris, action clavier) reçus aux différents composants du programme. Un exemple d'une telle boucle (511 annexe 5) figure dans l'exemple d'application donné par la suite dans les annexes 4 et 5.
L'interprète "WOOL.LIB" ne contient pas la boucle principale de l'application qui reste contrôlée par l'application (5).
Cette boucle est chargée d'appeler la fonction de lecture motif puis de distribuer l'entrée reçue. Cela signifie qu'il existe un niveau de programmation où l'on peut décider pour chaque événement X/Window et donc pour chaque événement "Motif" de l'entité chargée de traiter l'événement. Ce peut être "Motif" qui appellera les procédures de rappel "callbacks" définis pour le ""widget"" associé à l'événement ou bien un autre composant tel qu'EGERIA.
Dans le cas défini par EGERIA, une "callback" telle que par exemple "call-back dog:draw" écrite en Lisp (cf 435 annexe 4) ou "call-back dogrstep" (cf 4412 annexe 4) est formée d'un appel du point d'entrée principal (530 respectivement 531 annexe 5) de l'interpréteur "WOOL.LIB" qui va exécuter la méthode associée (523 respectivement 525 annexe 5) écrite en langage C et rend la main aussi vite que possible.
Enfin l'utilisation d'un système hybride fonctionnant en langage Lisp et en langage C pose le problème des conversions systématiques des paramètres des fonctions de C vers Lisp et de Lisp vers C. La solution était de faire utiliser par le système Lisp les structures naturelles de C autant que possible, mais en les préfixant avec une entête en langage "WOOL" (par exemple 522 annexe 5) .
La figure 1B représente la structure du noyau (WOOL KERNEL) qui est organisée selon un tableau dont chaque colonne correspond à un type d'objet. Un objet étant référencé par son type qui permet ainsi d'accéder à la méthode de traitement des messages que peut traiter l'objet.
Dans le mode exécution, l'interpréteur "WOOL.LIB" (11) a essentiellement poμr tâche de charger le fichier (13) de description d'interface,par exemple constitué par l'annexe 4, lorsque cette interface a été élaborée. "WOOL.LIB" exécute ce fichier de description d'interface (14) comme un programme en langage WOOL pour reconstruire 1'interface de 1'application et ensuite interprète tous les événements survenant en provenance de la boite à outils MOTIF pour, soit réagir de façon purement dynamique dans 1'interface sans réveiller l'application, soit envoyer l'événement à l'application par l'intermédiaire d'un point d'entrée de celle-ci.
L'éditeur EGERIA (10) possède principalement deux modes de fonctionnement, 1'édition et 1'exécution.
Le mode "édition" est celui dans lequel on peut librement modifier l'interface de l'application et le mode "exécution" permet de tester 1< omportement de 1'interface.
Enfin, si l'éditer tilisé résulte de l'édition de lien de la bibliothèque éd r (12) avec l'application (5) alors les fonctions de 1'app. t.'on sont effectivement appelées.
Pour L'édition des objets, on retrouve les fonctions classiques créer, couper, copier, coller, éditer, les attributs, défaire, avec toutefois des nouveautés importantes qui sont l'édition des formes (FORM EDITOR) , l'édition des attributs (Attribute Editor) et la hiérarchie des objets. Les objets ("widget") peuvent se classer en deux catégories, les objets élémentaires et les contenants ("container widgets") qui peuvent contenir plusieurs objets. Parmi les contenants, certains comme les objets interactifs père ou coquille ("shell widgets") n'ont pas de contenant et sont créés au premier niveau (exemple "Top level Shell" annexe 4) .
Un widget MOTIF FORM est un widget "contenant" dont les fils sont automatiquement positionnés ou retaillés lorsque le widget FORM est retaillé. La spécification interactive du comportement des fils d'un tel widget est réalisée à l'aide d'un formulaire spécial, dit éditeur de forme "FORM EDITOR", qui permet de définir de manière aisée l'ensemble des comportements fournis par MOTIF.
Le comportement d'un fils du widget FORM (par exemple XmPushButton (321, figure 3)) est spécifié en donnant la valeur d'un attachement pour les 4 bords du widget, respectivement désignés par top (322) , right (323) , left (324), bottom (325). Un attachement peut être NONE (pas d'attachement (323)) FORM (attachement par rapport au bord correspondant du FORM (322,324)), POSITION (attachement proportionnel à la dimension horizontale ou verticale du widget FORM (3262)) ou WIDGET (attachement relatif à un widget fils du même FORM (325)).
Avec chaque attachement, il est possible de spécifier une distance supplémentaire (3261) (offset) de décalage par rapport à la position spécifiée dans la zone d'édition (3262) .
Conformément à la figure 3 représentant le formulaire d'édition de forme "FORM EDITOR", quatre menus sont affichables pour spécifier le type d'attachement du widget fils considéré. Pour chaque attachement, une flèche (328) interactive montre quel attachement est "courant". La sélection d'un attachement quelconque se traduit par la mise à "courant" de l'attachement positionné.
Pour éditer un fils de FORM à l'aide de cet éditeur, il convient de sélectionner le widget et d'utiliser la commande d'édition de forme "FORM EDITOR" (2022) activable à l'aide du menu "Edit" (202). La classe, le nom et 1•identifieur du widget apparait alors dans une zone de texte (321)de la fenêtre de l'éditeur de FORM, qui visualise alors les caractéristiques du widget qui concernent son comportement comme fils du widget FORM.
Deux zones de texte décrivent le décalage (3261) (offset) et la position (3262) (lorsque l'attachement est POSITION) du widget correspondant à l'attachement courant. Lorsque l'attachement courant change, ces zones de texte sont mises à jour. Lorsque l'attachement n'est pas POSITION, la zone de texte marquée "position" est inactive, et son titre apparait en grisé, comme sur la figure 3. Il est possible de déplacer ou de retailler interactivement avec la souris le widget fils; dans ce cas la commande est exécutée comme si elle avait été passée à partir de l'éditeur FORM, et les zones de texte correspondant au décalage et/ou à la position sont mises à jour.
L'éditeur permet ainsi la création d'objets élaborés (container "widget") qui peuvent se composer de plusieurs objets mais qui sont considérés comme des objets simples, c'est à dire qu'on peut les coller, les couper et les copier en une seule opération.
Tous les objets sont réalisés à l'aide de la fonction création (203, figure 2) "create" du menu principal (200) qui permet d'installer un objet dans un objet container, après avoir sélectionné un objet par un clic souris. Ce menu principal (200) comporte en plus les fonctions classiques fichier (201) "file" et aide (206) "Help" et les fonctions spécifiques "EDIT", "CREATE", "GEOMETRY", "TOOLS".
L'édition de l'apparence de l'interface est effectuée soit directement à la souris en modifiant la taille ou la position des "widgets" à l'intérieur de leur contenant, soit en utilisant des formulaires contenant les différents attributs d'un ou plusieurs objets. Pour cela, on fait appel à la fonction (202) "Edit" (édition) qui permet l'édition des attributs d'un objet dans une fenêtre séparée et permet d'éditer les attributs des objets père d'un objet sélectionné et également de couper, coller, assembler, copier un jeu d'objets sélectionné. Enfin l'éditeur d'interface permet de modifier la géométrie de la présentation en faisant appel à la fonction (204) "geometry" (géométrie) qui permet par exemple d'aligner un ensemble d'objets sélectionné par le sommet, le côté ou la base, ou de faire varier les dimensions de l'ensemble de ces objets, soit en largeur, soit en hauteur. Le menu création (203) "CREATE" comporte comme représenté à la figure 2, une possibilité de choix parmi les différents objets disponibles dans la librairie X/MOTIF. Ces objets sont constitués par une famille de boutons (2030) , un contenant (container) (2032), un objet élaboré (2033), un objet simple (2031) , un objet du type message (2034) , un objet du type dialogue (2035) , un objet du type menu (2036) et un objet du type contenant (2037) ("Shell") qui lorsqu'il a été sélectionné fait apparaître une deuxième carte de menu permettant de choisir parmi les attributs niveau maximum (2371) , contenant (2372) (Shell) , contenant privilégié (2373) (override Shell) , contenant transitoire (2374) (transient Shell) , contenant général (2375) (Top level Shell) , contenant d'application (2376) (Application Shell) .
La partie attribut est réalisée avec un jeu de sous-éditeurs. Ces sous-éditeurs sont automatiquement créés par lecture d'une description des classes de la librairie (11) "X/MOTIF". Il y a trois sortes de sous-éditeurs. Un sous-éditeur bouton bascule pour entrer des attributs booléens, un sous éditeur bouton poussoir affichant un menu pour des types énumérés et un sous éditeur zone de texte pour des valeurs textuelles ou numériques, telles que celles figurant en annexe 4 sous la référence (436) .
La sélection dans la barre de menu de la fonction "edit"(202) permet d'éditer par la fonction 2021 "Attribute Editor" les attributs d'un "widget". Cette solution provoque l'affichage d'une fenêtre du type de celle représentée à la figure 4A.
Cette sélection provoque l'affichage d'une fenêtre du type de celle représentée à la figure 4A qui comporte un menu constitué de plusieurs cartes (311, 312) superposées accessibles par des boutons (3110 à 3114 et 3121 à 3124) jouant le rôle d'onglet. Chaque carte regroupe les attributs correspondants à une catégorie de "widget". Ces catégories sont l'apparence lancée par le bouton 3110, la géométrie lancée par le bouton 3111, le comportement lancé par le bouton 3112, les contraintes lancées par le bouton 3113, et les procédures de "callback" lancées par le bouton 3114. Ceci permet à l'utilisateur d'accéder de manière commode à un attribut parmi les très nombreux attributs fournis par le logiciel X/MOTIF.
Sur la figure 4A, le bouton de la carte correspondant à l'apparence 3110 est représenté en avant par rapport aux autres boutons 3111, 3112, 3113,3114 représentés enfoncés, c'est à dire en arrière plan. L'éditeur d'attribut apparence correspondant à ce bouton représenté en avant plan a été activé par un clic souris sur la zone du bouton, et affiche la fenêtre correspondante (313) pour permettre l'édition d'attributs. Dans le cas de la figure 4A, ce sera la fenêtre dont la partie 313 comporte les attributs permettant de définir l'apparence du "widget" en cours d'édition. Ces attributs sont constitués de zone de texte permettant de définir dans la zone 3130 l'arrière-plan, dans la zone 3131 l'arrière-plan de la matrice de points, dans la zone 3132 l'épaisseur de l'ombre de défaut de bouton, dans la zone 3133 la profondeur, dans la zone 3135 la liste de police de caractères, dans la zone 3136 l'avant-plan, dans la zone 3137 l'étiquette de la matrice de points, dans la zone 3138 l'étiquette de la chaîne, ici en l'occurrence XmPushButton, dans la zone 3139 le type d'étiquettes, et dans la zone 31390 l'apparition en tant que défaut.
Les attributs affichés dans la partie de fenêtre 313 sont les attributs visibles qui apparaissent lorsque le bouton 3101 portant l'étiquette "courant" (CURRENT) est enfoncé.
La définition des attributs se fait de façon classique, en venant cliquer avec la flèche souris la zone de texte de l'attribut souhaité et en introduisant au clavier les valeurs textuels ou numériques. Une fois chaque attribut définis, la sélection de bouton 3123 portant la commande applique (Apply) permet d'effectuer la validation globale de tous les attributs modifiés au cours d'une itération avec la feuille d'édition d'attributs. La sélection du bouton 3122 portant la commande démarque (unmark) , permet d'annuler toutes les modifications faites avant une validation globale. La sélection du bouton 3121 portant la commande marque permet de valider les modifications sans passer par une validation globale.
La sélection du bouton 3124 portant la commande vue (view) permet de faire passer un nom d'attribut de la l^iste des attributs visibles à la liste des attributs invisibles et réciproquement.
L'enfoncement de ce bouton (3124) par clic de la flèche souris sur la zone du bouton déclenche au sein de l'éditeur d'attributs une fonction d'affichage de la fenêtre 3110 permettant de visualiser à la fois les attributs visibles représentés dans la zone 313 et les attributs invisibles représentés dans une zone 314 de la fenêtre 3110. Cette fenêtre 3110 comporte également des boutons fonctionnels permettant de valider par le bouton OK la sélection effectuée, d'invalider par le bouton 316 la sélection ou les modifications apportées, de déplacer par le bouton 317 un attribut de la zone visible à la zone invisible ou vice versa, de charger par le bouton 318 des attributs et par le bouton 319 de sauvegarder la sélection ou les modifications de sélection qui ont été apportées.
Pour le bouton (view ail attributes) une commande additionnelle 310, disponible dans la feuille d'édition d'attribut (view ail attributes) sous la forme d'un bouton radio permet de ne pas tenir compte de la spécification de la visibilité et d'afficher tous les attributs dans la fenêtre 313. Lorsque l'on sélectionne le bouton radio courant 3101, seuls les attributs portant la spécificité visible sont affichés dans la fenêtre 313.
La sélection de la carte "geometry" par le bouton 3111 permet de lancer une fonction d'édition permettant d'afficher les attributs de sélection et de modification de la géométrie d'un widget. La carte "comportement" par l'activation du bouton 3112 perm t de lancer une fonction d'édition permettant d'afficher les attributs définissant le comportement d'un widget et de définir quel sera son comportement en fonction des attributs sélectionnés.
La sélection du bouton 3113 active la fonction d'édition des contraintes et permet d'afficher les attributs des contraint s - attachés à un objet déterminé.
Selon le ype d'objet des éditeurs sont inactivés.
Par exemple, pour les boutons poussoir dont les attributs sont définis dans la fenêtre 31, la fonction d'édition des contraintes et de validation globale sont inactives et dans ce cas, le titre apparait en grisé comme représenté dans les boutons 3113, 3123.
Enfin, la sélection du bouton 3114 permet de lancer la fonction d'édition de procédures de rappel.
La partie procédure de rappel "callbacks" est simplement une zone de texte où il est posrible d'éditer les procédures de rappels "callbacks" de l'objet interactif ""widget"". Cette partie est représentée de façon agrandie à la figure 4B. Au- dessus ce la zone de dialogue concernant les procédures de rappels "callbacks" se trouve une boite de texte permettant d'afficher les informations sur le "widget" édité telles que son nom et son numéro de référence. Une procédure de rappel "callback" est ici codée en langage WOOL. Un modèle de base est donné pour chaque procédure de rappel "callback" possible d'un "widget". Par exemple pour éditer le code WOOL exécuté quand un bouton poussoir est cliqué, le modèle de base est (on XmN activate callback (widget) ) . Un pseudo "callback" XmN create callback a été ajouté, il est appelé par EGERIA quand une description d'interface (14) est chargée, après que tous ses "widgets" fils créés dans le même fichier de description aient été créés. Des initialisations additionnelles peuvent être faites à l'intérieur de XmN create callback.
La sélection d'objets parent (tel que par exemple: XmDrawingArea qui est le parent de XmFrame, XmLabel, XmScale et de XmSeparator de l'annexe 4) n'est pas possible directement de façon à éditer les attributs d'un objet "Shell" ou d'un objet général "Top level widget" (XmTopLevelShell), il est nécessaire d'utiliser la commande "Select parent" et ensuite de lancer l'édition d'attributs.
Les objets interactifs créés ("widgets") dépendent beaucoup de l'état courant du fichier X/defaults, les noms donnés aux objets peuvent être utilisés pour positionner les valeurs par défaut des objets créés si ces valeurs n'ont pas été fixées avec l'éditeur. Un jeu minimum et utile de valeurs fixées par défaut qui peut être..utilisé par EGERIA peut être celles définies en annexe 1 dans le fichier X/Defaults (13) .
Une table de traduction contenue dans le fichier X/defaults peut également servir à activer des fonctions internes à Egeria, à partir d'événements UNIX. Ainsi l'événement (21) de l'annexe 2 permettra de sélectionner avec le bouton gauche et de déplacer le ou les "widget"(s) sélectionné(s) par le pointeur. La fonction "EgSelect" permet la sélection d'un "widget" sous le pointeur et la fonction EgMove permet le déplacement du "widget" sélectionné. Le bouton gauche de la souris actionné en même temps que la touche "Shift" permet comme représenté par la ligne 22 de l'annexe 2 , d'ajouter l'objet désigné à la liste des objets sélectionnés. En effet la fonction EgSelect or UnSelect, permet de sélectionner ou de désélectionner un objet désigné par le pointeur. Cette fonction travaille comme une bascule. Enfin 1'actionnement du bouton de droite de la souris produisant l'événement indiqué à la ligne 23 en UNIX déclenchera la fonction EgSetSelect qui permet de tracer un rectangle interactif et de sélectionner les objets situés à l'intérieur du rectangle. La zone rectangulaire est définie par deux coins, l'endroit où le bouton est enfoncé et l'endroit où le bouton est relâché.
Une deuxième table de translation minimale définie à l'annexe 3 est également installée dans le fichier X/Defaults pour permettre l'activation des principales fonctions d'édition à partir du clavier. Cette table fait appel à la fonction Eg WOOL Exec qui exécute une expression en langage WOOL qui est la valeur de l'atome donné en tant qu'argument. Les atomes préfixés par le terme "Custom" sont définis dans le fichier Edcustom.G. Ceci est la façon standard de personnaliser le comportement de base de l'éditeur.
Un exemple d'application de l'éditeur d'interface décrit en relation avec les figures 1 à 4 sera donné ci-après pour l'édition d'une interface permettant d'afficher comme représenté à la figure 5, un chien (45) en train de courir en permettant par action sur un bouton "One step" (42) de faire avancer le chien d'un pas, par action sur un bouton "Quit"
(43) de terminer l'exécution de l'application, par action sur bouton "Start" (40) de faire courir le chien, à une vitesse modulable grâce à un potentiomètre à glissières (44) , et par action sur un bouton "stop" (41) d'arrêter la course du chien.
L'application comportera plusieurs images successives mémorisées dans une mémoire "Pix ap pdog" (52) qui seront visualisées en les déplaçant dans une aire de dessin "DrawingArea". Pour éditer l'interface, il convient d'abord de créer les "widgets" en utilisant le menu "create". Tout d'abord, il faut créer explicitement un "widget Shell", qui sera dans notre exemple un "widget" général, un "top level", c'est à dire "XmToplevelShell" (40) qui a pour identificateur "§000001§",pour parent "eg:widget-root" et contenant un autre objet (41) "DrawingArea". Ensuite on créera les autres "widgets" qui comporteront tous un identificateur, des attributs, un éventuel nom dans EGERIA "eg:name",par exemple "speed-widget"(4510) et un éventuel script, par exemple celui (470) du bouton poussoir "quit" (47) . A chaque fois, l'éditeur demandera d'indiquer le père et la position. Nous créerons une "DrawingArea" où 1'application dessinera le chien à l'intérieur d'une fenêtre de déroulement "scrolled window" (46), définie à l'annexe 4 par l'objet "XmScrolledWindow" (462) et pourvue des barres de défilement "scroll bars" 47,48. Pour créer les objets, l'éditeur dispose des fonctions connues, couper, coller, copier et la liste des objets créés ou sélectionnés se manipule grâce, au bouton de gauche qui permet de sélectionner ou de déplacer le ou les "widgef's, au bouton de gauche qui lorsque la touche "Shift" est enfoncée permet d'ajouter l'objet désigné à la liste des objets sélectionné, au bouton de droite de la souris qui permet de sélectionner tous les "widgets" à l'intérieur d'une zone rectangulaire définie par deux coins, à savoir l'endroit où le bouton est enfoncé, et l'endroit où il est relâché. A l'opération "sélect parent" du menu "edit", le "widget" sélectionné devient le père de celui qui été sélectionné, ceci est indispensable pour sélectionner un "widget" caché par son ou ses fils, par exemple un" Shell" ou un menu. Lorsqu'un objet est sélectionné, sa classe et son numéro d'identification et éventuellement son nom apparaissent dans la fenêtre principale d'EGERIA, comme représenté à la figure 2.
Les "widgets" peuvent ensuite être changé de position et de taille à l'aide de la souris en actionnant le bouton de gauche pour sélectionner et déplacer le ou les "widgets" sélectionnés, ce qui fait intervenir les événements de la ligne 21 de l'annexe 2.
L'action sur le bouton de droite de la souris pour tracer un rectangle dans lequel les objets seront sélectionnés, fait intervenir les commandes de la ligne 23 de l'annexe 2. L'action sur le bouton du milieu de la souris, comme indiqué par la ligne 24 de l'annexe 2 permet de changer la taille d'un ou plusieurs "widgets".
Il est également possible de changer la position et la taille de plusieurs objets à la fois, grâce à des opérations du menu "Geometry", qui comporte une opération "align" permettant le déplacement des objets sélectionnés pour qu'ils soient alignés sur une même verticale à gauche, ou au milieu, ou à droite, ou sur une même horizontale, en haut, ou au milieu, ou en bas.
Une opération "Resize" de ce menu "Geometry" permet de donner la même taille aux objets sélectionnés en largeur ou en hauteur, ou une taille mini ou maximum. L'opération "Distribute" permet de répartir à intervalle régulier les objets sélectionnés, ils peuvent être répartis horizontalement ou verticalement à l'aide du rectangle les englobant ou à l'intérieur de leur père.
L'édition des attributs s'effectue en sélectionnant l'opération (2021) "Attribute" du menu "Edit" pour faire apparaître une feuille de données contenant tous les attributs comme représentée à la figure 4A. Certains attributs ne peuvent être modifiés après la création du "widget". C'est le cas par exemple des attributs XmNscrollingPolicy et XmNscrollBarDisplayPolicy.
Nous appelons "script" le code décrivant la réponse à l'ensemble des callbacks. nous allons détailler les scripts associés à chacun des "widgets. ces scripts sont écrits en WOOL.
- Le Pushbutton "Quit" permet de quitter l'application. Pour indiquer qu'en réaction au message "XmNactivateCallback" le bouton réagira en appelant la fonction "exit", il suffit d'écrire dans le script :
(on XmNactivateCallback(widget) (exit)) .
On notera que le paramètre "widget" est disponible, il indique le "widget" couramment activé, c'est à dire ici le bouton poussoir "PushButton Quit". Le paramètre call_data n'est pas disponible.
- Le bouton poussoir "Pushbutton Step" fait avancer le chien d'un pas. Pour indiquer qu'en réaction au message XmNactivateCallback le bouton réagira en appelant la "callback" "step", définie dans l'application, on écrit dans le script :
(on XmNactivateCallback ("widget" (call-back dog:step 19))
Le nombre 19 passé en argument se retrouvera dans le paramètre client_data de la "callback" C correspondant à step "StepCallback" (525). Il indique par l'instruction C:int movement=(int) client-data (526) ; de combien de pixels avancer le chien. La fonction C correspondante "DrawCallback" (523) pour dessiner le chien est présentée plus loin.
- Le chien est dessiné dans une aire de dessin "Drawing Area" . Il est redessiné chaque fois que nécessaire en appelant la "callback" draw définie dans l'application :
(On XmNexposeCallback (widget) (call-back draw) ) (cf annexe 4 réf. 430)
Lorsque ce "widget" est crée, on initialise l'application en appelant la fonction init par l'instruction "call-back init"(4311) qui définit les "callback" de l'application draw et step, et qui en faisant appel au code C: "InitCallback(widget,client-data,call-data) et InitPixmaps" (532) charge les images de point (pixmaps) correspondant aux différents états du chien par la procédure "InitPixmaps" définie en (5221) . De plus on mémorisera la taille de l'aire de dessin "DrawingArea" dans la variable window-width pour que la fonction step fasse repartir le chien de la gauche chaque fois qu'il sort de l'aire de dessin "DrawingArea" sur la droite.
(on XmNcreateCallback ("widget") (call-back init) (setq window-width (attribute-get "widget" XmNwidth) ) ) (cf annexe 4 référence 431)
La variable window-width est mise à jour chaque fois que la largeur du "widget" change par 1'instruction WOOL :
(on XmNresizeCallback ("widget")
(setq window-width (attribute-get "widget" XmNwidth) ) )
(cf annexe 4 réf. 433) .
Enfin on nomme ce widget drawing-area (434) pour l'identifier depuis le code C qui crée les pi aaps. cela se fait avec la fonction EgVariableGetValue("drawing-area", ...) cf annexe 5 référence 522. il aurait été plus simple de passer le "widget" en paramètre d'init mais cela nous permettra de voir (plus loin) comment consulter une variable LISP depuis le code C.
- Le PushButton "START" fait courir le chien. Pour cela on utilise la fonction work-proc (441) qui mémorise une expression qui est ensuite évaluée chaque fois qu'il n'y a pas d'événement à traiter provenant de X . Cette expression doit être évaluée en peu de temps. Dans notre exemple, elle incrémente un compteur (4411) et fait avancer le chien grâce à la fonction step (4412 ou 4413)) lorsqu'une certaine valeur est atteinte. L'incrément est la valeur d'un "widget" Scale
(451) identifié par un numéro géré par EGERIA, ici @000010@.
L'identificateur d'un "widget" est visualisé quand celui-ci est sélectionné . Il peut facilement être copié et collé. Sa classe et éventuellement son nom sont aussi affichés.
(on XmNactivateCallback ("widget") (work-proc ' (progn (setq count (+ count
(attribute-get @000010@ X NInt-value) ) ) (if (> count 100)
(setq count (- count 100) ) (call-back step 19))))))
Il est important de noter que l'attribut consulté est X NInt- value et non pas XmNvalue. Ceci permet de lever l'ambigûité due (en WOOL) au fait que XmNvalue (pour MOTIF) désigne un entier pour un XmScale et une chaine de caractères pour XmText.
Dans ce dernier cas il faudrait utiliser XmNString-value.
Le compteur est initialisé lors de la création du "widget" :
( on XmNcreateCallback (widget) (setq count O) )
- Le PushButton "Stop" permet d'arrêter la course du chien. Cela se fait aussi par un appel à work-proc cf 442:
(on XmNactivateCallback (widget) (work-proc() ) )
La sauvegarde de 1'interface s•effectue par 1'opération "Save" du Menu "File". Par la suite, le fichier ainsi sauvé peut être relu par l'opération "Load". Quelques remarques sur les conventions de noms s•imposent :
- Les fichiers propres à EGERIA sont préfixés par eg-
II est conseillé de donner au fichier contenant l'interface d'une application le nom de cette application suffixe par.eg. Dans notre exemple nous appellerons dog.eg l'interface générée par EGERIA et dog 1'exécutable.
Si cela ne convenait pas, il faudrait indiquer explicitement le nom du fichier à charger dans la source C de l'application (dans un paramètre de la fonction EgMain) .
Le reste de l'application s'écrit en C. Toutes les librairies utilisées sont écrites en C cf annexe 5. Si ce langage est C++, des modifications aux fichiers à inclure s'imposent. Pour tout autre langage il faudrait générer les fichiers de déclaration des types, des constantes et des fonctions.
Le source complet de l'exemple dog.c est en annexe 5. Nous allons en présenter les principaux éléments.
Il faut d'abord inclure les déclarations de la boite à outil "toolkit". EGERIA fournit le fichier "eg_toolkit.h contenant toutes les déclarations publiques du "toolkit" MOTIF (cf 50) :
#include "eg_toolkit.h" .
Il faut ensuite inclure les déclarations d'EGERIA. Les fonctions ainsi disponibles sont décrites dans le manuel de référence :
#include "egeria.h".
On donne le contrôle de l'exécution à EGERIA grâce à la fonction EgMain.
EgMain(layers, XtNumber(layers) , argc, argv, options, XtNumber(options) , MODE_EXECUTION,
InitCallback, NULL, Null, "EGPATH") ;
}
Le paramètre le plus important, InitCallback (5110) , enregistre la "callback" qui initialise l'application et enregistre les autres callbacks. Cette "callback" est appelée explicitement depuis l'interface par (call-back init) .
Il est conseillé de reprendre le code donné en exemple dans dog.C. Seules les callbacks seront modifiées pour d'autres applications. La fonction EgMain et ses paramètres permet d'effectuer les initialisations nécessaires et appelle ensuite EgAppMainLoop qui boucle sur l'appel à XtAppNextEvent et EgDispatchEvent.
La "callback" InitCallback a deux rôles : initialiser l'application et enregistrer les liens entre l'interface et 1'application.
Côté application, dans notre cas, on crée les pixmaps correspondant aux différentes étapes de la course du chien dans la fonction InitPixmaps.
Côté lien avec l'application, on enregistre sous les noms draw et step les callbacks DrawCallback et StepCallback grâce à la fonction EgCallbackDefine. on fait aussi de window-width une variable LISP un peu particulière car elle partagera l'adresse de la variable C windowWidth.
void
InitCallback(widget, client_data, call_data) Widget widget; /* UNUSED */ caddr_t client_data /* UNUSED */ caddr t call data /* UNUSED */ {
InitPixmaps() ;
EgCallbackDefine("Draw", DrawCallback) ; EgCallbackDefine("step" , StepCallback) ;
EgPointerDefine("window-width" , &windowWidth) ;
void DrawCallback(widget, client_data, call_data) Widget widget; /* UNUSED */ caddr_t client_data /* UNUSED */ caddr_t call_data /* UNUSED */ XCopyArea(DISPLAY,pdog[current] ,drawingAreaWindow, gc, 0, 0, wdog[current] , Hdog[current] , xdog, ydog) ; }
void
StepCallback(widget, client_data, call_data) Widget widget; /* UNUSED */ caddr_t client_data /* movement */ caddr t call data /* UNUSED */
int movement = (int) client data;
XClearArea(DISPLAY, drawingAreaWindow, xdog,ydog,WIDTH, HEIGHT,False) ,
xdog += movement ; if (movement > 0) { if (xdog >= windowWidth) xdog = 0; current++; if (current > 5) current =0; } else{ if (xdog < à) xdog = windowWidth; current—; if(current < 0) current = 5; }
XCopyArea(DISPLAY, pdog[current] ,drawingAreaWindow, gc, 0, 0, wdog[current] , hdog[current] , xdog, ydog) ;
}
Dans la fonction InitPixmaps on crée les pixmaps et pour cela il est nécessaire de savoir dans quel widget ils seront dessinés, on consulte donc la variable LISP drawing-area.
if ( !EgvariableGetValue("drawing-area" , egClassWidget, SedrawingArea) ) { fprintf(stderr,
"drawing-area must be specified\n") ; exit (-1) ;
}
On pourrait aussi modifier la valeur d'une variable LISP depuis C. Il faut noter que ce principe se retrouve dans d'autre systèmes qui ne sont pas forcément basés sur un interpréteur LISP. Cela signifie qu'une application utilisant ces fonctionnalités n'est pas dépendant d'EGERIA.
Après avoir compilé l'application, il faut en faire l'édition de lien avec la librairie EGERIA libEg.a et avec les librairies nécessaires pour OSF/MOTIF c'est à dire : libXm.a, libXt.a et libXll.a.
Le programme obtenu permet d'éditer l'interface s'il est exécuté avant l'option -edit :
EGPATH = .:/user/local/lib/Xll/eg dog -edit&.
Toutes modifications à la portée de l'homme de métier fait également partie de l'esprit de l'invention.
ANNEXE 1
EGERIA*background: AntiqueWhite3 EGERIA*XmTest*background: AntiqueWhite2 EGERIA*XmList*background: AntiqueWhite2 EGERIA*foreground: black
EGERIA*FonList: -adobe-times-bold-r*-*-12-*-75-*-*-*-*-*
EGERIA*XmToggleButton.indicatorSize : 18
EGERIA*selectionPolicy : SINGLE_SELECT EGEP VIistSizePolicy: CONSTANT EGEF..A*XmList.visibleltemCount :7
FEUILLE DE REMPLACEMENT ANNEXE 2
Shift"Ctri<Btn1Down > EgSelectO EgMove()\n\ — 21
"Shift"CtrKBtn2Down > EgSelectO EgResize()\n\ — 24
"Shift"CtrKBtn1Do n > EgSelectOrUnselect()\n\ — 22
"Shift"CtrKBtn2Down; EgSelectOrUnselect()\n\
Shift"CtrKBtn3Down > EgSelect()\n\ 23
FEUILLE DE REMPLACEMENT ANNEXE 3
EGERI A *object. translations: #override\
< keyPress > e: EgWoolExec(custom:Edit)\n\ < keyPress > p: EgWoolExec(custom:EditParent)\n\
< keyPress > x: EgWoolExec(custom:Cut)\n\
< keyPress > c: EgWooiExec(custom:Copy)\n\
< keyPress >v: EgWoolExec(custom:Paste)\n\
< keyPress > d: EgWoolExec(custom:Delete)
FEUILLE DE REMPLACEMENT ANNEXE 4
Interface description generated by EGERIA for toolkit MOTIF
{eg:layer-check 'Egeria 2000036) (eg:layer-check 'Xt 1 1004) (eg:layer-check 'MOTIF 1001 )
(Idirinterface
Figure imgf000036_0001
0 0 (
(ldi:widget
Figure imgf000036_0002
0 0 (
FEUILLE DE REMPLACEMENT ANNEXE 4 (suite)
(l
Figure imgf000037_0001
0 (
(Idkwidget XmDrawingArea — 434 ( ident"@000005@" eg:name"drawing-area"
431 script"(on XmNcreateCalIback (widget)
Figure imgf000037_0002
431
(call-back init)\n (setq dog:window-width (attribute-get widget XmNwidth)))\n\|J (on XmNdestroyCalIback (widget) )\n\ (on XmNhelpCalIback (widget) )\n\
(on XmNresizeCalIback (widget) \n\ 433
(setq dog:window-width (attribute-get widget XmNwidth)))\n\ (on XmNexposeCalIback (widget) \n\ 430
(call-back dog:draw))\n\ 435
(on XmNinputCalIback (widget) )\n\— 432
XmNborderWidthO
XmNxO
XmNyO 1 436
XmNwidth71 1
XmNheight1 63
XmNresizePolicyXmRESIZE NONE
FEUILLE DE REMPLACEMENT ANNEXE 4 (suite)
(I
Figure imgf000038_0001
(ldi:widget XmPushButton
( ident"@000007@" eg:name"" script"(on XπnNcreateCalIback (widget) (setq count O))\n(on XmNdestroyCalIback (widget) )\n\ (on XmNhelpCalIback (widget) )\n\ (on XmNactivateCallback (widget) \n\ (setq dog:max 400) \n\ (work-proc \n\ 4411
\'(progn\n\ /
(setq count ( + count (attribute-get @000010@ XmNlnt-value)))\n\ (if ( > count dog:max)\n\ (progn\n\
(setq count (- count dog:max))\n\
(call-back dog:step 19))\n\ 441
(if ( < count 0)\n\N4412 (progn\n\ \t(setq count ( + count dog:max))\n\
\t(call-back dog:step -19)))))))\n\ 4413
(on XmNarmCalIback (widget) )\n\ (on XmNdisarmCalIback (widget) )\n\
) (
XmNlabelString"START"
XmNx6
XmNy6
XmNwidth47
XmNheight23
)
FEUILLE DE REMPLACEMENT ANNEXE 4 (suite)
0 0 0
)) )
(Idi.widget XmPushButton ( ident"@000008@" eg:name"" script"(on XmNcreateCalIback (widget) )\n(on XmNdestroyCalIback (widget) )\n(on XmNhelpCalIback (widget) )\n\
(on XmNactivateCallback (widget) (work-proc ()))\n\ 442
(on XmNarmCalIback (widget) )\n\ (on XmNdisarmCalIback (widget) )\n\
) ( XmNlabelString"STOP" XmNx214 XmNy244 XmNwidth41 XmNheight22 )
0 0 0 ) (Idi.widget XmPushButton ( ident"@000009@" eg:name"" script"(on XmNcreateCalIback (widget) )\n(on XmNdestroyCalIback (widget) )\n(on XmNhelpCalIback (widget) )\n\ (on XmNactivateCallback (widget) (call-back dog:step 19))\n\ (on XmNarmCalIback (widget) )\n\ (on XmNdisarmCalIback (widget) )\n\
XmNIabelString'One step"
XmNx354
XmNy244
XmNwidth56
XmNheight23 ) 0
FEUILLE DE REMPLACEMENT ANNEXE 4 (suite)
0 (l
1
Figure imgf000040_0001
0 0 ) (ldi:widget XmSeparator
( ident"@OOOO1 1 (σ. " eginame""
XmNwidth761 XmNheight2O XmNx2 XmNy204
FEUILLE DE REMPLACEMENT ANNEXE 4 (suite)
(Id widget XmPushButton
( ident"@OOO01 2@" eg:name"" script"(on XmNcreateCalIback (widget) )\n(on XmNdestroyCalIback
470 (widget) )\n(on XmNhelpCalIback (widget) )\n\ on XmNactivateCallback (widget) (exit))\n\ on XmNarmCalIback (widget) )\n\ (on XmNdisarmCalIback (widget) )\n\ 47
XmNIabelString'OUIT"
XmNx672
XmNy244
XmNwidth32
XmNheight21
0 0 0 ) (Id widget XmLabel ( ident"@OOOO1 3@" eg:name"" ) (
XmNalignmentXmALIGNMENT_BEGINNING
XmNmarginWidthO
XmNfontList"-adobe-helvetica-bold-r-normal-14-140-75-75-p-82-iso8859-1
XmNlabelString"Demonstration of the EGERIA Interface Editor (built on OSF/MOTIF)"
XmNx149
XmNyl O
XmNwidth466
XmNheight20
)
) )
FEUILLE DE REMPLACEMENT ANNEXE 5
Application: Link with User Interface part
\
#include "eg_toolkit.h" #include "egeria.h" #include < stdio.h > void InitCalIbackO; /* (widget, client data, call data) */
/* = = = = = = = = = = * \
Initialisation of EGERIA
\ * = = = = = = = = = =
Figure imgf000042_0001
FEUILLE DE REMPLACEMENT ANNEXE 5 (suite) *\
Egeria version
Used to check version
CAUTION: Read the modification before to change this number • */
#define EgVERSION 2 #define EgREViSION 0 #define EgVersion EgVERSION 1000 + EgREViSION
EgLayer layers[] = { ["Egeria", EgVersion}, "Xt", XtVersion}, ["MOTIF", XmVersion}
• *\
Egeria main loop - */ int
51 1
Figure imgf000043_0001
r = = = = = = = = = ≈ = = == = = = = = = = = = = =z = ≈
*\
Application part
\ * = = ≈ = z= = = = = = = = = = = ≈ = = = =z = = = ≈ = = */
Widget drawingArea;
Display *EgDisplay;
Window drawingAreaWindow;
#define PIXMAP_NUMBER 7
#define PIXMAP_NAME "dog"
Pixmap ppixmap[PIXMAP_NUMBER];/* Pixmaps */ unsigned int wpixmap[PIXMAP_NUMBER], hpixmap[PIXMAP_NUMBER], HEIGHT ≈ 0,
WIDTH = 0; /* sizes */
GC gc;
#define DEFAULT_PIXMAP 2 int xpixmap = 0, ypixmap = 25, current = 0; int windowWidth = 100;
FEUILLE DE REMPLACEMENT ANNEXE 5 (suite)
/ * *\
Utilities \* */ int
ReadPixmap(pixmapName, pixmapPtr, widthPtr, heightPtr) char * pixmapName;
Pixmap * pixmapPtr; unsigned int * widthPtr, * heightPtr;
{
XrmValue from_value, to_value; int dummy; from_value.size = strlen(pixmapName) + 1 ; from_vaiue.addr = pixmapName;
XtConvert(drawingArea, XtRString, &from_value, XmRManForegroundPixmap /* XmRPrimForegroundPixmap */, &to_value); if (to_value.addr = = NULL | |
* (Pixmap * ) to_value.addr = = DEFAULT_PIXMAP) { return False;
} else { unsigned long int dummy; Status status;
* pixmapPtr = * (Pixmap *) to_value.addr; status = XGetGeometry(EgDisplay, * pixmapPtr,
&dummy, &dummy, &dummy, widthPtr, heightPtr, &dummy, &dummy); return True;
) } void InitPixmapsO
{
XGCValues gcv; int i; char name[100]; if (lEgVariableGetCValue ("drawing-area", EgClassWidget, &drawingArea)) { \522 fprintf(stderr, "drawing-area must be specified\n"); exit (1 );
}
EgDisplay = XtDisplay(drawingArea); drawingAreaWindow = XtWindow(drawingArea);
FEUILLE DE REMPLACEMENT ANNEXE 5 (suite)
/* to avoid event accumulation during animation */ gcv.graphics_exposures = False ; gc = XCreateGC(EgDisplay, drawingAreaWindow, GCGraphicsExposures, &gcv); for (i = 0; i < PIXMAP_NUMBER; i + + ) { #ifdef BULL /* Kriss */ /* DATE : 06 Jun 91 */ sprintf(name, "/usr/lib/XI 1 /Egeria/dog/%s%d .xbm", PIXMAP_NAME, i); #else /* BULL */ /* Kriss */ /* DATE : 06 Jun 91 */ sprintf(name, " %s%d.xbm", PIXMAP_NAME, i); #endif /* BULL */ /* Kriss */ /* DATE : 06 Jun 91 */ if (! ReadPixmap(name, &ppixmap[i], &wpixmap[i], &hpixmap[i])) { fprintf(stderr, "file %s is not found\n", name); exit (-1 );
} if (hpix apti] > HEIGHT) HEIGHT = hpixmapfi]; if (wpixmap[i] > WIDTH) WIDTH = wpixmap[i];
} } r • *\
Callback functions • */ void
DrawCalIbac widget, client_data, call_data) Widget widget;/* UNUSED */ caddr_t client jjata;/* UNUSED */ caddr t call data;/* UNUSED */
{ 523
XCopyArea(EgDisplay, ppixmap[current], drawingAreaWindow, gc, 0, 0, wpixmaptcurrent], hpixmaptcurrent], xpixmap, ypixmap);
void
UndrawCallback(widget, client-data, call_data)
Widget widget;/* UNUSED */ caddr_t client_data;/* UNUSED */ caddr_t call_data;/* UNUSED */
{
XCIearArea(EgDisplay, drawingAreaWindow, xpixmap, ypixmap, wpixmaplcurrent], HEIGHT, False); }
FEUILLE DE REMPLACEMENT ANNEXE 5 (suite)
void
StepCalIbac widget, client_data, calljjata)- 525
Widget widget;/* UNUSED */ caddr_t client_data;/* movement */ caddr_t call_data;/* UNUSED */
{ int movement = (int) client_data; 526
XCIearArea(EgDisplay, drawingAreaWindow, xpixmap, ypixmap, WIDTH, HEIGHT, False); xpixmap + = movement ; if (movement > 0) { if (xpixmap > = windowWidth) xpixmap = 0; current + + ; if (current > = PIXMAP_NUMBER) current = 0;
} else { if (xpixmap < 0) xpixmap = windowWidth; current-; if (current < 0) current = PIXMAP_NUMBER - 1;
}
XCopyArea(EgDisplay, ppixmapicurrent], drawingAreaWindow, gc, 0, 0, wpixmaplcurrent], hpixmaplcurrent], xpixmap, ypixmap); } void lπitCallback(widget, client_data, call_data)
Widget widget;/* UNUSED */ caddr_t client_data,7* UNUSED */ caddr_t call_data,7* UNUSED */ | 532
{
InitPixmapsO;
EgPointerDefine("dog:window-width", EgClassInt, &windowWidth); EgTypedCallbackDefine("dog:draw", DrawCallback, EgClassAny);
EgTypedCallbackDefine("dog:step", StepCallback, EgClassInt); 531
EgTypedCallbackDefine("dog:undraw", UndrawCalIback, EgClassAny); }
/ **+******»*******#**********+***»***+****»**#«#»*#«**#*#+
FEUILLE DE REMPLACEMENT 45
ANNEXE 6
6.1 WOOL CORE PART
6.1.1 Svntax
Function Action
[W1&2HCL526] WOOL comment [W1&2HCL 16] integer [W1&2][CL≠27] symbol [W1&2][CL≠33] string notation
(...) [W1&2] list notation [W1&2HCL 115] prevent évaluation
0 [W1&2][CL 96] the nil va! -• nil [W1&2][CL 96] the nil value
6.1.2 Basic
Function Action
IW1&2HCL 115] prevent évaluation quote [W1&2HCL 115] prevent évaluation
0 [W1&2][CL 96] the nil value nil [W1&2HCL 96] the nil value defsetf [W2][CL138] define an assignation function for setf load [W1] load and exécute a WOOL file load [W2][CL 657] load and exécute a WOOL file
*load-pathname' [W2] directory path used by load provide [W2][CI_ 277] manage file loading require [W2HCL 277] manage file loading setf [W2][CL 124] gênerai assignation setq [W2HCL 122,121] variable assignement set [W2][CL 122,121] variable assignement
FEUILLE DE REMPLACEMENT 4/02895
46
ANNEXE 6 (suite)
6.1.3 Control
Function Action catch [W2][CL 187] non-local goto cond [W1&2HCL 158] conditional test dolist [W2][CL 169,395] iterate through a sequ nce (list or string) dotimes [E1][W2][CL 169] loop from zéro to n-1 do [E1][W2][CL 164] gênerai loop end [W1] terminate exécution error-catch [W1] [?] trap errors occuring in expressions error-trigger [W1] trigger a WOOL error eval [W1&2] evaluate a WOOL expression every [E1] LISP traditional iterators exit [W1] non-local goto exit [W2] terminate exécution for [W1] iterate through a list of values ifn [E1][old] conditional test if [W1&2] conditional test mapcan [E1] LISP traditional iterators mapcar [E1] LISP traditional iterators mapfor [W1] iterate through a list of values map [W2][CL 169,395] iterate through a séquence (list or string) progn [W1&2][CL 147] séquence of instructions some [E1] LISP traditional iterators ta g [W1] non-local goto throw [W2] [CL 187] non-local goto unless [E1] [?] négative conditionnai test unwind-protect [W2] [CL 188] ensure exécution of code when [E1] [?] positive conditionnai test while [W1] [?] while loop
FEUILLE DE REMPLACEMENT ANNEXE 6 (suite)
6.1 .4 Function
Function Action
[W2] prevent évaluation with possible internai évaluations backquote [W2] prevent évaluation with possible internai évaluations defmacro [E1 ] define a WOOL macro defmacro [W2][CL 76, 1 95] define a WOOL function defunq [W1 ] define a WOOL function defun [W1 ] define a WOOL function defun [W2][CL 76, 1 95] define a WOOL function de [W1 ] define a WOOL function df [W1 ] define a WOOL function dm [E1 ] define a WOOL macro flambda [W1 ] define a WOOL function lambdamacro [W2][CL 76, 195] define a WOOL function lambda [W1 ] define a WOOL function lambda [W2][CL 76, 1 95] define a WOOL function
6.1 .5 Anv
Function Action
[W2] [CL ≠ 293] test inequality of objects convert [E1 ] convert a value copy [E1 ] [W2] copy of a WOOL object eq [W1 &2] test strict equality of any two objects equal [W1 &2] [CL 107] test equality of any objects object-plist [E2] return property-list associated with an object print [W1 &2] [CL ≠577] print WOOL objects ? [W1 ] print WOOL objects
*print-read ably1 [W2] [CL 577] affect the way objects are printed type-of [W1 &2] [CL 65] type of a WOOL object type-of [E1 ] [CL 65] type of a WOOL object typep [W1 ] [CL 67] check type of an object
FEUILLE DE REMPLACEMENT ANNEXE 6 (suite)
6.1 .6 Hash Table
Function Action gethash [W2] [CL 438] retrieves entry in an hash table make-hash-table [W2][CL 436] make an hash table maphash [W2][CL 438] apply function on each enties in hash table remhash [W2][CL 438] removes entry in hash table
6.1 .7 Input/Output
Function Action close [W2] [CL 505]close a stream error-output [E1 ] global streams file-open [E1 ] open a stream open [W2] [CL 646] open a stream output [E1 ] global streams print [W1 &2] [CL ≠577] print WOOL objects ? [W1 ] print WOOL objects read-char [W21ICL 573,579] read or write a char read-line [W2][CL 572,579] read or write a line read [old] read a string from the current stream read [W2][CL 569] read an expression
*standard-error* [W2][CL 497] global streams
*standard-input* [W2][CL 497] global streams
*standard-output* [W2][CL 497] global streams stderr [E1 ][W2] initial global streams stdin [E1 ][W2] initial global streams stdout [E1 ][W2] initial global streams write-char [W2][CL 573,579] read or write a char write-line [W2][CL 572,579] read or write a line
FEUILLE DE REMPLACEMENT ANNEXE 6 (suite)
6.1 .8 List
Function Action nil IW1 &2] [CL 96] the nil value
+ [W1 &2] [CL 295] add or concatenate nth [G 1 ] access an élément of a list replace-πth [G1 ] physically replace an élément of a list append [W2] append séquences (lists or strings) nconc [W2] append séquences (lists or strings) consp [E1 ] test for a list delete [W2][CL 400]L!]remove from a séquence (list or string) delete-nth [G1 ] physically remove an élément of a list dolist [W2] [CL 1 69,395] iterate through a séquence (list or string) map [W2] [CL 1 69,395] iterate through a séquence (list or string) elt [W2] get an item in a séquence (list or string) for [W1 ] iterate through a list of values mapfor [W1 ] iterate through a list of values lenght [W1 &2] length of séquence (list or string) list [W1 &2] make a list list-add [E1 ][E2] add an élément at the end of a list list-add! [E1 ][E2] add an élément at the end of a list list-append [E1 ][E2] append a list to an other one list-append! [E1 ][E2] append a list to an other one list-get [E1 ][E2] get or set item in a list list-put [E1 ][E2] get or set item in a list list-put! [E1 ][E2] get or set item in a list list-make [E1 &2] make a list of a given size list-remove [E1 ][E2] remove from a list list-remove! [E1 ][E2] remove from a list list-sort! [E1 ][E2] sort a list in place make-list [W2][CL 418] make a list of a given size mapcar [E1 ] LISP traditional iterators mapcan [E1 ] LISP traditional iterators some [E1 ] LISP traditional iterators every [E1 ] LISP traditional iterators member [W1 ] position of élément in a list or in string position [W2HCL404] position of élément in séquence (list or in string) print-level [,W1 &2][CL 564] control printing depth of lists reverse [W2][CL 393] reverse items in a list sort [W1 &2HCL 408] sort a list in place sublist [W1 ] extract a sub-list out of a list subseq [W2][CL 393] extract a sub-part out of a séquence
(list or string)
FEUILLE DE REMPLACEMENT 50
ANNEXE 6 (suite)
6.1.9 Looical
Function Action and [W1&2] logical AND of expressions not [W1&2] [CL 110] logical négation null [E1] logical négation or [W1&2HCL 110] logical OR of expressions t [W1&2HCL 96] the logical "true" value
6.1.10 Number
Function Action mod [W2] [CL 353] modulo
[W1&2] [CL 296] arithmetic operators
[W1&2] [CL 296] arithmetic operators
+ [W1&2] [CL 295] add or concatenate
[W1&2] [CL 295] arithmetic différence
< [W1&2] [CL 293] test for strict inferiority
< = [E1][W2][CL 293] test for inferiority > [W1&2HCL 293] test for strict superiority > = [E1][W2][CL 293] test for superiority atoi [W1] ascii string to integer conversion compare [W1&2] ordering comparison itoa [W1] integer to ascii string conversion logand [E1][W2] bitwise operators logior [E1][W2] bitwise operators logxor [E1][W2] bitwise operators lognot [E1][W2] bitwise operators min [E1][W2][CL 294] give the min or max of a list of numbers or strings max [E1][W2][CL 294] give the min or max of a list of numbers or strings numberp [E1] test if it is a number
6.1.11 Obiect
Function Action class-name [W2] [CL 821] returns name of a class class-of [W2] [CL 822] returns class of an object defclass [W2] [CL 822] define a class defmethod [W2] [CL 838] define a method make-instance [W2] [CL 848] make an instance of a given class pπnt-object |W2] [CL 850] method slot-value [W2] [CL 857] get slot value of an object
FEUILLE DE REMPLACEMENT ANNEXE 6 (suite)
6.1 .1 2 Packaαe
Function Action boundp [W1 &2] [CL 1 20] test if an symbol has aiready been defined defvar [W2] [CL 86] defines variable or constant defconstant [W2] [CL 86] define variable or constant defun [W2] [CL 76, 195] define a WOOL function defmacro [W2] [CL 76, 1 95] define a WOOL function find-package [W2] [CL 264] find package from its name intern [E1 ] make an symbol from a string intern [W2] [CL 266] make an symbol from a string make-package [W2] [CL 262] make a package
* package * [W2] [CL 262] current package use-package [W2] [CL 269] indicates packages used
6.1 .13 Séquence
Function Action
+ [W1 &2] [CL 295] add or concatenate append [W2] append séquences (lists or strings) nconc [W2] append séquences (lists or strings) delete [W2] [CL 400][TJremove from a séquence (list or string) dolist [W2] [CL 169,395] iterate through a séquence (list or string) map [W2] [CL 169,395] iterate through a séquence (list or string) elt [W2] get an item in a séquence (list or string) length [W1 &2] length of séquence (list or string) position [W2] [CL 404] position of élément in séquence (list or in string) subseq [W2] [CL 393] extract a sub-part out of a séquence
(list or string)
FEUILLE DE REMPLACEMENT ANNEXE 6 (suite)
6.1 .14 String
Function Action
[W1 &2] [CL≠33] string notation
[W1 &2] [CL 295] add or concatenate
< [W1 &2] [CL 293] test for strict inferiority
< - [E1 ][W2][CL 293] test for inferiority > [W1 &2HCL 293] test for strict superiority
> = [E1 ][W2][CL 293] test for superiority append [W2] append séquences (lists or strings) nconc [W2] append séquences (lists or strings) atoi [W1 ] ascii string to integer conversion compare [W1 &2] ordering comparison delete [W2] [CL 400][7] remove from a séquence (list or string) dolist [W2] [CL 169,395] iterate through a séquence (list or string) map [W2] [CL 169,395] iterate through a séquence (list or string) elt [W2] get an item in a séquence (list or string) intern [E1 ] make an symbol from a string intern [W2] [CL 266] make an symbol from a string itoa [W1 ] integer to ascii string conversion length [W1 &2] length of séquence (list or string) match [W1 &2] gênerai regular expression matching package position [W2] [CL 404] position of élément in séquence (list or in string) min [E1 ][W2][CL 294] give the min or max of a list of numbers or strings max [E1 ][W2][CL 294] give the min or max of a list of numbers or strings read-line [W2] [CL 572,579] read or write a line write-line [W2] [CL 572,579] read or write a line strcat [E1 ] [old] concatenate two strings string-execute [E1 ] exécute a WOOL string string-upcase [E1 &2][CL 465] change the case of a string string-downcase [E1 &2HCL 465] change the case of a string stringp [E1 ] test for a string subseq [W2] [CL 393] extract a sub-part our of a séquence
(list or string) symbol-name [old] give the name of a symbol
FEUILLE DE REMPLACEMENT ANNEXE 6 (suite)
6.1.15 Svmbol
Function Action atom [G1] make an dsymbolatom atom [E1] test if it is an symbol boundp [W1&2] [CL 120] test if an symbol has aiready been defined gensym [E1][E2] generate a symbol intern [E1] make an symbol from a string intern [W2] [CL 266] make an symbol from a string symbol-name [old] give r name of a symbol symbol-plist [W2][CL 24 i] return property-list associated with a symbol unbind [W1] undefine a symbol makunbound [W2] [CL 12 ] undefine a symbol
6.1.16 Variable and Constant
Function Action defvar [W2] [CL 86] defines variable or constant defconstant [W2] [CL 86] defines variable or constant let [W2] local variable déclaration let* [E1][W2] local variable déclaration set [W2] [CL 122,121] variable assignement setq [W2] [CL 122,121] variable assignement set [W1] variable assignement setq [W1] variable assignement [W1] variable assignement with [W1] local variable déclaration with-eval [W1] local variable déclaration
6.1.17 Miscelaneous
Function Action conte»'t-save [W1] context management context-restore [W1] context management gensym [E1][E2] generate a symbol random [E1][W2] [CL 365] generate a random number
FEUILLE DE REMPLACEMENT ANNEXE 6 (suite)
6.1 .18 System
Function Action
[E1 ] exécute a shell command
[W2] exécute a shell command
System [E1 ] exécute a shell command System [W2] exécute a shell command ϋ [W2] exécute a shell command getenv [W1 &2] get the value of a shell variable get-internal-run-time [W2][CL 705] get running time time-elapsed [E1 ] get running time elapsed-time [G 1 ] get running time popen [E1 ] open a pipe stream with a forked shell
6.1 .19 Internai
Function Action hack [W2] raw access to WOOL internai structures hack [W1 ] raw access to WOOL internai structures hashinfo [W1 &2] statistics on symbol storage meminfo [W1 &2] print memory used oblist [W1 ] print ail defined objects stack-print-level [W1 &2]number of stack frames printed on error trace-level [W1 &2] trace calls to a WOOL function trace-ail [W1 &2] trace calls to a WOOL function trace [W1 &2] trace and untrace a function untrace [W1 &2] trace and untrace a function
FEUILLE DE REMPLACEMENT D3
ANNEXE 6 (suite)
6.2 WOOL EGERIA PART
6.2.1 Any
Function Action class-is-subclass [E1 ] tests if a class is subclass of another class-super-class [E1 ] |will be removed.TT) returns superclass eg:cast [E1 ][7] change the type of an object type-is-subtype [W2] [3 tests if a type is subtype of another
6.2.2 Attribute
Function Action eg:attribute-atom [È1 ] [7J returns information about a widget attribute eg:attribute-make [E1 ] 7} defines a widget attribute eg:attribute-name [E1 ] [7] returns information about a widget attribute eg:attribute-type [E1 ] [T] returns information about a widget attribute
6.2.3 Behavior
Function Action
XtAddCalIback [E1 ] (7) adds or remove callback in a widget
XtAddEventHandler [E1 ] [T] add or remove an event handler
XtRemoveCalIback [E1 ] 7\ adds or remove callback in a widget
XtRemoveEventHandler [E1 ] (T] add or remove an event handler call-back [E1 &2] call a callback function eg:callback-make-from-string [E1 ] T\ create a callback from a string eg:callback-make [E1 ] 7 create a callback from an expression widget-add-callback [E1 ] [T] adds or remove callback in a widget widget-add-event-handler [E1 ] [2 add or remove an event handler widget-remove-callback [E1 ] [?] adds or remove callback in a widget widget-remove-event-handler [E1 ] [?] add or remove an event handler work-proc [E1 ] |will be removed.. -"] get or set workproc expression
FEUILLE DE RE 4/02895
56
ANNEXE 6 (suite)
6.2.4 Control
Function Action apply [E1 ] [W2] apply a function with given parameters atom-for [E1 ] itérâtes on each symbol do-symbol [W2] itérâtes on each symbol error [E1 ] | will be removed. X\ prompts an error message range-for [E1 ] will be removed ... itérâtes throught a range of integers warning [E1 ] \7 generate a warning
6.2.5 Development
Function Action break [W1 &2] null function measure-doing [E1 ] [7J to begin or stop measure measure-print [E1 ] Q] print statistic information about user functions
FEUILLE DE REMPLACEMENT ANNEXE 6 (suite)
6.2.6 Egeria
Function Action ed:ask-parent [E1 ] |7| interactively ask to designate a widget ed:ghost-color [E1 ] [7j active value : the color of the ghost rectangle ed:handle-height [E1 ] \T active values : the width and height of the handles ed:handle-width [E1 ] [3 active values : the width and height of the handles ed:select-widget [E1 ] jT] get and set the list of selected widgets ed-selected-list-get [E1 ] 0 get and set the list of selected widgets ed:selected-list-set [E1 ] [7] get and set the list of selected widgets eg:application-class [E1 ] (?] the class of the current application eg:application-name [E1 ] Î3 the name of the current application eg:default-edition-mode [E1 ] |3 the default egeria mode eg-editable [E1 ] 3 indicates if created widget will be editable eg:edition-mode [E1 ] B active value : the global egeria mode eg:identifier-to-widget [E1 ] [Fj the widget given by an identifier eg:load [E1 ] |?3 load a non editable file description of widgets eg:profile-name [E1 ] 0 the name of the first profile name eg:script-update [E1 ] [7j updates widget identifier in script eg:widget-description [E1 ] (3 give an expression describing the widget eg:widget-for [E1 ] B iterate through the list of edited widgets eg:widget-is-editable [E1 ] \T say if a widget is editable eg:widget-pprint [E1 ] (3 pretty print a widget eg:widget-to-apply [E1 ] (3 yhe parent widget if it is a shell eg:widget-to-identifier [E1 ] [ the identifier of a widget eg:widget-top-list [E1 ] 0 the list of shell or toplevel widgets sw [E1 ] |TJ returns selected widget
FEUILLE DE REMPLACEMENT ANNEXE 6 (suite)
6.2.7 Event
Function Action egxursor-position [E1 ] [TJget the cursor coordinates eg:cursor-x [E1 ] jT] get the cursor coordinates eg:cursor-y [E1 ] (T] get the cursor coordinates eg:which-button [E1 ] |Tj the mouse button pressed in the last X event
6.2.8 Mise
Function Action eg:XmString-to-String [E1 ] [3 convert an XmString to an ascii string egxut-buffer [E1 7] get the eut buffer eg.default [E1 3 egrdefine-cursor [E1 Tjset and unset the cursor shape eg:flush [E1 Tj flush the X server eg:resource-get [E1 7]get or set an X resource eg:resource-put [E1 7J get or set an X resource eg:synchronize-expose [E1 7] synchronize the X server eg:undefine-cursor [E1 7]get and unset the cursor shape eg:xt-convert [E1 3 convert an object from one type to another
FEUILLE DE REMPLACEMENT ANNEXE 6 (suite)
6.2.9 Plist
Function Action eg:propertιes-get [E1 ] UJ get or put properties of an object eg:properties-put [E1 ] |TJ get or put properties of an object eg:property-get [E1 ] [Tj get or put property of any object eg:property-put [E1 ] [Tj get or put property of any object get [E1 ] [7] get or put property of any object plist-for [E1 ] [Tj itérâtes throuh a property list plist-get [E1 ] ( | get or put a property in a plist plist-list-get [E1 ] GB get or put properties in a plist plist-list-put! [E1 ] [7] get or put properties in a plist plist-make [E1 ] will be removed... make a property list from a simple list plist-put! [E1 ] L?) get or put property in a plist plist-put [E1 ] [ JQet or put property in a plist plist-remove [E1 ] will be removed... remove properties from a list properties-get [El I \T get or put properties of an object properties-put [E1 ] (Tj get or put properties of an object property-get [E1 ] (T] get or put property of any object property-put [E1 ] {T) get or put property of any object put IE1 ] GD get or put property of any object
6.2.10 Stream
Function Action buffer-make [E1 ] créâtes a stream buffer buffer-reset [E1 ] ] resets the content of the buffer buffer-string [E1 ] gets the content of the buffer
6.2.1 1 Symbol
Function Action
NONE [E1 &2] désignâtes no value atom-for [E1 ] itérâtes on each symbol do-symbol [W2] itérâtes on each symbol
FEUILLE DE REMPLACEMENT ANNEXE 6 (suite)
6.2.12 Widget
Function Action
XtCreatePopupShell [E1 &2] créâtes a widget
XtCreateWidget [E1 &2] créâtes a widget
XtDestroyWidget [E1 &2] destroy a widget and ail its children
XtGetValues [E1 &2] get MOTIF resources of a widget
XtManageChild [E1 &2] manage or unmanage a child widget
XtMapWidget [E1 ] |Tj map or unmap a child widget
XtMoveWidget [E1 &2] move or resizes a widget XtParent [E1 &2] get the parent widget of a widget
XtPopdown [E1 &2] pop-up or popdown a menu
XtPopup [E1 &2] pop-up or popdown a menu
XtRealizeWidget [E1 &2] créâtes X window associated with widget
XtResize [E1 &2] XtMakeGeometryRequest moves or resizes a widget XtSetValues [E1 &2] Set MOTIF resources of a widget
XtTranslateCoords [E1 &2] translates to root window coordinates
XtUnmanageChild [E1 &2] manage or unmanage a child widget
XtUnmapWidget [E1 ] [Tj map or unmap a child widget attribute-get [E1 &2] get and set the value of a widget attribute attribute-set [E1 &2] get and set the value of a widget attribute
FEUILLE DE REMPLACEMENT ANNEXE 6 (suite)
6.2.1 2 Widget (suite)
Function Action eg:XmButtonPopdownChildren [E1 ] Ej popdown chiidren of a menu eg.XmDisarm [E1 ] [3 disarms a cascade button eg.widget-children [E1 ] jTj the list of chiidren widgets eg:widget-lower [E1 ] iTjraise or lower a widget window eg:widget-raise [E1 ] [7j raise or lower a widget window eg:widget-rank [E1 ] jTjget or set rank of a widget in chiidren list eg:widget-redraw [E1 ] jredraw a widget. eg:widget-set-menu-position [E1 ] [Tjget the position of a menu eg-widget-shell-children [E1 ] [TJthe list of chiidren widgets popup-shell-create [E1 &2] créâtes a widget widget-create [E1 &2] créâtes a widget widget-destroy [E1 &2] destroy a widget and ail its chiidren widget-geometry-request [E1 &2] moves or resizes a widget widget-get-values [E1 &2] get MOTIF resources of a widget widget-manage [E1 &2] manage or unmanage a child widget widget-map [E1 ] {Tj map or unmap a child widget widget-move [E1 &2] moves or resizes a widget
FEUILLE DE
REMPLACEMENT ANNEXE 6 (suite)
6.2.13 WidoetClass
Function Action
XtGetConstraintResourceList IE1 ] |T) get resource list of a widget class
XtGetResourceList [E1 ] CE) get resource list of a widget class eg:widget-class-atom [E1 ] [TJ returns information on a widget class eg:widget-class-creator [E1 ] JTj returns information on a widget class eg:widget-class-father [E1 ] [TJ returns super-class of a class eg:widget-ciass-is-subclass [E1 ] JTj test if a class is a sub class of another eg:widget-class-name [E1 ] JTJ returns information on a widget class eg:widget-class-variable [El ] [TJ returns information on a widget class widget-class-constraint-resource-list [E1 ] [Tj get resource list of a widget class widget-class-resource-list [E1 ] J_?J get resource list of a widget class
6.2.14 Xmlinear
Function Action
XmLinearDrawReference [E1 ] [TJ draw référence size and position of chiidren
XmLinearRestoreReference [E1 ] [_? | restore size to référence size XmLinearSaveReference [E1 ] [Tj save current coordinates as référence /02895
63
ANNEXE 6 (suite)
6.2.1 5 Xmlist
Function Action XmListAddltems [E1 &2] add an item or a list of items to a list
XmListAddltem [E1 &2] add an item or a list of items to a list
XmListDeleteAllltems [E1 &2] deselect ail the items of list
XmListDeselectAllltems [E1 &2] deselect ail the items of list
XmListDo [E1 ] [ will be removed..T(perform a list opération on an item in List widget
XmListGetSelected [E1 ] j will be removed.. Jget the list of selected items
XmListGet [E1 ] will be removed... get or set the list of items
XmListltemExists [E1 &2] checks if and item is in a list widget
XmListSet [E1 ] [ will be removed.. get or set the list of items
6.2.1 6 Xmtext
Function Action
XmTextGetString [E1 &2] get the text in a text widget XmTextReplace [E1 &2] replace the text in a text widget
XmTextSetSelection [E1 &2] sélects a string in a text widget
XmTextSetString [E1 &2] set the text in a text widget ANNEXE 6 (suite)
6.3 C Part
6.3.1 Hiqht level
Function Action
EgCallbackDefine [E1 &2] define a Callback »
EgMain [E1 &2] start EGERIA run-time
EgTypedCalIbackDefine [E1 &2] define a Callback
EgVariableGetCValue ÎE1 &2] set or get a WOOL variable
EgVariableSetCValue [E1 &2] set or get a WOOL variable
6.3.2 Obiect
Function Action
EgObjectCopy [E1 &2] copy an object EgObjectCreateFromXtArgVal [E1 &2] Créâtes a new object from C value
EgObjectCreate [E1 &2] Créâtes a new object from C value
EgObjectDecreaseRef [E1 &2] decrease or increase the référence count of an object
EgObjectEqual [E1 &2] Test equality of two objects EgObjectEval [E1 &2] Evaluâtes an object EgObjectGetCValue [E1 &2] Gets C value of an object EgObjectlncreaseRef [E1 &2] decrease or increase the référence count of an object
EgObjectlnternEval [E1 &2] Evaluâtes an object EgObjectlsSubclass [E1 &2] Checks the class of an object EgObjectModify [E1 ] [T] Sets C value of an object EgObjectPrint [E1 &2] Prints the wool object ANNEXE 6 (suite)
6.3.3 List
Function Action
EgListAppendltem [E1 &2] append an object to a list EgListContainltem [E1 ] | will be removed ... jtest if an item is in a list
EgListCreateFromArray [E1 &2] create a list from an array
EgListCreateN [E1 &2] create a list
EgϋstCreateOfSize [E1 ] JTj create a list of given size
EgListCreate [E1 &2] create a list
EgListGetArray [E1 &2] get contents of the list in C array
EgListGetltem [E1 &_22 get or set an item in a list EgListGetPosition [E1 ] }_?J get the position of an object in a list
EgListlnsertltem [E1 &2] insert an object in a list
EgListLength [E1 &2] the length of a list
EgListMoveltem [E1 &2] move an élément inside a list
EgListRemoveltem [E1 &2] Removes one item
EgListSetltem [E1 &2] get or set an item in a list
EgListReset [E1 ] [Tj Removes ail items in a list
6.3.4 Class
Function Action
EgClassCreate [E1 &2] Créâtes a new Egeria class
EgClassGetMethod [E1 &2] .set or get a m..~hod of a class
EgClassIsSubclass [E1 &2] Tests subclassing
EgClassSetMethod [E1 &2] set or get a method of a class
EgTooIkitClassCreate [E1 &2] Créâtes a new Egeria class
EgTooIkitEnumerationClassCreate [E1 &2] Créâtes a new Egeria class
EgTooIkitSynonymousClassCreate [E1 &2] Créâtes a new Egeria class
EgClassDestroy [E1 ] [T| Destroyes a class ANNEXE 6 (suite)
6.3.5 Mise
Function
EgActiveDefine EgArgumentMustBe
EgConvenientWidgetClassCreate EgError
EgFunctionDefine
EgMalloc
EgReallocEgCalloc[E1 &2] Memory management functions EgNormaIWidgetClassCreate
EgPointerDefine
EgPrintf
EgPuts
EgVariableGetObject
EgVariableSetObject
EgWarning EgPutChar
ANNEXE 7
EgActive Define define an active value
void EgActiveDefine(t7atr7e, getFunction,setFunction) char*name;
EGFunction getFunction; EGFunction setFunction;
To define a WOOL active value, use the function EgActiveDefine. An active value may be viewed as a variable or as a function in the same time. The principle is that a spécifie function is called when you assign or when you consult an active value.
The get function has no parameters and returns an EgObject, the set function has one parameter (the value set) et returns an EgObject.
The corresponding WOOL verb can be used as a function or a variable like : CAUTION : Both set and get functions must return an bf EgObject value.
(setq active 1 34) (active 1 34)
which hâve the same effect, the active value being defined by : int value Active 1 ;
EgObject getFunctionActivel 0
{ return EgObjectCreate (EgClassInt, valueActiveU;
}
EgObject setFunctionActive . (object) EgObject object;
{ if (EgObjectlsSubclass(object, EgClassInt)) { valueActive 1 ≈ EgObjectGetCValue (object); return object; } else { return EgNIL;
} }
EgActiveDefineC'active 1 " , getFunctionActivel , setFunctionActive 1 ); O 94/02895
68
ANNEXE 7 (suite)
EgArgumentMust be check the type of an argument void EgArgumentMustBe (number, object, class) int number; EgObject object; EgClass class;
Check the class of an argument and call EgError to give to the WOOL programmer an appropriate message, number will give the position in the corresponding WOOL call of the wrong argument. The position starts at 0.
EgArgumentMustBe (0, argv[0], EgClassInt);
EgClassCreate EgTooIkitClassCreate EgTooIkitSynonymousClassCreate - Créâtes a new Egeria class EgTooIkitEnumerationClassCreate
EgClass EgClassCreate (superClass, name)
EgClass superClass; char * name; EgClass EgTooIkitClassCreate (name, class, toolkit ype)
EgClass class; char * name; caddr t toolkit_type; EgClass EgTooIkitSynonymousClassCreate (name, class, toolkitjype)
EgClass class; char * name; caddr_t toolkit_type; EgClass EgTooIkitEnumerationClassCreate (name, toolkitjype) char * name; caddr_t toolkit_type;
Créâtes a ciass by copying ail characteristics of the class 'superClass'. That means that ail methods are the same. The super class of the new class is the class 'superClass' . 'name' indicates the name of the new class in script' language.
EgClassUnsignedLong ≈ EgClassCreate (
EgClassInt, "UnsignedLong"); EgClassTranslationTable = EgTooIkitClassCreate (
EgClassStructured, ."TranslationTable", XtRTranslationTable); EgClassShellUnitTγpe = EgToolkitSynonymousClassCreate(
"ShellUnitType", EgCiassUnitType, XtRShellUnitType); EgCiassOrientation = EgTooIkitEnumerationClassCreate (
"Orientation", XmROrientation);
EgTooIkitSynonymousClassCreate does no . really create a new class but make it available in C and WOOL ANNEXE 7 (suite)
EgClassDestroy Destroyes a class void EgClassDestroy (class); EgClass class;
You must be sure that you hâve aiready destroyed every subclasses and every objects of this class. Actually, this function only changes methods to produce error if one try to print, to eval, or to call any method with an object of the destroyed class.
EgClassGetMethod EgClassSetMethod - set or get a method of a class
EgMethod EgClassGetMethod (class, methodName)
EgClass class;
EgMethodName method; void EgClassSetMethod (class, methodName, methodFunction)
EgClass class;
EgMethodName methodName;
EgMethod methodFunction;
This allows to consult or modify the function called when a message methodName is send to an object of the class class. This is usually used to create new class by copying existing one and then modify some characteristics. Parameters of methodFunction dépends on the method. Hère is a table of available methods in WOOL release 1 . Note that there is pseudo method which allows to access to data instead of functions : such as EgMethodTypelMame which is the name of the class.
Figure imgf000071_0001
CAUTION : The available methods and their programming interface may be subject to modifications in the future. 94/02895
70 ANNEXE 7 (suite)
EgClassIsSubclass - Tests subclassing
int EgClassIsSubclass (class 1, class2) EgClass class l , class2;
Returns True if classl is a subclass of class2, False otherwise.
EgConvenientWidgetClassCreate EgNormaIWidgetClassCreate Record a new widget class
void EgNormaIWidgetClassCreate (prefix, wool ame, toolkit Jd); char * prefix; char *wool_name; WidgetClass toolkitjd;
void EgConvenientWidgetClassCreate (prefix, wool iame, toolkitjd, creator); char *prefix; char *wool_name; WidgetClass toolkitjd; EgWidgetCreator creator;
Example: to define XmMessageBox and XmMessageDialog.
EgConvenientWidgetClassCreateC'Xm" "MessageBox", xmMessageBoxWidgetClass, XmCreateMessageBox);
EgConvenientWidgetClassCreateC'Xm", "MessageDialog", xmMessageBoxWidgetClass, XmCreateMessageDialog);
CAUTION: Convenient class must be recorded after their real class. Example: MessageDialog after MessageBox.
FEUI 94/02895
71
ANNEXE 7 (suite)
EgError print a warning error and stop exécution
void EgError (stringFormat, value) char *stringFormat; long value;
Prints an error message and stops exécution. Jumps to the toplevel of the running WOOL program. See also : EgWarning. if (argc ! = 3) EgError ("bad number of arguments %d", argc); if (argc ! = 3) EgError (egError_BAD_NUMBER_OF_ARGS, argc);
Figure imgf000073_0001
EgF: ctionDefine define a WOOL function
void EgFunctionDefine (Λ -, function, arity) char * name; char EgFunction func n; int arity;
EgFunctionDefine allows to create a new function.
name is tne name of the îunc on as it will be called from WOOL ANNEXE 7 (suite) function is the function. arity indicates the number of arguments expected. It may vary from 0 up to 5 or may be be NARY.
CAUTION : An Egeria function must always return an EgObject.
EgObject substraction (objectO, objectD EgObject objectO, objectl ;
{ int resuit;
EgArgumentMustBe(0, objectO, EgClassInt);
EgArgumentMustBeO , objectl , EgClassInt); resuit = ((int) EgObjectGetCValue(objectO)) - ((int) EgObjectGetCValue(objectD); return EgObjectCreate(EgClasslnt, resuit);
}
EgObject addition (argc, argv) int argc;
EgObject *argv;
{ int resuit, i; if (argc < 1 ) EgError (egError_BAD_NUMBER_OF_ARGS, argc); for (i = 0; i < argc; i + + ) {
EgArgumentMustBe(i, argv.i], EgClassInt); resuit + = EgObjectGetCValue(argv[il); return EgObjectCreate(EgClasslnt, resuit);
} void
InitCallback (widget, closure, callData)
Widget widget; caddr_t closure; caddr_t callData;
{
EgFunctionDefine ("sub", substraction, 2); EgFunctionDefine ("add", addition, NARY);
}
NOTE : It is important to note that recorded function accepts only WOOL arguments. So it is often necessary to write an intermediate function with WOOL arguments which check the type of argument, get the C value and call any C function. A way to record a function describing its programming interface could be studied.
EgListAppendltem | - append an object to a list void EgListAppendltem (list, item) EgList list; EgObject item;
ApDenα an ooiect TO tne end o . a i:sι . See ai o: EgListinsertltem . ANNEXE 7 (suite)
EgListContainltem | - test if an item is in a list
int EgListContainltem (list, item) EgList list; EgObject item;
CAUTION: Use EgListGetPosition instead.
EgListCreate EgListCreateN create a list
EgList EgListCreate () EgList EgListCreateO 0 EgList EgListCreate 1 (object) EgObject object;
EgList EgListCreate2 (objectl, object ) EgObject objectl , object2;
EgList EgListCreate3 (object l, object2, object3) EgObject objectl , object2, object3;
EgList EgListCreate4 (objectl, object2, object3, object4) EgObject objectl , object2, object3, object4;
EgList EgListCreateδ (object l, objectl, objectβ, object4, objectδ) EgObject objectl , object2, object3, object4, objectδ;
EgListCreate and EgListCreateO are identical. EgListCreatel , EgListCreateδ are provided for convenience. Thèse functions use EgObject- IncreaseRef. See also EgList-CreateFromArray.
EgListCreateFromArray J - create a list from an array
EgList EgListCreateFromArray (argc, argv) int argc; EgObject * argv;
To create a WOOL list object from an array, use EgListCreateFromArray. argc gives the number of éléments in the array argv
FEUILLE DE REMPLACEMENT ANNEXE 7 (suite)
EgListCreateOfSize l - create a list of given size
EgList EgListCreateOfSize (size, item) int size; EgObject item;
EgListCreateOSize créâtes a list of a given size. The following example créâtes the list (nil nil nil).
EgListCreateOfSizeO, EgNIL);
EgListGetArray | - get contents of the list in C array
EgObject * EgListGetArray (list) EgList list;
CAUTION: the array must not be free. It must not be modified directiy to avoid error with référence jount of items or length of the list.
See also: EgObjectDecreaseRef, EgObjectlncreaseRef
EgListGetltem EgListSetltem get or set an item in a list
EgObject EgListGetltem (list, position)
EgList list; int position; int EgListSetltem (list, position, object)
EgList list; int position; int object;
Gets or sets an object from a list at a given position. EgListGetltem returns EgNIL if position is not correct. EgListSetltem returns True if done and False otherwise
Note: position starts from 0
EgListGetPosition | - get the position of an object in a list int EgListGetPosition (list, item) EgList list; EgObject item;
Returns the position of the item in the list. 0 is the first position in the list. Returns - 1 if the item is not fouπd in the list.
FEUILLE DE REMPLACEMENT ANNEXE 7 (suite)
EgListlnsertltem | - insert an object in a list void EgListlnsertltem (list, position, item) EgList list; int position; EgObject item;
Insert an object in a. list at a given position, except if position is less than O (insertion is done at the begining of the list) or if position is more than the length of list (insertion is done at the end of the list).
The first position in the list is given by 0. See also: EgListAppendltem.
EgListLength the length of a list
EgObject EgListLength (list) EgList list;
Returns the length of a list.
EgListMoveltem | - move an élément inside a a list int EgListMoveltem (list, ofdPosition, newposition) EgList list; int oldposition; int newposition;
Changes the position of an item inside a list. Returns True if modification is done or False if oldposition or newposition is outside limits. In this last case, nothing is done.
NOTE: The first position in a list is 0 (zéro). MODIFICATION: (in release 0.δ4): moved item is described by its position .
EgListRemoveltem l - Removes one item int EgListRemoveltem (list, position) EgList list; int position;
Returns True if it is done, False if position is out of range.
EgListReset - Removes ail items in a list
void EgListReset (list) EqList list; 94/02895
76
ANNEXE 7 (suite)
EgMalloc EgFree EgRealloc EgCalloc - Memory management functions caddr_t EgMalloc (bytes) int bytes; void EgFree (ptr) caddr_t ptr; caddr_t EgRealloc (ptr, bytes) caddr_t ptr; int bytes; caddr_t EgCalloc (ne/em, elsize) int nelem, bytes;
Thèse are the same functions as corresponding UNIX ones. See also: MALLOC(3).
EgObjectCopy | - copy an object
EgObject EgObjectCopy (object)
EgObject object;
Copy an object. This allow to prevent border effect on the copied object. The resuit is equal but not necessarily eq. For a list, only the top level is copied.
EgObjectCreate | - Créâtes a new object from C value
EgObjectCreateFromXtArgVal | - Créâtes a new object from C value
EgObject EgObjectCreate (class, anyCValυe)
EgClass class;
EgCValue anyCValue; EgObject EgObjectCreateFromXtArgVal (class, anyCValue)
EgClass class;
EgCValue anyCValue;
This is a generic function to create an object of any type except List. The second function EgObjectCreateFromXtArgVal is intended only for EXPERT who uses the resuit of toolkit functions which return XtArgVal values such as XtGetValues or XtConvert.
See also: EgVariableSetCVaiue, EgListCreate.
CAUTION: EgObjectCreateFromXtArgVal should be changed to accept a pointer rather than a direct value. Otherwise it causes some problems on machines where casting from pointer to character toward pointer to integer is not always valid. Ai présent, tne compilation option -DMISALIGN allows to avoid the problem oui an assignation is reoiaced by a bcopy and it is not very efficient. ANNEXE 7 (suite)
EgObjectDecreaseRef EgObjectlncreaseRef - decrease or increase the référence count of an object
void EgObjectDecreaseRef (object)
EgObject object; void EgObjectlncreaseRef (object)
EgObject object;
WOOL use a référence count garbage collection algorithm. When an object is referenced from an other one, its référence count must be incremented. And when an object is no longer referenced, its référence count must be decremented. WOOL destroys objects with a référence count equal to 0.
EgObjectEqual | - Test equality of two objects
EgObject EgObjectEqual (objectl, objectD EgObject objectl , object2;
Returns EgNIL if False and objectl if True (except if objectl is nil, in this case returns EgTRUE).
This function has the same semantic as the WOOL function equal.
EgObjectEval | - Evaluâtes an object
EgObjectlnternEval | - Evaluâtes an object
EgObject EgObjectEvaKoώ/ecD
EgObject object; EgObject EgObjectlnternEval(oύ/ect)
EgObject object;
Evaluation of many objects returns the object itself. Evaluation of list calls the function found as first item with following items as parameters.
The function EgObjectEval returns EgERROR if an error occurs.
The function EgObjectlnternEval doesn't care of errors. So it must not be used except if you are quite sure that the code using it is executed from a WOOL function.
This is the Dasic function 10 call tne WOOL interDreie: ANNEXE 7 (suite)
EgObjectGetCValue | - Gets C value of an object
EgCValue EgObjectGetCValue (object) EgObject object;
See also: EgVariableGetCValue, EgObjectCreate, EgObjectModify
MODIFICATION (in release 0.δ4 ) : The old name of this function was EgObject-GetCValue.
EgObjectlsSubclass | - Checks the class of an object int EgObjectlsSubclass (object, class) EgObject object; EgClass class;
EgObjectlsSubclass returns True or False.
EgObjectGetClass will probably not be available in next version.
EgObjectModify - Sets C value of an object void EgObjectModify (object, anyCValue) EgObject object; EgCValue anyCValue;
This function is very dangerous to use because of the border effect. It is the reason why its name is not EgObjectSetCValue. This can be necessary to set to NULL the value which is a pointer when the pointer is no longer valid. But this lead to some problems about type checking...
EgObjectPπnt | - Prints the wool object
EgObject EgObjectPrint (object) EgObject object;
See also EgPrintf, EgPuts, EgPutChar.
EαPointerDefine - define a shared variable
To Define a variable shared by the interpréter and the application, use EgPointerDefine. The shared value is always an integer. void EgPointerDefine {name, pointer) char * name; EGCValue pointe" ANNEXE 7 (suite)
The différence with EgVariableSetCValue is that the argument is not a WOOL value but an address to a C value. This allows the interpréter and the application to set the value of the same memory address. From the WOOL side, an object of type Integer is created to hold this value.
From the application side : long int fooBar;
EgPointerDefine("foo-bar", (EgCValue *) &fooBar); fooBar ≈ 78;
And from the WOOL side :
(print foo-bar) = = > 78
EgPrintf
EgPuts
EgPutChar print on current output stream void EgPrintf(char *string, void *arg) void EgPutsfc *string) void EgPutChar(char c)
EgPrintfC'there is %d widgets created" , number);
EgPutsC'hello");
EgPutc('\n');
EgVariableGetObject EgVariableSetObject - get or set wool value of a variable void EgVariableSetObject (name, object) char * name;
EgObject object; EgObject EgVariableGetObject (name) char * name;
Assign an object to a WOOL variable.
Thèse functions are différent from EgVariableSetCValue and EgVariableSetCValue which manipulate C values and implicitly create a WOOL object.
MODIFICATION: (in release 0. δ4 ) : The old names were EgVariableAssignObject and EgVariableConsultObject.
| EgWaming j - print a warning error vc.d EgWarning (stringFormat, value) char *stringFormat; long value;
Priπts a warninα message and continues the exécution. See also: EgError. if (x < = Ô) {
EgWarning ("x (%d) is not positive", x) ;
REMPLACEMENT

Claims

REVENDICATIONS
1. Outil interactif de définition d'interface caractérisé en ce qu'il utilise un langage interprété et que l'interpréteur est embarqué avec le programme de définition d'interface.
2. Outil interactif selon la revendication 1 caractérisé en ce quel langage a une représentation similaire pour les données et les programmes.
3. Outil interactif selon la revendication 1 ou 2 caractérisé en ce que le programme de définition coopère avec une bibliothèque d'objets interactifs ("widget") une bibliothèque d'objets, de commandes "X/MOTIF" et une bibliothèque d'objets graphiques ("GO") .
4. Outil interactif selon l'une des revendications 1 à 3 caractérisé en ce que le programme est constitué d'un mélange d'instructions en langage C et d'instructions en langage interprétable.
5. Outil interactif selon la revendication 4 caractérisé en ce que l'interpréteur est orienté objet en langage "LISP".
6. Outil interactif selon une des revendications précédentes caractérisé en ce que l'interpréteur de l'éditeur d'interface utilise des tableaux.
7. Outil interactif selon la revendication 6 caractérisé en ce que le noyau de 1'interpréteur est constitué comme une matrice à deux dimensions, l'une de types contenant les listes, les chaînes, les nombres..., l'autre de sélecteurs
("eval, print, free, add...").
8. Outil interactif selon une des revendications précédentes caractérisé en ce que l'interpréteur ("WOOL") comporte un ramasse-miettes ou glaneur de cellules (Garbage Collector, G.C; incrémental permettant de temps a autre et de façon cyclique de balayer la mémoire à la recherche d'objets inutilisés dont l'espace peut être réutilisé.
9. Outil interactif selon la revendication 8 caractérisé en ce que le Glaneur de Cellules utilise des compteurs de référence et un mécanisme de regroupement des objets par tailles pour limiter la fragmentation de la mémoire.
10. Outil interactif selon une des revendications précédentes caractérisé en ce que les fonctions de l'outil interactif sont décrites sous forme d'un programme interprété.
11. Utilisation d'un outil selon une des revendications précédentes pour la réalisation d'une interface caractérisée en ce que l'archivage de la présentation de l'interface éditée est effectuée comme celui d'un programme en langage "WOOL".
12. Outil interactif selon la revendication 3 caractérisée en ce que la spécification interactive de la géométrie d'assemblage de ces objets est constituée par un fichier utilisable par une application et contenant la présentation d'un interface utilisateur.
13. Outil interactif selon les revendications 3 ou 11 caractérisé en ce que le comportement dynamique des objets interactifs ("widgets") est défini par un ensemble de procédure de rappel ("callbacks") écrites en langage interprété ("WOOL") qui désignent des fonctions de l'application appelées par la boite à outils "X/MOTIF" lorsqu'un événement d'entrée est reçu par l'un des ("widgets") objets interactifs.
14. Outil interactif selon une des revendications lou 2, ou, 3 ou 11 caractérisé en ce que le programme de définition d'interface est extensible par l'ajout de classes d'objets interactifs ("widgets") effectué en décrivant en langage interprété ("WOOL") les nouveaux types d'attributs de cette classe pour rendre les nouveaux objets interactifs ("widgets") éditables.
15. Outil interactif selon la revendication 14 caractérisé en ce que chaque objet interactif ("widget") étant pointé par un objet en langage interprété ("WOOL") de la classe "WOOL" correspondant à la classe de l'objet interactif ("widget"), les attributs supplémentaires sont directement rattachés à l'objet en langage interprété ("WOOL") .
16. Outil interactif selon la revendication 15 caractérisé en ce que chaque objet en langage interprété ("WOOL") est une structure en langage C auto-typée contenant le type de l'objet et l'information du compte de référence.
17. Outil interactif selon la revendication 3, caractérisé en ce que un identifieur unique est alloué de façon incrémental à chaque objet interactif en langage interprété ("WOOL") .
18. Outil interactif selon la revendication 1 ou 2, ou, 3 ou 13, caractérisé en ce que l'outil interactif de définition d'interface (EGERIA) comporte un programme permettant l'affichage d'un menu de base, comprenant une fonction d'"édition", une fonction de "création", une fonction "géométrie" ("Geometry") .
19. Outil selon la revendication 18, caractérisé en ce que la fonction "création" permet la création de tout objet interactif ("widget") à partir d'un menu et après sélection d'une ligne de menu change la forme du curseur et un clic souris dans un objet interactif contenant ("widget container") installera l'objet du type choisi dans cet objet interactif contenant ("container") .
20. Outil selon la revendication 18, caractérisé en ce que la fonction ("édit") permet l'édition des attributs d'un objet interactif ("widget") dans une renétre séparée et permet de couper, coller, copier ou dupliquer le jeu d'objets interactifs ("widgets") sélectionné ainsi que d'éditer les attributs des objets interactifs ("widgets") parent d'un objet interactif ("widget") sélectionné ou de rendre le parent d'un objet interactif ("widget") couramment sélectionné le nouvel objet interactif ("widget") sélectionné.
21. Outil selon la revendication 18 caractérisé en ce que la fonction "géométrie" ("Geometry") permet de gérer la géométrie d'un ensemble d'objets interactifs ("widgets") sélectionnés qui peuvent être alignés par le sommet, par le bas, par le côté droit, par le côté gauche ou avoir leur largeur ou hauteur identique.
22. Outil selon la revendication 20 caractérisé en ce que la fonction "édition" permet l'affichage d'une fenêtre d'édition des attributs d'un objet interactif ("widget") , la dite fenêtre étant divisée en deux zones, 1'une comportant les fonctions appelées de l'application procédure rappel ("callback"), l'autre comportant les attributs matérialisés par un jeu de sous-éditeurs.
23. Outil selon la revendication 22 caractérisé en ce que le premier sous-éditeur est constitué d'un bouton bascule pour entrer des attributs booléens.
24. Outil selon la revendication 22 caractérisé en ce que le second sous-éditeur est constitué d'un bouton poussoir affichant un menu affichant les listes des valeurs d'un type énuméré (exemple : alignement d'un texte à gauche, à droite ou centré) .
25. Outil selon la revendication 22 caractérisé en ce que le troisième sous-éditeur est constitué d'une zone de texte pour la saisie des textes ou des valeurs numériques.
26. Outil selon la revendication 20 caractérisé en ce que la fonction d'édition des objets interactifs interpréteurs de commande (Shell"widget") ou des objets généraux (Top level "widget") est lancée en sélectionnant d'abord le menu ("sélect parent") de sélection de parent du menu et ensuite la fonction d'édition d'attribut ("edit attribute").
PCT/FR1993/000749 1992-07-22 1993-07-21 Utilisation d'un langage a interprete embarque pour la realisation d'un outil interactif de definition d'interface utilisateurs WO1994002895A1 (fr)

Priority Applications (3)

Application Number Priority Date Filing Date Title
US08/211,133 US5696914A (en) 1992-07-22 1993-07-21 Using an embedded interpreted language to develop an interactive user-interface description tool
KR1019940700954A KR0136349B1 (ko) 1992-07-22 1993-07-21 내장 해석 언어를 사용한 대화식 사용자-인터페이스 기술 도구
JP50421894A JP3348853B2 (ja) 1992-07-22 1993-07-21 インターフェース記述用対話型ツール

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
FR9209057A FR2694105B1 (fr) 1992-07-22 1992-07-22 Utilisation d'un langage à interprète embarqué pour la réalisation d'un outil interactif de définition d'interface utilisateurs.
FR92/09057 1992-07-22

Publications (1)

Publication Number Publication Date
WO1994002895A1 true WO1994002895A1 (fr) 1994-02-03

Family

ID=9432152

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/FR1993/000749 WO1994002895A1 (fr) 1992-07-22 1993-07-21 Utilisation d'un langage a interprete embarque pour la realisation d'un outil interactif de definition d'interface utilisateurs

Country Status (7)

Country Link
US (2) US5696914A (fr)
EP (1) EP0580509B1 (fr)
JP (1) JP3348853B2 (fr)
KR (1) KR0136349B1 (fr)
DE (1) DE69324966T2 (fr)
FR (1) FR2694105B1 (fr)
WO (1) WO1994002895A1 (fr)

Cited By (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JPH0895796A (ja) * 1994-09-29 1996-04-12 Nec Corp 異なる言語間のコールバック関数設定方式
US7943292B2 (en) 1993-06-04 2011-05-17 Biotime, Inc. Physiologically acceptable aqueous solutions and methods for their use

Families Citing this family (125)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CA2123924A1 (fr) * 1993-06-02 1994-12-03 Charles Douglas Blewett Definition de contextes en programmation a rappel
US7424731B1 (en) 1994-10-12 2008-09-09 Touchtunes Music Corporation Home digital audiovisual information recording and playback system
US8661477B2 (en) 1994-10-12 2014-02-25 Touchtunes Music Corporation System for distributing and selecting audio and video information and method implemented by said system
US7188352B2 (en) 1995-07-11 2007-03-06 Touchtunes Music Corporation Intelligent digital audiovisual playback system
ATE188793T1 (de) 1994-10-12 2000-01-15 Touchtunes Music Corp Intelligentes system zur numerischen audio- visuellen reproduktion
US6314570B1 (en) * 1996-02-08 2001-11-06 Matsushita Electric Industrial Co., Ltd. Data processing apparatus for facilitating data selection and data processing in at television environment with reusable menu structures
FR2753868A1 (fr) 1996-09-25 1998-03-27 Technical Maintenance Corp Procede de selection d'un enregistrement sur un systeme numerique de reproduction audiovisuel et systeme pour mise en oeuvre du procede
US5793368A (en) * 1996-11-14 1998-08-11 Triteal Corporation Method for dynamically switching between visual styles
EP0951706A4 (fr) * 1996-12-03 2000-02-23 Ergolight Ltd Appareil informatise et procedes d'identification des problemes d'utilisation d'un systeme informatise
US5815149A (en) * 1997-02-19 1998-09-29 Unisys Corp. Method for generating code for modifying existing event routines for controls on a form
KR19980075429A (ko) * 1997-03-31 1998-11-16 윤종용 이동통신 시스템의 기지국 관리장치에서 위젯의 폰트 변경 방법
US7779020B2 (en) * 2002-03-01 2010-08-17 International Business Machines Corporation Small-footprint applicative query interpreter method, system and program product
FR2769165B1 (fr) 1997-09-26 2002-11-29 Technical Maintenance Corp Systeme sans fil a transmission numerique pour haut-parleurs
UA55489C2 (uk) * 1997-10-07 2003-04-15 Каналь+ Сосьєте Анонім Пристрій для багатопотокової обробки даних (варіанти)
US6230318B1 (en) * 1998-02-24 2001-05-08 Microsoft Corporation Application programs constructed entirely from autonomous component objects
US6405159B2 (en) * 1998-06-03 2002-06-11 Sbc Technology Resources, Inc. Method for categorizing, describing and modeling types of system users
US6282524B1 (en) 1998-07-20 2001-08-28 Pitney Bowes Inc. Method and system of printing postage indicia from an envelope design application
US6384931B1 (en) 1998-07-20 2002-05-07 Pitney Bowes Inc. Method and system for capturing destination addresses from label data
FR2781582B1 (fr) 1998-07-21 2001-01-12 Technical Maintenance Corp Systeme de telechargement d'objets ou de fichiers pour mise a jour de logiciels
FR2781580B1 (fr) 1998-07-22 2000-09-22 Technical Maintenance Corp Circuit de commande de son pour systeme de reproduction audiovisuelle numerique intelligent
FR2781591B1 (fr) 1998-07-22 2000-09-22 Technical Maintenance Corp Systeme de reproduction audiovisuelle
US8028318B2 (en) 1999-07-21 2011-09-27 Touchtunes Music Corporation Remote control unit for activating and deactivating means for payment and for displaying payment status
US6859919B1 (en) * 1998-10-16 2005-02-22 Computer Associates Think, Inc. Object modeling tool with meta model semantic registry (rules) a meta data manager for object(s) properties an object/property interface for instance(s) of objects/properties received via object/property interface of the object factory registry
KR20010089309A (ko) 1998-10-16 2001-09-29 엘그레시 도론 ２ 이상의 모델들간의 차이점을 결정하는 방법
US6947037B1 (en) * 1998-11-05 2005-09-20 Computer Associates Think, Inc. Method and apparatus for interfacing with intelligent three-dimensional components
US8121891B2 (en) * 1998-11-12 2012-02-21 Accenture Global Services Gmbh Personalized product report
US7076504B1 (en) 1998-11-19 2006-07-11 Accenture Llp Sharing a centralized profile
US6195651B1 (en) 1998-11-19 2001-02-27 Andersen Consulting Properties Bv System, method and article of manufacture for a tuned user application experience
US8726330B2 (en) 1999-02-22 2014-05-13 Touchtunes Music Corporation Intelligent digital audiovisual playback system
WO2000072184A2 (fr) * 1999-05-24 2000-11-30 Matsushita Mobile Communication Development Corp. Of U.S. Systeme independant de plate-forme indiquant une interface utilisateur enfouie
US7086007B1 (en) 1999-05-27 2006-08-01 Sbc Technology Resources, Inc. Method for integrating user models to interface design
US7224790B1 (en) 1999-05-27 2007-05-29 Sbc Technology Resources, Inc. Method to identify and categorize customer's goals and behaviors within a customer service center environment
US6476828B1 (en) 1999-05-28 2002-11-05 International Business Machines Corporation Systems, methods and computer program products for building and displaying dynamic graphical user interfaces
FR2796482B1 (fr) 1999-07-16 2002-09-06 Touchtunes Music Corp Systeme de gestion a distance d'au moins un dispositif de reproduction d'informations audiovisuelles
US6909439B1 (en) * 1999-08-26 2005-06-21 International Business Machines Corporation Method and apparatus for maximizing efficiency of small display in a data processing system
US7734457B2 (en) * 1999-10-16 2010-06-08 Computer Associates Think, Inc. Method and system for generating dynamic comparison models
FR2805377B1 (fr) 2000-02-23 2003-09-12 Touchtunes Music Corp Procede de commande anticipee d'une selection, systeme numerique et juke-box permettant la mise en oeuvre du procede
FR2805072B1 (fr) 2000-02-16 2002-04-05 Touchtunes Music Corp Procede d'ajustement du volume sonore d'un enregistrement sonore numerique
FR2805060B1 (fr) 2000-02-16 2005-04-08 Touchtunes Music Corp Procede de reception de fichiers lors d'un telechargement
GB0004090D0 (en) * 2000-02-22 2000-04-12 Innovation Venture Ltd Application programming system and method of operation thereof
US7505817B2 (en) 2000-03-06 2009-03-17 Siemens Technology-To-Business Center, Llc Programming automation by demonstration
US6778643B1 (en) 2000-03-21 2004-08-17 Sbc Technology Resources, Inc. Interface and method of designing an interface
US20040006473A1 (en) * 2002-07-02 2004-01-08 Sbc Technology Resources, Inc. Method and system for automated categorization of statements
US6995853B1 (en) 2000-03-31 2006-02-07 Pitney Bowes Inc. Method and system for modifying print stream data to allow printing over a single I/O port
US6678889B1 (en) 2000-05-05 2004-01-13 International Business Machines Corporation Systems, methods and computer program products for locating resources within an XML document defining a console for managing multiple application programs
FR2808906B1 (fr) 2000-05-10 2005-02-11 Touchtunes Music Corp Dispositif et procede de gestion a distance d'un reseau de systemes de reproduction d'informations audiovisuelles
FR2811175B1 (fr) 2000-06-29 2002-12-27 Touchtunes Music Corp Procede de distribution d'informations audiovisuelles et systeme de distribution d'informations audiovisuelles
FR2811114B1 (fr) 2000-06-29 2002-12-27 Touchtunes Music Corp Dispositif et procede de communication entre un systeme de reproduction d'informations audiovisuelles et d'une machine electronique de divertissement
FR2814085B1 (fr) 2000-09-15 2005-02-11 Touchtunes Music Corp Procede de divertissement base sur les jeux concours a choix multiples
US20020124236A1 (en) * 2000-12-27 2002-09-05 Ruths Derek Augustus Samuel Method of manipulating a distributed system of computer-implemented objects
US7631265B1 (en) 2000-12-29 2009-12-08 Gateway, Inc. System and method for configuring and loading a user interface
DE10065323C2 (de) * 2000-12-31 2003-10-30 Siemens Ag Verfahren zur Steuerung der Anordnung von graphischen Elementen
US6779175B2 (en) * 2001-05-22 2004-08-17 Thermwood Corporation Method and system for converting graphic databases into coded workpiece processing programs
DE10134270A1 (de) * 2001-07-18 2003-02-06 Heidenhain Gmbh Dr Johannes Verfahren zur Erzeugung pixelorientierter Bilddateien zur Darstellung graphischer Symbole durch eine numerische Steuerung
US7065201B2 (en) * 2001-07-31 2006-06-20 Sbc Technology Resources, Inc. Telephone call processing in an interactive voice response call management system
AU2002334770A1 (en) * 2001-10-09 2003-04-22 Grey Zone, Inc. Data driven access to tools
US7305070B2 (en) * 2002-01-30 2007-12-04 At&T Labs, Inc. Sequential presentation of long instructions in an interactive voice response system
US6914975B2 (en) 2002-02-21 2005-07-05 Sbc Properties, L.P. Interactive dialog-based training method
US8151304B2 (en) 2002-09-16 2012-04-03 Touchtunes Music Corporation Digital downloading jukebox system with user-tailored music management, communications, and other tools
US11029823B2 (en) 2002-09-16 2021-06-08 Touchtunes Music Corporation Jukebox with customizable avatar
US8584175B2 (en) 2002-09-16 2013-11-12 Touchtunes Music Corporation Digital downloading jukebox system with user-tailored music management, communications, and other tools
US10373420B2 (en) 2002-09-16 2019-08-06 Touchtunes Music Corporation Digital downloading jukebox with enhanced communication features
US8103589B2 (en) 2002-09-16 2012-01-24 Touchtunes Music Corporation Digital downloading jukebox system with central and local music servers
US7822687B2 (en) 2002-09-16 2010-10-26 Francois Brillon Jukebox with customizable avatar
US8332895B2 (en) 2002-09-16 2012-12-11 Touchtunes Music Corporation Digital downloading jukebox system with user-tailored music management, communications, and other tools
US9646339B2 (en) 2002-09-16 2017-05-09 Touchtunes Music Corporation Digital downloading jukebox system with central and local music servers
CA2406025A1 (fr) * 2002-09-30 2004-03-30 Ibm Canada Limited-Ibm Canada Limitee Validation de contenu de fichiers de donnees de localisation
US20040095388A1 (en) * 2002-11-15 2004-05-20 Rocchetti Robert J. Method and apparatus for creating user interfaces for computing devices
US7324912B2 (en) * 2002-11-25 2008-01-29 Lsi Logic Corporation Method, system and programming language for device diagnostics and validation
US8468227B2 (en) * 2002-12-31 2013-06-18 Motorola Solutions, Inc. System and method for rendering content on multiple devices
US7240292B2 (en) 2003-04-17 2007-07-03 Microsoft Corporation Virtual address bar user interface control
US7712034B2 (en) 2003-03-24 2010-05-04 Microsoft Corporation System and method for shell browser
US7769794B2 (en) 2003-03-24 2010-08-03 Microsoft Corporation User interface for a file system shell
US7421438B2 (en) 2004-04-29 2008-09-02 Microsoft Corporation Metadata editing control
US7823077B2 (en) 2003-03-24 2010-10-26 Microsoft Corporation System and method for user modification of metadata in a shell browser
US7627552B2 (en) 2003-03-27 2009-12-01 Microsoft Corporation System and method for filtering and organizing items based on common elements
US7650575B2 (en) 2003-03-27 2010-01-19 Microsoft Corporation Rich drag drop user interface
US7925682B2 (en) * 2003-03-27 2011-04-12 Microsoft Corporation System and method utilizing virtual folders
CA2433527A1 (fr) * 2003-06-26 2004-12-26 Ibm Canada Limited - Ibm Canada Limitee Systeme et methode pour interpreteur de commandes integre graphique et oriente objet
EP1652074A4 (fr) * 2003-07-11 2008-08-13 Computer Ass Think Inc Adjonction a un outil de modelisation d'objets definis par un utilisateur
CA2445427A1 (fr) * 2003-10-17 2005-04-17 Ibm Canada Limited - Ibm Canada Limitee Methode et systeme d'edition d'enonces de langage de programmation orientes en colonnes
US8024335B2 (en) 2004-05-03 2011-09-20 Microsoft Corporation System and method for dynamically generating a selectable search extension
US20050114818A1 (en) * 2003-11-21 2005-05-26 Lsi Logic Corporation Chip design command processor
US20050123892A1 (en) * 2003-12-05 2005-06-09 Cornelius William A. Method, system and program product for developing and utilizing interactive simulation based training products
US7451431B2 (en) * 2003-12-12 2008-11-11 International Business Machines Corporation Registry driven real-time configuration of resource management objects for deployment in an instance of an integrated solutions console
US7027586B2 (en) 2003-12-18 2006-04-11 Sbc Knowledge Ventures, L.P. Intelligently routing customer communications
US7694236B2 (en) 2004-04-23 2010-04-06 Microsoft Corporation Stack icons representing multiple objects
US7657846B2 (en) 2004-04-23 2010-02-02 Microsoft Corporation System and method for displaying stack icons
US8707209B2 (en) 2004-04-29 2014-04-22 Microsoft Corporation Save preview representation of files being created
US8302020B2 (en) 2004-06-25 2012-10-30 Apple Inc. Widget authoring and editing environment
US7490295B2 (en) 2004-06-25 2009-02-10 Apple Inc. Layer for accessing user interface elements
US7546543B2 (en) 2004-06-25 2009-06-09 Apple Inc. Widget authoring and editing environment
US7761800B2 (en) 2004-06-25 2010-07-20 Apple Inc. Unified interest layer for user interface
US7614016B2 (en) 2005-04-21 2009-11-03 Microsoft Corporation Multiple roots in navigation pane
US8195646B2 (en) 2005-04-22 2012-06-05 Microsoft Corporation Systems, methods, and user interfaces for storing, searching, navigating, and retrieving electronic information
US7665028B2 (en) 2005-07-13 2010-02-16 Microsoft Corporation Rich drag drop user interface
US7694308B1 (en) * 2005-07-15 2010-04-06 Sprint Communications Company L.P. Enterprise application mapping tool and datastore with target state dimension
US7752556B2 (en) 2005-10-27 2010-07-06 Apple Inc. Workflow widgets
US7707514B2 (en) 2005-11-18 2010-04-27 Apple Inc. Management of user interface elements in a display environment
US7568162B2 (en) * 2006-06-09 2009-07-28 International Business Machines Corporation Visual helps while using code assist in visual tools
US20080098325A1 (en) * 2006-10-23 2008-04-24 Carnet Williams Method and system for facilitating social payment or commercial transactions
US9171419B2 (en) 2007-01-17 2015-10-27 Touchtunes Music Corporation Coin operated entertainment system
US9330529B2 (en) 2007-01-17 2016-05-03 Touchtunes Music Corporation Game terminal configured for interaction with jukebox device systems including same, and/or associated methods
JP2008219501A (ja) * 2007-03-05 2008-09-18 Ricoh Co Ltd 画像処理装置、画像処理方法及び画像処理プログラム
US9953481B2 (en) 2007-03-26 2018-04-24 Touchtunes Music Corporation Jukebox with associated video server
US20080270919A1 (en) * 2007-04-27 2008-10-30 Kulp Richard L Context Based Software Layer
US8954871B2 (en) 2007-07-18 2015-02-10 Apple Inc. User-centric widgets and dashboards
US8332887B2 (en) 2008-01-10 2012-12-11 Touchtunes Music Corporation System and/or methods for distributing advertisements from a central advertisement network to a peripheral device via a local advertisement server
US10290006B2 (en) 2008-08-15 2019-05-14 Touchtunes Music Corporation Digital signage and gaming services to comply with federal and state alcohol and beverage laws and regulations
WO2010005569A1 (fr) 2008-07-09 2010-01-14 Touchtunes Music Corporation Jukebox de téléchargement numérique à caractéristiques d'amélioration des recettes
US20100031147A1 (en) * 2008-07-31 2010-02-04 Chipln Inc. Method and system for mixing of multimedia content
KR20100086677A (ko) * 2009-01-23 2010-08-02 삼성전자주식회사 커뮤니티 위젯 제공 방법 및 장치
US10564804B2 (en) 2009-03-18 2020-02-18 Touchtunes Music Corporation Digital jukebox device with improved user interfaces, and associated methods
US9292166B2 (en) 2009-03-18 2016-03-22 Touchtunes Music Corporation Digital jukebox device with improved karaoke-related user interfaces, and associated methods
US10719149B2 (en) 2009-03-18 2020-07-21 Touchtunes Music Corporation Digital jukebox device with improved user interfaces, and associated methods
KR101748448B1 (ko) 2009-03-18 2017-06-16 터치튠즈 뮤직 코포레이션 엔터테인먼트 서버 및 관련 소셜 네트워킹 서비스
CA2881456A1 (fr) 2010-01-26 2011-08-04 Touchtunes Music Corporation Dispositif de juke-box numerique ayant des interfaces d'utilisateur perfectionnees, et procedes associes
GB2522772B (en) 2011-09-18 2016-01-13 Touchtunes Music Corp Digital jukebox device with karaoke and/or photo booth features, and associated methods
US11151224B2 (en) 2012-01-09 2021-10-19 Touchtunes Music Corporation Systems and/or methods for monitoring audio inputs to jukebox devices
USD705787S1 (en) * 2012-06-13 2014-05-27 Microsoft Corporation Display screen with animated graphical user interface
US9519701B2 (en) * 2012-12-26 2016-12-13 Sap Se Generating information models in an in-memory database system
EP3049920A1 (fr) 2013-09-27 2016-08-03 Rudolf Markus Petri Procédé et dispositif de génération et de production automatiques d'au moins une application logicielle
WO2015070070A1 (fr) 2013-11-07 2015-05-14 Touchtunes Music Corporation Techniques de création de dispositions d'une interface utilisateur graphique d'un menu électronique destinées à être utilisées en association avec des dispositifs électroniques
EP3123293A4 (fr) 2014-03-25 2017-09-27 Touchtunes Music Corporation Dispositif de juke-box numérique ayant des interfaces utilisateurs améliorées, et procédés associés
US10782963B2 (en) * 2017-09-11 2020-09-22 Siemens Industry Software GmbH Introducing artifact information system and method

Citations (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
EP0395606A2 (fr) * 1989-04-28 1990-10-31 International Business Machines Corporation Procédé d'allocation d'espace mémoire

Family Cites Families (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US4912629A (en) * 1986-06-26 1990-03-27 The United States Of America As Represented By The Administrator Of The National Aeronautics And Space Administration Real-time garbage collection for list processing using restructured cells for increased reference counter size
US4811240A (en) * 1986-12-22 1989-03-07 International Business Machines Corporation System for creating and controlling interactive graphic display screens
US5206951A (en) * 1987-08-21 1993-04-27 Wang Laboratories, Inc. Integration of data between typed objects by mutual, direct invocation between object managers corresponding to object types
US4989132A (en) * 1988-10-24 1991-01-29 Eastman Kodak Company Object-oriented, logic, and database programming tool with garbage collection
US5243697A (en) * 1989-03-15 1993-09-07 Sun Microsystems, Inc. Method and apparatus for selecting button functions and retaining selected options on a display

Patent Citations (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
EP0395606A2 (fr) * 1989-04-28 1990-10-31 International Business Machines Corporation Procédé d'allocation d'espace mémoire

Non-Patent Citations (4)

* Cited by examiner, † Cited by third party
Title
NEC RESEARCH AND DEVELOPMENT. no. 98, Juillet 1990, TOKYO, JP pages 89 - 97 H. TARUMI ET AL. 'CANAE - A USER INTERFACE CONSTRUCTION ENVIRONMENT WITH EDITORS AS SOFTWARE PARTS' *
PROCEEDINGS OF THE WINTER 1992 USENIX CONFERENCE. 20 Janvier 1992, BERKELEY, CA, US pages 111 - 123 D. BLEWETT ET AL. 'X WIDGET BASED SOFTWARE TOOLS FOR UNIX' *
RESEARCH DISCLOSURE. no. 319, Novembre 1990, EMSWORTH, GB page 863 31916 'TABLE-DRIVEN METHOD FOR OPTION PROCESSING' *
THE VISUAL COMPUTER. vol. 8, no. 2, Février 1992, ALLEMAGNE pages 94 - 116 B.A. MYERS ET AL. 'ENVIRONMENT FOR RAPIDLY CREATING INTERACTIVE DESIGN TOOLS' *

Cited By (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US7943292B2 (en) 1993-06-04 2011-05-17 Biotime, Inc. Physiologically acceptable aqueous solutions and methods for their use
JPH0895796A (ja) * 1994-09-29 1996-04-12 Nec Corp 異なる言語間のコールバック関数設定方式

Also Published As

Publication number Publication date
DE69324966T2 (de) 1999-11-11
US5974253A (en) 1999-10-26
EP0580509B1 (fr) 1999-05-19
JP3348853B2 (ja) 2002-11-20
JPH06510879A (ja) 1994-12-01
EP0580509A1 (fr) 1994-01-26
KR0136349B1 (ko) 1998-06-15
US5696914A (en) 1997-12-09
FR2694105A1 (fr) 1994-01-28
FR2694105B1 (fr) 1994-11-25
DE69324966D1 (de) 1999-06-24

Similar Documents

Publication Publication Date Title
EP0580509B1 (fr) Utilisation d&#39;un langage à interprète embarqué pour la réalisation d&#39;un outil interactif de définition d&#39;interface utilisateurs
Darwin Android Cookbook: Problems and Solutions for Android Developers
Lutz Programming Python: powerful object-oriented programming
Hashimi et al. Pro Android 3
Komatineni et al. Pro Android 4
Blanchette et al. C++ GUI programming with Qt 4
Mednieks Programming android
Seibel Practical common lisp
US9524279B2 (en) Help document animated visualization
Lazar et al. Mastering Qt 5: Create stunning cross-platform applications using C++ with Qt Widgets and QML with Qt Quick
Troelsen et al. C# 6.0 and the. NET 4.6 Framework
Mackey Introducing. NET 4.0: With Visual Studio 2010
Bolin Closure: The definitive guide: Google tools to add power to your JavaScript
MacLean et al. Pro Android 5
Yener et al. Expert Android Studio
Horton Ivor Horton's Beginning Java 2
Panigrahy Xamarin Mobile Application Development for Android
Annuzzi et al. Advanced Android application development
Alessandria et al. Flutter Cookbook: Over 100 proven techniques and solutions for app development with Flutter 2.2 and Dart
Topley JavaFX Developer's Guide
Lewis et al. Native mobile development: a cross-reference for iOS and Android
Ducasse et al. Pharo by Example 5.0
Moore Mastering GUI programming with Python: Develop impressive cross-platform GUI applications with Pyqt
Edge et al. Cross-Platform UIs with Flutter: Unlock the ability to create native multiplatform UIs using a single code base with Flutter 3
Mechtley et al. Maya Python for Games and Film: A Complete Reference for the Maya Python API

Legal Events

Date Code Title Description
AK Designated states

Kind code of ref document: A1

Designated state(s): JP KR US

WWE Wipo information: entry into national phase

Ref document number: 08211133

Country of ref document: US