1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
Welcome to GNUstep Renaissance!
GNUstep Renaissance is free software (GNU LGPL), and part of the
GNUstep project. It is a development framework which runs on top of
the GNUstep libraries or on top of the Apple Mac OS X Cocoa
frameworks, providing an opaque layer to write portable applications.
GNUstep Renaissance is mostly useful to:
- write GUIs for GNUstep and Apple Cocoa in an open, portable format.
The GUIs are described by an open, simple, human-editable XML file
which works on GNUstep (GNU/Linux, *BSD), GNUstep (Windows) and
Apple Cocoa.
- generate GUIs for GNUstep and Apple Cocoa programmatically. Have
your code or scripts generate simple XML data describing your
windows and GUIs; Renaissance will magically create the GUIs from
the XML.
- write GUIs for GNUstep and Apple Cocoa without using Gorm or
Interface Builder. You can create a new GUI by writing an XML
description of your windows using a simple text editor (vi or emacs
will do). The XML is extremely simple and is designed to be a
pleasure to edit by hand.
- write GUIs for GNUstep and Apple Cocoa that can be translated
easily in a large number of languages. Renaissace decouples the
GUI localization from the GUI design, allowing you to easily
translate your software in a number of languages, and making easy
the maintenance of translations. An end-to-end localization
toolchain based on gettext is planned for Renaissance 1.0 - which
will finally allow you to have GNUstep or Apple Cocoa applications
that are as easy to translate as any other gettext-based system.
In short, GNUstep Renaissance allows you to describe your user
interfaces (that is, the windows in your application, and the buttons,
boxes, textfields, etc in the windows) in simple and intuitive XML
files, using an open, standard format describing the logic of the
interface. GNUstep Renaissance can then, at run time, generate the
user interfaces (using the native host OpenStep-like libraries) by
reading the XML files. The connections between the objects created
from the XML files, and the other objects in the application are done
via outlets (as traditionally in OpenStep); a new quick and intuitive
syntax has been developed to make creating outlets as easy as
possible.
GNUstep Renaissance contains quite a few new ideas over previous
technologies. Some of the main end-user advantages of GNUstep
Renaissance over previous OpenStep-inspired technologies for the same
task are:
- Portability. User interfaces built using GNUstep Renaissance are
truly portable. They simply run without any change on any
OpenStep-based platform on which Renaissance has been ported
(currently, at least on both GNUstep and Apple Mac OS X).
- Open, simple and standard format. User interfaces built using
GNUstep Renaissance are saved into open, simple files which can be
edited and read on any platform using any text editor. The XML
format has been designed to be as easy to edit as possible. We will
have a specific graphical builder for GNUstep Renaissance, which will
make editing directly the XML files a rare operation; still, it's a
great advantage to be able to actually edit and inspect them directly
whenever needed. Your user interfaces will no longer be locked in
binary files which can only be edited using a specific
platform-specific application; you will be able to compare different
versions of the same user interface using diff and cvs diff (you
can't get any meaningful comparison with binary formats); and your
user interfaces will be finally stored in a readable format, which
you can read even from a terminal, making your program easier to
check. The format is so nice that I expect many hard hackers will
keep creating user interfaces directly in XML even when a graphical
editor is available!
- Easy localization. User interfaces built using GNUstep Renaissance
are much easier to translate than in all previous technologies. You
no longer need to create a new separate interface for the new
language: you can just provide the translation of the strings in a
.strings file, and GNUstep Renaissance will automatically replace
every string in the existing interface with the corresponding
translation. Previous technologies can't do this because they don't
support automatic sizing and layout of widgets.
- Themeability. Themes are a problem for traditional OpenStep-like
technologies, because a change in theme changes all the widgets
appearances and sizes. User interfaces built using GNUstep
Renaissance can survive easily a change in theme, since all sizing
and layout of widgets is done dynamically at runtime. Previous
technologies can't, and you would need to create a different user
interface for each different theme.
GNUstep Renaissance compares favourably to other non-OpenStep
technologies for similar tasks as well:
- Easy, intuitive integration with the rest of the software. GNUstep
Renaissance uses outlets and connections (which are made possible by
Objective-C) to connect at run time user interface objects to other
objects in the application. This is the traditional magic used by
NIB files (of NeXTstep and OpenStep fame) to integrate user
interfaces with the rest of the program. When a file is loaded, you
can have arbitrary instance variables of objects in your application
automatically set to point to newly created buttons or other widgets;
and vice versa, you can have instance variables and properties of
user interface objects set to point to objects in your application.
You can control very easily these connections from the file itself.
- More intelligent autolayout mechanism. GNUstep Renaissance
implements new autolayout ideas whereby each object in the interface
contains enough intelligence to provide an intelligent default
autoresizing behaviour. For example, buttons automatically know they
should not be resizable, while editable textfields automatically know
they should be resizable horizontally but not vertically. Containers
automatically gather all this information, and can automatically
compute reasonable borders and alignments, and use them to layout
automatically without programmer's intervention. The result is that
you can create a window by just creating objects, and putting them in
boxes -- without having to spend time setting spacing, borders,
resizing behaviours -- unless you really need to, in order to get a
special effect. In the normal case, you will at most need to set a
few align flags (left vs center vs right). This cuts down on
development time a lot, and also creates better user interfaces,
since GNUstep Renaissance is following a strict, mechanical logic
when choosing autolayout behaviours: programmers often pay too little
attention to sizing and layout flags and details, resulting in user
interfaces which work but which often have quite a lot inconsistent
(or simply wrong) sizing and layout details. This can't happen with
GNUstep Renaissance.
Renaissance is composed of the following blocks:
- AutoLayout: a collection of autolayout objects (h/v boxes, grids,
spaces, ...), providing automated runtime widget layout, similar to
what you find in most other toolkits on the market ... similar, but
better :-) The missing piece of the AppKit. Depends on gnustep-gui.
- Markup: an xml parsing/generating engine. Depends on gnustep-base.
- TagLibrary: a standard set of tag objects for use by the xml
parsing/generating engine in order to read/write gui windows, menus,
panels, etc. Depends on the previous parts: AutoLayout and Markup.
Renaissance was written by Nicola Pero
(nicola.pero@meta-innovation.com) and is part of the GNUstep project
(http://www.gnustep.org).
GNUstep Renaissance home page is at http://www.gnustep.it/Renaissance.
|
