Nouvelle version de l'éditeur a terminaux intégrés it-edit (version 2.91).

Le , par Luke spywoker, Membre expérimenté
it-edit (Integrated Terminals Editor) est disponible en version 2.91.

Cette nouvelle version n'apporte pas de nombreuses améliorations par rapport à la version 2.0, mais constitue une étape importante, car elle est désormais basée sur la nouvelle version majeure de la bibliothèque libvte (bibliothèque implémentant un widget d'émulateur de terminal, utilisé par Gnome-terminal.) it-edit se met donc à niveau. À cette occasion, de nombreux bugs et imperfections ont été corrigés.






* Page officielle de it-edit-2.91

* Paquets Debian de it-edit-2.91

* Tarball de it-edit-2.91

* it-edit-2.91 sur Github

* README de it-edit-2.91

* ChangeLog de it-edit-2.91




La plus importante des améliorations étant l'utilisation du chargeur de fichiers intégré à la bibliothèque gtksourceview3.0, qui permet de charger des fichiers codés dans tous les jeux de caractères (pas seulement UTF-8) ; l'éditeur s'est bien sûr amélioré avec le temps et la sortie des nouvelles moutures d'Ubuntu (Xenial) et de Debian (Jessie) ayant bien évolué depuis les versions précédentes.

Une intégration de la coloration syntaxique pour de nouveaux langages a été faite, comme par exemple le ReST sur lequel se base le générateur de documentation sphinx.

Concernant libvte (sur laquelle le nouveau gnome-terminal est basé) de nouvelles fonctionnalités apparaissent dans les menus contextuels des terminaux de it-edit :

* ouvrir un nouvel onglet dans le panneau latéral de terminaux ;
* fermer l'onglet actuel depuis ce panneau latéral ;
* incrémenter la taille de la police (Font-scale, aussi configurable depuis le panneau de configuration) ;
* décrémenter la taille de la police (Font-scale, aussi configurable depuis le panneau de configuration) ;
* réinitialiser le terminal ;
* et d'autres, accessibles depuis le panneau de configuration ;
* la mauvaise nouvelle étant que libvte ne permet plus de mettre des images en arrière-plan des terminaux…




Mais je vous invite à tester ou à mettre à jour vers cette nouvelle version de it-edit en espérant que vous en serez satisfait(e). Je pense qu'il est utile de réellement tester un outil avant de l'adopter.

PS: it-edit ne se limite pas aux distributions de la famille Debian, il suffit de disposer des bibliothèques nécessaires par le biais du build de it-edit-2.91 basé sur les autotools.


Vous avez aimé cette actualité ? Alors partagez-la avec vos amis en cliquant sur les boutons ci-dessous :


 Poster une réponse

Avatar de gerald3d gerald3d - Membre expert https://www.developpez.com
le 22/07/2016 à 9:09
Salut Luke.

Je vois que tu ne chômes pas cet été . Je viens d'installer la toute nouvelle version (2.91) sur ma Debian sid. Pas de souci particulier de ce côté là.

Je lance l'application sans problème. J'ouvre un premier fichier, je le modifie et je le ferme. Aucun message d'avertissement pour me dire que le fichier est modifié et non sauvé ! Gênant, non ?

Autre petite chose. Lorsque tu ouvres un fichier, le premier onglet vide reste vide. Un nouvel onglet s'ouvre pour afficher le fichier sélectionné. Ca serait peut être d'ouvrir ce fichier dans l'onglet vide de départ.
Avatar de Luke spywoker Luke spywoker - Membre expérimenté https://www.developpez.com
le 23/07/2016 à 13:06
Salut gérald3d,

Je lance l'application sans problème. J'ouvre un premier fichier, je le modifie et je le ferme. Aucun message d'avertissement pour me dire que le fichier est modifié et non sauvé ! Gênant, non ?
Cela fait plusieurs fois que tu me fait la remarque sur l'avertissement manquant concernant la petite croix (16x16) dans le tab pour fermer le fichier.

Je pense qu'il est inutile de mettre un message d'avertissement sur cette croix car il existe de multiples manières de sauver un fichier et puis quand il ne l'est pas un asterix est placer a coté du nom de fichier ouvert...

Cela saute peut-être aux yeux quand ont teste mais en pratique:

cela fait plus d'un an que j'utilise cet éditeur et fermer un fichier non-sauvegarder par mégarde m'est arriver qu'une seule et unique fois alors que j'ai de maintes fois fermer des fichier non-sauvegarder exprésemment.

Je ne veut pas submerger l'utilisateur que je suis de messages pas forcement utiles quand l'on sait ce que l'on fait.

----

Et puis Firefox me gonfle a force de me demander si je désire confirmer l'exit du programme quand il y a plus d'un onglet ouvert. Alors qu'est-ce que ça serai si il le faisait par onglet...

Autre petite chose. Lorsque tu ouvres un fichier, le premier onglet vide reste vide. Un nouvel onglet s'ouvre pour afficher le fichier sélectionné. Ca serait peut être d'ouvrir ce fichier dans l'onglet vide de départ.
Effectivement c'est le comportement par défaut quand on ouvre l'application sans fichiers sélectionnés
sinon si l'on ouvre un|des fichiers grâce aux navigateur de fichiers le|les fichiers sélectionnés sont ouvert dans l'éditeur, d'ailleurs il est possible de mettre it-edit comme éditeur par défaut (par le biais du panneau de configuration) et dans ce cas là plus de besoin de "open with" c'est automatique.

Car la plupart des mimetypes de fichier textes sont lié a l'éditeur it-edit (excluant la famille XML et XSLT (*.html, *.htm)) .

Comme quoi il faut utiliser l'éditeur un peu plus que 2 ou 3 tests avant de décider si l'on désire vraiment s'en servir (une semaine est suffisante), comme toute applications importante je pense.

Mais n'hésite pas a critiquer mon oeuvre, c'est toujours la bienvenue même une mauvaise critique, car cela me fait avancer.

PS:

Sinon je voulais te demander si tu savait construire un paquetage debian a la sauce Launchpad car mes paquetages fonctionne parfaitement et sont valide (lintian) car je les construit avec

$ dpkg -b

mais Launchpad ou plutôt debuild demande de remplacer le fichier control par un fichier nommer changelog ce qui n'a de sens:

Launchpad dit qu'il n'accepte que les fichiers debian contruit avec:

$ debuild -S
Avatar de Luke spywoker Luke spywoker - Membre expérimenté https://www.developpez.com
le 03/12/2016 à 23:28
Changement subite du comportement de it-edit ?

Vous avez récemment fait une mise a jour de votre distribution,

et vous avez remarquer que votre éditeur avec terminaux intégrées: it-edit

souffrait de problèmes récurrents...

Et bien c'est sûrement a cause d'un changement de version de Gtk3 (<= gtk+-3.18 vers >= gtk-+3.20).




Introduction aux changements

Quand je distribue un programme sous forme de tarball ou de paquetage debian

et bien je copie les sources dans le dossier ${pkgdatadir} (/usr(/local)/share/it-edit/source) accompagner

d'un Makefile, multi-usages.




Je vous recommande donc de faire les peu de changements présenté içi,

grâce aux sources, et au Makefile, livrée avec it-edit.

Afin que it-edit soit de nouveau comme avant !




Problème de police de caractères ?

Si vous avez remarquer que it-edit a changer de police après la mise a jours

et que cela vous dérange, je vous invite a faire le petit changement suivant

dans la fonction situé dans le fichier situé:

/usr(/local)/share/it-edit/source/GUI/configure/configure_gui_elements.c
nommer: setting_sourceview_settings(...).

Une fois que vous avez trouver le fichier:

éditer le ainsi: Vous pouvez faire un copier-coller en écrasant la fonction.

Code : Sélectionner tout
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
 
 
void setting_sourceview_settings(GtkSourceView *view) {
  /** Configure the GtkSourceView according to configuration. **/
 
  #ifdef DEBUG
    DEBUG_FUNC_MARK
  #endif
 
  gtk_source_view_set_auto_indent(view, settings.use_auto_indent) ;
  gtk_source_view_set_indent_on_tab(view, TRUE);
  gtk_source_view_set_indent_width(view, settings.indent_width) ;
 
  gtk_source_view_set_insert_spaces_instead_of_tabs(view, settings.use_spaces_as_tabs);
  /** FIXME: ??? gtk_source_view_set_smart_home_end(view, GTK_SOURCE_SMART_HOME_END_BEFORE) ;   ??? **/
 
 
  gtk_source_view_set_show_line_numbers(view, settings.display_line_numbers) ;
 
  gtk_source_view_set_tab_width(view, settings.tabs_width) ;
 
  if (settings.display_tabs_chars) {
    gtk_source_view_set_draw_spaces(view, GTK_SOURCE_DRAW_SPACES_TAB) ;
  }
 
 
 
 
  /** This part of the function can be replace,
  GtkCssProvider *provider = gtk_css_provider_new ();
 
  gchar *text_css = g_strconcat("GtkTextView {\n"
                                 "font : ",
                                 settings.editor_font,
                                 "}\n",
                                 NULL) ;
 
 
  gtk_css_provider_load_from_data(provider, text_css, -1, NULL) ;
 
  g_free(text_css) ;
 
 
  GdkDisplay *display = gdk_display_get_default() ;
 
  GdkScreen *screen = gdk_display_get_default_screen(display) ;
 
  gtk_style_context_add_provider_for_screen (screen, GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_USER) ;
 
 
 
  g_object_unref(provider) ;
  */
 
  /** By this GtkTextView configuration setting: **/
  gtk_text_view_set_monospace( GTK_TEXT_VIEW(view), TRUE ) ;
 
  return ;
 
}
Cela remplace la police actuelle par la police Monospace par défaut du widget GtkTextView.




Problèmes au démarrage de it-edit

Si vous avez des problèmes en lançant it-edit:

- La barre latéral de terminaux qui ne s'affiche plus, ou quand elle veut.

- Problèmes d'affichage de la barre de recherche(s) et de remplacement(s).

- Des problèmes pour ouvrir un fichier.

Éditez la fin de la fonction main(...) situé dans le fichier:

/usr(/local)/share/it-edit/source/main.c
Comme cela,

changez juste la fin de la fonction main(...) afin d'introduire la boucle (while(...) indiquer) au bon endroit:

Code : Sélectionner tout
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
 
 
/** ...  **/
 
int main(int argc, char*argv[]) {
 
  //...
 
  /** Hide the search and replace bar at application start. **/
  gtk_widget_hide(gui->search_and_replace-search_and_replace_main_vbox) ;
 
  /** Hide the terminals at application start. **/
  gtk_widget_hide(gui->terminal_notebook) ;
 
 
  /** Insert the following loop (which wait until all events are completed)
    * is sufficent so that you get no problems by starting it-edit.
    ************************************************************************/
  while ( gtk_events_pending() ) {
 
    gtk_main_iteration() ;
 
  }
 
 
 
  /** Set editor notebook page. **/
  gtk_notebook_set_current_page(GTK_NOTEBOOK(gui->main_notebook), 0) ;
 
 
 
  /** This function set the terminals default size in relationship to your screen relationship because the application is maximize at start. And set startup settings. **/
  g_signal_connect(G_OBJECT(gui->main_window), "size-allocate", G_CALLBACK(on_size_allocated), NULL) ;
 
  gtk_main() ;
 
  exit(EXIT_SUCCESS) ;
 
}
 
/** ... **/



Rendez les changements effectifs

Une fois ces deux fonctions réparés,

il nous reste a compiler it-edit de nouveau et a le réinstaller dans le dossier des binaires.

Aller dans le dossier ${pkgdatadir} situer à:

/usr(/local)/share/it-edit
Et taper la commande suivante:

Code : Sélectionner tout
1
2
3
4
5
$ sudo make install
# or
$ su root
...
$ make install
Maintenant it-edit devrai fonctionner comme avant a part que si vous

avez éditer la fonction setting_sourceview_settings(...)

et bien vous ne devriez pas pouvoir changer la police de l'éditeur.

Mais elle ne vous plaisait pas de toute façon.

Peut-être subsiste-t-ils encore quelques problèmes mineurs

que je n'ai pas encore remarquer avec la nouvelle mouture de Gtk3.

Mais malgré tout it-edit reste un bon éditeur avec terminaux intégrés.




Infos et News

Une nouvelle version de it-edit est prévue pour l'année prochaine !

Je n'ai actuellement pas encore écrit une seule ligne mais mon savoir concernant gtk s'est affutée...

Je vous promet un it-edit encore plus puissant pour l'année prochaine...

Quelques idées d'améliorations en vrac:

- La possibilité d'ouvrir une URI non locale.

- La possibilité de mettre les permission voulus lors de la sauvegarde

Cela permettra aux programmeurs qui utilisent un langage de script

qu'il n'y aura plus de besoin de rendre la script exécutable

pour le lancer immédiatement dans un des terminaux intégrer.
- L'on corrigera ce petit problème avec l'historique qu'a it-edit.

Et que le gnome-terminal semble avoir aussi.
- Peut-être que it-edit embarquera un correcteur orthographique,...

Merci a tout les utilisateurs de it-edit,

Votre serviteur.
Avatar de gerald3d gerald3d - Membre expert https://www.developpez.com
le 10/12/2016 à 19:29
Bonjour Luke.

Ton projet avance. Il serait peut-être temps pour lui de passer la vitesse supérieure .

En plongeant un peu dans ton code il serait peut être intéressant de le modifier pour le faire passer à la programmation orientée objet façon Gtk+.

Par exemple, tu disposes d'une structure Terminal. Tu pourrais transformer tout ce petit monde en un objet dérivant directement d'un GtkBox. Ainsi, il te suffirait de déclarer un nouvel objet que tu pourrais appeler GtkItTerm par exemple. Cet objet intégrerait directement un GtkBox, un GtkScrollBar et bien sûr un VteTerminal. Ce n'est qu'un exemple...

Tout ceci pour rendre ton code encore plus robuste et aussi plus facile à maintenir.

Si le cœur t'en dit, je dispose d'un peu de temps devant moi d'ici la fin de l'année pour te mettre le pied à l'étrier .
Avatar de Luke spywoker Luke spywoker - Membre expérimenté https://www.developpez.com
le 26/12/2016 à 20:58
Salut gérald3d,

ça faisait longtemps, en faîtes je ne sais pas du tout comment l'on fait:

+ Un custom widget ( si ce n'est changer la couleur de fond basée sur un gtk_drawing_area ).

+ Et encore moins comment l'on définis un G_OBJECT personnalisé.

Sinon j'avance petit a petit avec la GLib, Gio, pandoc, gdk-pixbuf, mais juste en utilisant les fonctions prédéfinis...

Donc ton aide serai la bienvenue pour une nouvelle version de it-edit.

Sinon, tu peut jeter un coup d'oeil a Micro Music Player (mmp-3.0) pour voir l'avancement de ma technique GTK+, comme l'utilisation d'une GtkApplication au lieu de la paire gtk_init(...)/gtk_main(...) par exemple.

Merci pour ta réponse.

PS:

Il faut dire que les développeurs de GTK+3 ont fait de graves changements, de comportement entre autres, entre 3.18 et >= 3.20.

Est-ce parce que l'on pourrai dire que gtk passe de GTK+-3.1(8) a GTK+-3.2(0) ?

Ou c'est tout le temps comme cela ?
Avatar de gerald3d gerald3d - Membre expert https://www.developpez.com
le 27/12/2016 à 18:54
Je vais te donner un exemple ici qui pourra bien entendu servir à d'autres au cas où.

Tout d'abord il y a un très bon cours ici pour apprendre à créer ses propres objets dérivés d'un GObject. Il y a ensuite deux autres tutos (ici et ) qui expliquent comment créer un widget personnalisé avec gestion des signaux. Enfin il y a la documentation officielle qui aborde aussi le sujet. La lecture de tout ce petit monde est fortement recommandé .

Ceci étant dit, passons à l'exemple.
Je suis parti de ton propre code qui traite des vte terminals. Tu déclares une structure Terminal dans laquelle on trouve ceci :
Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
typedef struct {
 
   /** Structure for one terminal width
     * -) Terminal
     * -) Scrollbar for the terminal.
     * -) hbox container.
     ***********************************/
 
   GtkWidget *terminal ;
 
   GtkWidget *terminal_scrollbar  ;
 
   GtkWidget *terminal_hbox ;
 
} Terminal ;
Au vu de ton code source j'ai décidé de créer un nouvel objet qui dérivera des GtkBox puisque le vte terminal se retrouve à l’intérieur de celui-ci. Ainsi, la déclaration de terminal_hbox devient obsolète. On gardera les deux premières comme données privées.

Le nouvel objet créé portera le doux nom de : GtkItTerm

Pour créer un objet façon Gtk, il faut deux fichiers : un .h et un .c. Rien de bien extraordinaire jusqu'ici. Par contre la déclaration du fichier d'entête doit respecter un certain protocole. Je passe ici l'explication exhaustive étant détaillée dans les liens cités au début de ce post.

Voila donc le le fichier GtkItTerm.h :
Code : Sélectionner tout
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
/** ***********************************************************************************
  * it-edit the Integrated Terminal Editor: a text editor with severals               *
  * integrated functionnalities.                                                      *
  *                                                                                   *
  * Copyright (C) 2015,2016 Brüggemann Eddie.                                         *
  *                                                                                   *
  * This file is part of it-edit.                                                     *
  * it-edit is free software: you can redistribute it and/or modify                   *
  * it under the terms of the GNU General Public License as published by              *
  * the Free Software Foundation, either version 3 of the License, or                 *
  * (at your option) any later version.                                               *
  *                                                                                   *
  * it-edit is distributed in the hope that it will be useful,                        *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of                    *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                      *
  * GNU General Public License for more details.                                      *
  *                                                                                   *
  * You should have received a copy of the GNU General Public License                 *
  * along with it-edit. If not, see <http://www.gnu.org/licenses/>                    *
  *                                                                                   *
  ************************************************************************************/
 
#ifndef __GTK_ITTERM_H__
#define __GTK_ITTERM_H__
 
#include <gtk/gtk.h>
#include <vte-2.91/vte/vte.h>
 
G_BEGIN_DECLS
 
/* G_DECLARE_FINAL_TYPE (GtkItTerm, gtk_itterm, GTK, ITTERM, GtkBox)
 * Les 7 lignes ci-dessous seront à remplacer par la ligne ci-dessus une fois la version de la
 * Glib >= v2.44
 */
#define GTK_ITTERM(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ITTERM, GtkItTerm))
#define GTK_ITTERM_CLASS(class)    (G_TYPE_CHECK_CLASS_CAST ((class), GTK_TYPE_ITTERM, GtkItTermClass))
#define IS_GTK_ITTERM(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ITTERM))
#define IS_GTK_ITTERM_CLASS(class) (G_TYPE_CHECK_CLASS_TYPE ((class), GTK_TYPE_ITTERM))
#define GTK_ITTERM_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ITTERM, GtkItTermClass))
typedef struct _GtkItTerm GtkItTerm;
typedef struct _GtkItTermClass GtkItTermClass;
 
 
#define GTK_TYPE_ITTERM (gtk_itterm_get_type ())
 
/* Définition de la structure qui va contenir toutes les données privées.
 * Sa déclaration se trouvera dans GtkItTerm.c
 */
typedef struct _GtkItTermPrivate GtkItTermPrivate;
 
/* Les deux structures suivantes définissent les structures de base de notre
 * nouveau widget.
 * On peut voir déjà que le parent de _GtkItTerm est un GtkBox.
 */
struct _GtkItTerm {
  GtkBox parent;
 
  GtkItTermPrivate *priv;
};
 
struct _GtkItTermClass {
   GtkBoxClass parent_class;
};
 
/******************************************************************************/
/* Déclaration des différentes fonctions publiques */
 
// Création d'une nouvelle instance
GtkWidget *gtk_itterm_new ();
 
// Récupération du vte terminal
GtkWidget *gtk_itterm_get_vte_terminal (GtkWidget *itterm);
 
// Configuration du vte terminal
void gtk_itterm_configure_terminal(GtkWidget *itterm, gboolean initialize);
 
G_END_DECLS
 
 
#endif
Les commentaires dans le code source éclaireront un peu ta lanterne.

Passons maintenant au code source.
J'ai récupéré encore une fois ton propre code que j'ai modifé pour permettre une compilation et une exécution. C'est mieux pour tester .

J'ai donc codé en dure les données qui proviennent de la structure Settings. Il serait intéressant ici d'intégrer toutes ces données en tant que propriétés du nouvel objet. Ca éviterait ainsi de balader des variables globales. Tu sais combien j'en ai une sainte horreur .

Tu trouveras dans le code source une déclaration d'une structure _GtkItTermPrivate. Toutes les données incluses dans cette structure sont dites privées.

Il est fait usage des pointeurs de fonction pour simuler le comportement d'une classe façon C++. Trois fonctions sont importantes :
Code : Sélectionner tout
1
2
3
static void gtk_itterm_class_init (GtkItTermClass *class);
static void gtk_itterm_init (GtkItTerm *itterm); // Constructeur
static void gtk_itterm_finalize (GObject * object); // Destructeur
Elles permettent d'initialiser le nouvel objet à la manière d'un constructeur et ainsi une fonction qui fait office de destructeur. Intéressant pour libérer la mémoire allouée pour des données internes lors de la destruction de l'objet.
Pour notre GtkItTerm, comme il hérite d'un GtkBox, un gtk_widget_destroy (); lancera en interne la fonction gtk_itterm_finalize ();. C'est transparent pour l'utilisateur final.
Si tu veux voir toutes les fonctions connectables en interne à l'objet c'est par ici.

J'arrête là le blabla, voila le code source complet de GtkItTerm. J'ai volontairement commenté certaines parties du code pour pouvoir compiler ce bout de code avec un main minimaliste. Tu connais mieux ton code source que moi. Tu y retrouveras tes petits .
Code : Sélectionner tout
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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
#include "GtkItTerm.h"
 
/* Private structure definition. */
struct _GtkItTermPrivate
{
  GtkWidget *vteterm ;
  GtkWidget *terminal_scrollbar  ;
};
 
G_DEFINE_TYPE_WITH_PRIVATE (GtkItTerm, gtk_itterm, GTK_TYPE_BOX)
 
static void gtk_itterm_class_init (GtkItTermClass *class);
static void gtk_itterm_init (GtkItTerm *itterm); // Constructeur
static void gtk_itterm_finalize (GObject * object); // Destructeur
 
static void
gtk_itterm_class_init (GtkItTermClass *class)
{
  g_return_if_fail (class != NULL);
 
  G_OBJECT_CLASS(class)->finalize = gtk_itterm_finalize; // destructeur
}
 
static void
gtk_itterm_init (GtkItTerm *itterm)
{
  g_return_if_fail (itterm != NULL);
 
  // Permet d'accéder aux données privées de l'objet
  GtkItTermPrivate *priv = gtk_itterm_get_instance_private (itterm);
 
  // Initialisation des différentes données privées
  priv->vteterm = NULL;
  priv->terminal_scrollbar = NULL;
}
 
static void
gtk_itterm_finalize (GObject *object)
{
  GtkItTermPrivate *priv = gtk_itterm_get_instance_private (GTK_ITTERM(object));
 
  // Destruction des données privées si nécessaire
 
 
  G_OBJECT_CLASS (gtk_itterm_parent_class)->finalize (object);
}
 
 
/******************************************************************************/
void
setup_terminal(GtkWidget *vteterminal, gboolean is_sidebar)
{
 
#ifdef DEBUG
  DEBUG_FUNC_MARK
#endif
 
    //  extern GUI *gui ;
 
      /** Configure terminal partially according to the configuration stored settings. **/
    //  configure_terminal(vteterminal, true) ;
 
 
	char *argv_cmd[2] = {vte_get_user_shell(), NULL} ;
 
	/** Fork a new process: your default shell. The configurations files like .bashrc will be reading. **/
    // The process is killed per example if you closing a terminals tab or by resetting the terminal else it is automatic by exiting the application.
    // So we let no zoombies after us.  
    GPid child_pid ;
 
  gchar **envp = g_get_environ() ;
 
  vte_terminal_spawn_sync(VTE_TERMINAL(vteterminal), VTE_PTY_DEFAULT, g_get_home_dir(), argv_cmd, envp, G_SPAWN_DEFAULT, NULL, NULL, &child_pid, NULL,  NULL);
 
  g_strfreev(envp) ;
 
  vte_terminal_watch_child(VTE_TERMINAL(vteterminal), child_pid) ;
 
  /** Generate clipboard menu connect to the terminal. **/
  GtkWidget *clipboard_menu = gtk_menu_new() ;
 
  GtkWidget *copy_label  = gtk_menu_item_new_with_label("Copy from terminal") ;
  GtkWidget *paste_label = gtk_menu_item_new_with_label("Paste  to terminal") ;
  //GtkWidget *select_all_label = gtk_menu_item_new_with_label("Select all") ;
 
  // TODO: reset, curdir sync
 
 
  GtkWidget *separator_1      = gtk_separator_menu_item_new() ;
  GtkWidget *new_tab_label    = gtk_menu_item_new_with_label("Open new tab");
  GtkWidget *close_tab_label  = gtk_menu_item_new_with_label("Close tab");
 
  GtkWidget *separator_2      = gtk_separator_menu_item_new() ;
  GtkWidget *decr_font_label = gtk_menu_item_new_with_label("Decrease font-scale");
  GtkWidget *incr_font_label = gtk_menu_item_new_with_label("Increase font-scale");
 
  GtkWidget *separator_3      = gtk_separator_menu_item_new() ;
  GtkWidget *reset_label      = gtk_menu_item_new_with_label("Reset terminal");
 
  gtk_menu_shell_append(GTK_MENU_SHELL(clipboard_menu), copy_label)  ;
  gtk_menu_shell_append(GTK_MENU_SHELL(clipboard_menu), paste_label) ;
 
 
  if (is_sidebar) {
 
    gtk_menu_shell_append(GTK_MENU_SHELL(clipboard_menu), separator_1)     ;
    gtk_menu_shell_append(GTK_MENU_SHELL(clipboard_menu), new_tab_label)   ;
    gtk_menu_shell_append(GTK_MENU_SHELL(clipboard_menu), close_tab_label) ;
 
  }
 
  gtk_menu_shell_append(GTK_MENU_SHELL(clipboard_menu), separator_2)       ;
  gtk_menu_shell_append(GTK_MENU_SHELL(clipboard_menu), decr_font_label)   ;
  gtk_menu_shell_append(GTK_MENU_SHELL(clipboard_menu), incr_font_label)   ;
  gtk_menu_shell_append(GTK_MENU_SHELL(clipboard_menu), separator_3)       ;
  gtk_menu_shell_append(GTK_MENU_SHELL(clipboard_menu), reset_label)       ;
 
  /*  GtkAccelGroup *accel_group ;
 
    accel_group = gtk_accel_group_new() ;
      gtk_window_add_accel_group(GTK_WINDOW(gui->main_window), accel_group);
 
      gtk_widget_add_accelerator(GTK_WIDGET(copy_label),  "activate", accel_group, GDK_KEY_Copy,   GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE) ;
      gtk_widget_add_accelerator(GTK_WIDGET(paste_label), "activate", accel_group, GDK_KEY_Insert, GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE) ;
 
 
      gtk_widget_add_accelerator(GTK_WIDGET(incr_font_label),  "activate", accel_group, GDK_KEY_plus,   GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE) ;
      gtk_widget_add_accelerator(GTK_WIDGET(decr_font_label),  "activate", accel_group, GDK_KEY_minus,   GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE) ;
 
      if (is_sidebar) {
 
      gtk_widget_add_accelerator(GTK_WIDGET(new_tab_label),  "activate", accel_group, GDK_KEY_t,      GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE) ;
 
      }
 
 
  gtk_widget_show_all(clipboard_menu) ;
 
  //  g_signal_connect(G_OBJECT(vteterminal), "button-press-event", G_CALLBACK(display_clipboard_menu), clipboard_menu) ;
 
  //  g_signal_connect(G_OBJECT(copy_label),  "activate", G_CALLBACK(clipboard_copy),  vteterminal) ;
  //  g_signal_connect(G_OBJECT(paste_label), "activate", G_CALLBACK(clipboard_paste), vteterminal) ;
 
  g_object_set_data(G_OBJECT(vteterminal), "Pid", &child_pid) ;
  //  g_signal_connect(G_OBJECT(reset_label), "activate", G_CALLBACK(reset_terminal),  vteterminal) ;
 
  //  g_signal_connect(G_OBJECT(incr_font_label),  "activate", G_CALLBACK(increase_font_size),  vteterminal) ;
  //  g_signal_connect(G_OBJECT(decr_font_label),  "activate", G_CALLBACK(decrease_font_size), vteterminal) ;
 
  //  g_signal_connect(G_OBJECT(vteterminal), "increase-font-size", G_CALLBACK(increase_font_size),  vteterminal) ;
  //  g_signal_connect(G_OBJECT(vteterminal), "decrease-font-size", G_CALLBACK(decrease_font_size),  vteterminal) ;
 
  /*  if (is_sidebar) {
      g_signal_connect(G_OBJECT(new_tab_label),   "activate", G_CALLBACK(add_new_terminals),    NULL) ;
 
      gint *ret = g_malloc(sizeof(gint)) ;
 
      *ret = gtk_notebook_get_current_page(GTK_NOTEBOOK(gui->terminal_notebook)) ;
 
      ++(*ret) ;
 
 
      g_signal_connect(G_OBJECT(close_tab_label), "activate", G_CALLBACK(remove_terminal_tabs_from_clipboard),  ret ) ;
 
      }
 
 
      if (! is_sidebar) {
 
      gtk_widget_destroy(separator_1) ;
      gtk_widget_destroy(new_tab_label)  ;
      gtk_widget_destroy(close_tab_label)  ;
 
      }
  */
 
  return ;
 
}
 
GtkWidget *
gtk_itterm_new ()
{
  /** Pack a terminal with a GtkScrollbar in a container. **/
 
#ifdef DEBUG
  DEBUG_FUNC_MARK
#endif
 
    GtkItTerm *itterm = NULL;
  // Création d'un nouvel objet
  itterm  = g_object_new (GTK_TYPE_ITTERM, NULL);
 
  // Il faut indiquer quel est l'orientation du GtkBox
  gtk_orientable_set_orientation (GTK_ORIENTABLE (itterm), GTK_ORIENTATION_HORIZONTAL);
 
  // Récupération du pointeur sur les données privées
  GtkItTermPrivate *priv = gtk_itterm_get_instance_private (itterm);
 
  priv->vteterm = vte_terminal_new() ;
 
  priv->terminal_scrollbar = gtk_scrollbar_new( GTK_ORIENTATION_VERTICAL, gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(priv->vteterm))) ;
 
  /* Cette déclaration devient inutile. Notre objet hérite d'un GtkBox.
   * Nous utilisation directement notre objet pour insérer les éléments à
   * l'intérieur.
   */
  //terminal->terminal_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL,0)  ;
 
 
  gtk_widget_set_redraw_on_allocate(priv->vteterm , TRUE) ;
 
  gtk_box_pack_start(GTK_BOX(itterm), priv->vteterm, TRUE, TRUE, 0) ;
  gtk_box_pack_start(GTK_BOX(itterm), priv->terminal_scrollbar, FALSE, FALSE, 0) ;
 
  gtk_box_set_homogeneous(GTK_BOX(itterm),FALSE);
 
  // Configuration du vte terminal
  gtk_itterm_configure_terminal(GTK_WIDGET (itterm), TRUE);
  setup_terminal(priv->vteterm, FALSE);
 
  return GTK_WIDGET(itterm);
}
 
GtkWidget*
gtk_itterm_get_vte_terminal (GtkWidget *itterm)
{
  if (!itterm || !IS_GTK_ITTERM (itterm))
    {
      g_printerr ("gtk_itterm_get_vte_terminal(); attend un pointeur valide !\n");
      return NULL;
    }
 
  // Récupération du pointeur sur les données privées
  GtkItTermPrivate *priv = gtk_itterm_get_instance_private (GTK_ITTERM(itterm));
 
  return priv->vteterm;
}
 
void
gtk_itterm_configure_terminal(GtkWidget *itterm, gboolean initialize)
{
  /** Configure the VteTerminal according to the configuration. **/
 
#ifdef DEBUG
  DEBUG_FUNC_MARK
#endif
 
    if (!itterm || !IS_GTK_ITTERM (itterm))
      {
	g_printerr ("gtk_itterm_configure_terminal (); attend un pointeur valide !\n");
	return;
      }
 
  GtkWidget *vteterminal = gtk_itterm_get_vte_terminal (itterm);
 
  vte_terminal_set_default_colors(VTE_TERMINAL(vteterminal)) ;
 
  /** Font settings: **/
  PangoFontDescription *font_desc = pango_font_description_from_string("Monospace 10") ;
 
  g_object_set(G_OBJECT(vteterminal), "font-desc", font_desc, NULL) ;
 
  vte_terminal_set_font_scale(VTE_TERMINAL(vteterminal),  1.0) ;
 
 
  /** Cursor settings: **/
  vte_terminal_set_cursor_shape(VTE_TERMINAL(vteterminal), (0 == 0) ? VTE_CURSOR_SHAPE_BLOCK : (0 == 1) ? VTE_CURSOR_SHAPE_IBEAM : VTE_CURSOR_SHAPE_UNDERLINE) ;
 
  vte_terminal_set_cursor_blink_mode(VTE_TERMINAL(vteterminal), (1 == 0) ? VTE_CURSOR_BLINK_SYSTEM : (1 == 1) ? VTE_CURSOR_BLINK_ON : VTE_CURSOR_BLINK_OFF) ;
 
  vte_terminal_set_audible_bell(VTE_TERMINAL(vteterminal), TRUE) ;
 
  vte_terminal_set_mouse_autohide(VTE_TERMINAL(vteterminal), FALSE) ;
 
  /** Bold setting: **/
 
  vte_terminal_set_allow_bold(VTE_TERMINAL(vteterminal), TRUE) ;
 
  GdkRGBA bold_color ;
  gdk_rgba_parse(&bold_color, "#FFFFFF") ;
  vte_terminal_set_color_bold(VTE_TERMINAL(vteterminal), &bold_color) ;
 
 
 
  /** Erasing keys binding. **/
  g_object_set(G_OBJECT(vteterminal), "backspace-binding", (0 == 0) ? VTE_ERASE_AUTO :
	       (0 == 1) ? VTE_ERASE_ASCII_BACKSPACE :
	       (0 == 2) ? VTE_ERASE_ASCII_DELETE :
	       (0 == 3) ? VTE_ERASE_DELETE_SEQUENCE :
	       VTE_ERASE_TTY,
	       NULL) ;
 
  g_object_set(G_OBJECT(vteterminal), "delete-binding", (0 == 0) ? VTE_ERASE_AUTO :
	       (0 == 1) ? VTE_ERASE_ASCII_BACKSPACE :
	       (0 == 2) ? VTE_ERASE_ASCII_DELETE :
	       (0 == 3) ? VTE_ERASE_DELETE_SEQUENCE :
	       VTE_ERASE_TTY,
	       NULL) ;
 
 
 
  /** Colors settings: **/
  GdkRGBA bg_terminal ;
  gdk_rgba_parse(&bg_terminal, "#000000") ;
  GdkRGBA fg_terminal ;
  gdk_rgba_parse(&fg_terminal, "#FFFFFF") ;
 
  vte_terminal_set_color_foreground(VTE_TERMINAL(vteterminal), &fg_terminal) ;
 
  vte_terminal_set_color_background(VTE_TERMINAL(vteterminal), &bg_terminal) ;
 
 
  /** Usual default settings: **/
  vte_terminal_set_scrollback_lines(VTE_TERMINAL(vteterminal),    -1) ;
 
  vte_terminal_set_scroll_on_output(VTE_TERMINAL(vteterminal),    TRUE) ;
 
  vte_terminal_set_scroll_on_keystroke(VTE_TERMINAL(vteterminal), FALSE) ;
 
  if (initialize) {
 
    vte_terminal_set_encoding(VTE_TERMINAL(vteterminal), vte_terminal_get_encoding(VTE_TERMINAL(vteterminal)), NULL)  ;  // default
 
    /** Mouse left button double click word separators: The following characters are not register as word separators. **/
    //   vte_terminal_set_word_char_exceptions(VTE_TERMINAL(vteterminal), vte_terminal_get_word_char_exceptions(VTE_TERMINAL(vteterminal)) ) ;
 
    vte_terminal_set_rewrap_on_resize(VTE_TERMINAL(vteterminal), TRUE) ;
 
    vte_terminal_set_size(VTE_TERMINAL(vteterminal), 80, 24) ;
 
  }
}
Pour finir je te livre le code source du main.c minimaliste que j'ai utilisé pour compiler et exécuter ce code :
Code : Sélectionner tout
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
#include <stdlib.h>
#include <gtk/gtk.h>
 
#include "GtkItTerm.h"
 
gint
main(int argc, char **argv)
{
  GtkWidget *window = NULL;
  GtkWidget *itterm = NULL;
 
  gtk_init(&argc, &argv);
 
  window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 
  /* dimension fenetre */
  gtk_window_set_default_size(GTK_WINDOW(window), 300, 300);
 
  /* titre fenetre */
  gtk_window_set_title(GTK_WINDOW(window), "GtkItTerm");
 
  /* Affectation de la fonction gtk_main_quit(); au signal "destroy" */
  g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
  /* Création d'un GtkItTerm et insertion dans la fenêtre principale */
  itterm = gtk_itterm_new ();
  gtk_container_add (GTK_CONTAINER (window), itterm);
 
 
  gtk_widget_show_all(window);
 
  gtk_main();
 
  return EXIT_SUCCESS;
}
Bonne lecture...
Avatar de Persistant Persistant - Membre du Club https://www.developpez.com
le 30/12/2016 à 8:01
Bonjour a tous,

Le but d'un widget n'est pas de composer des widgets(pour ca, il y a la GtkBuilder). Il faut lui donner des fonctionnalité. (Supprimer la fonction gtk_itterm_get_vte_terminal permet d'avoir des idées)
GtkItTerm pourrai avoir ces fonctionnalitées :
  • * GtkItTerm::change_directory() // Simplifie la synchronisation du repertoir de travail avec le fichier courrant
    * GtkItTerm::print_working_directory() // Afficher le chemin du repertoir courrant
    * GtkItTerm::list() // Afficher les fichiers du repertoir courrant
    * GtkItTerm::switch_profil(/*configuration*/)

Aussi, je propose d'utiliser un GtkBin comme objet mère. Ainsi, il n'est pas possible de faire un gtk_container_add(GTK_CONTAINER(it_term), GTK_WIDGET(mal_venu))

Ha oui! Et pour la mourre du ciel utilisé les feuille de styles et pas les vte_terminal_set_color_bold (un gtk_style_context_add_class devrai faire l'affaire)

Je trouve l'idée super sympa. Ca me rappel Kate(Qt) et Je trouve le code facile a lire et bien foutu, dommage qu'il ne soit pas mieux organiser (beaucoup de gtk_container_add dans le fichier main.c) et qu'il ne respect pas mieux les standar GNU (des petit choses comme source/ au lieu de src/ que les commentaire ne soit pas formaté pour gtk-doc.. des petite choses-fastidieuse- qui viendrons surement avec le temps)

Post-Scriptum:
C'est vrai, les tuto sont excelent. Il m'aurais été impossible de démarrer avec GLib/Gtk sans. Il faut aussi faire attention car il à y des différences suivant la version de GLib utilisé. Chaque version de Gimp se base sur la version de la GLib courrant. Ainsi, si on veux beneficier de la nouvelle version de Gimp, il faut installer la nouvelle version de GLib. Peut etre est-ce une approche a adopter pour éviter les erreur de mise a jour...

Dans les tuto, il y a quand même quelques petites erreur de frappe qui me frappe:

http://nicolasj.developpez.com/gobject/classe/ :
Original Modifier
Code : Sélectionner tout
1
2
3
4
void vehicule_avancer (Vehicule *self, gint distance)
{
  VEHICULE_CLASS (self)->avancer (self, distance);
}
Code : Sélectionner tout
1
2
3
4
void vehicule_avancer (Vehicule *self, gint distance)
{
  VEHICULE_GET_CLASS (self)->avancer (self, distance);
}


Original Modifier
Code : Sélectionner tout
priv = VEHICULE_GET_PROVATE (self);
Code : Sélectionner tout
priv = VEHICULE_GET_PRIVATE (self);


http://franckh.developpez.com/tutori...eation-widget/ :

Original Modifier
Code : Sélectionner tout
1
2
3
4
5
6
void
gtk_led_set_state (GtkLed * led, gboolean state)
{
   led->state = state;
   gtk_led_paint (GTK_WIDGET (led));
}
Code : Sélectionner tout
1
2
3
4
5
6
void
gtk_led_set_state (GtkLed * led, gboolean state)
{
   led->state = state;
   gtk_widget_queue_draw (GTK_WIDGET (led));
}
Avatar de Luke spywoker Luke spywoker - Membre expérimenté https://www.developpez.com
le 30/12/2016 à 10:10
Merci les gars super sympa,

grand merci a celui que j'aime appeler mister GTK (gérald3d) qui a participer (relecture et pointage des fautes) a it-edit version 1.0 et qui vient me donner des idées pour la version 3.0.

Sympa a Persistant (que je connais pas) pour ces idées et d'avoir pointer les fautes des documents.

Je ne peut pas formater mes commentaires a la sauce gtk-doc car j'utilise sphinx et je ne connais pas gtk-doc.

Dommage d'ailleurs car c'est mon format de documentation préféré, mais ont ne choisis pas son destin...

Et dommage aussi pour le dossier nommer "source" au lieu de "src", j'ai pourtant lu le GNU Coding Standart ?

Je vous promet une version 3.0 de it-edit pour l'année prochaine.

Sur ceux bonne fêtes et joyeuse programette et merci beaucoup.
Avatar de Persistant Persistant - Membre du Club https://www.developpez.com
le 30/12/2016 à 11:02
Le temps d'un café j'ai essayé de compiler ...

J'ai fait :
Code : Sélectionner tout
1
2
3
4
5
git clone https://github.com/mrcyberfighter/it-edit-2.91.git
mkdir it-edit-2.91-build
cd it-edit-2.91-build
../it-edit-2.91/configure
make
Et là, c'est le drame, "pas de regle pour fabriquer la règle Icons/*.png"

Du coup j'ai mis la main a la pâte. Et j'ai modifier de cette façon pour que ca compile :
Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
nobase_dist_pkgdata_DATA   = ${top_srcdir}/data/Icons/*.png                   \
                             ${top_srcdir}/data/Icons/16x16/*.png             \
                             ${top_srcdir}/data/Icons/16x16/mimetypes/*.png   \
                             ${top_srcdir}/data/Icons/22x22/*.png             \
                             ${top_srcdir}/data/Icons/64x64/mimetypes/*.png   \
                             ${top_srcdir}/data/License/*.html                \
                             ${top_srcdir}/data/License/*.txt                 \
                             ${top_srcdir}/data/README/*.html                 \
                             ${top_srcdir}/data/README/*.inv                  \
                             ${top_srcdir}/data/README/*.js                   \
                             ${top_srcdir}/data/README/_static/*.gif          \
                             ${top_srcdir}/data/README/_static/*.css          \
                             ${top_srcdir}/data/README/_static/*.js           \
                             ${top_srcdir}/data/README/_sources/*.txt         \
                             ${top_srcdir}/data/Styles/*.sh                   \
                             ${top_srcdir}/data/Styles/*.xml                  \
                             ${top_srcdir}/data/Styles/*.rng
 
EXTRA_DIST = ${top_srcdir}/data/Files_handler/*.conf
Code : Sélectionner tout
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
SUBDIRS = source translations data man texi desktop doc
 
nobase_pkgdata_DATA   =       ${top_srcdir}/source/*.c \
                              ${top_srcdir}/source/Callbacks/*.c \
                              ${top_srcdir}/source/Callbacks/*.h \
                              ${top_srcdir}/source/GUI/configure/*.c \
                              ${top_srcdir}/source/GUI/configure/*.h \
                              ${top_srcdir}/source/GUI/dialogs/*.c \
                              ${top_srcdir}/source/GUI/dialogs/*.h \
                              ${top_srcdir}/source/GUI/setup/*.c \
                              ${top_srcdir}/source/GUI/setup/*.h \
                              ${top_srcdir}/source/Editor/*.c \
                              ${top_srcdir}/source/Editor/*.h \
                              ${top_srcdir}/source/Configuration/*.c \
                              ${top_srcdir}/source/Configuration/*.h \
                              ${top_srcdir}/source/DEBUG/*.c \
                              ${top_srcdir}/source/DEBUG/*.h \
                              ${top_srcdir}/source/Headers/*.c \
                              ${top_srcdir}/source/Headers/*.h \
                              ${top_srcdir}/source/Headers/Structures/*.h \
                              ${top_srcdir}/Makefile.mk
 
 
EXTRA_DIST =  ${top_srcdir}/Makefile.mk \
              ${top_srcdir}/CONTRIBUTORS
Là ca compile, mais quand je fais make install j'ai des probleme... du coup j'ai copier Translations et Icons/* dans mon repertoir d'install
et j'arrive a lancer it-edit avec les icons

J'ai encore un hic quand j'essaie de faire la colorisation syntaxique ...

J'ai pas Kate installé, ca a un impacte ?

PS: Je vais jeter un oeil à sphinx le temps de finir mon café...

PS: Excelent l'étape de configuration (ca a été trop facile de résoudre les dépendances)
Avatar de Luke spywoker Luke spywoker - Membre expérimenté https://www.developpez.com
le 18/01/2017 à 9:57
Oui merci persistant,

J'ai remarquer aussi qu'il faillait mieux éviter les wildcards avec les autotools

Et puis l'erreur vient sûrement de la différence:

nobase_dist_pkgdata_DATA != nobase_pkgdata_DATA
Avant j'utilisais nobase_pkgdata_DATA mais il a fallut que les

"autotools changes their behaviour"

encore une fois !

Le but de nobase_dist_pkgdata_DATA était de mettre a disposition le code source du programme comme je fait a chaque fois avec le Makefile (Makefile.mk)

qui va avec afin que vous puissiez hacker mon code sans devoirs réinstaller le programme a chaque changement dans le code.

Bref cela permet de mettre le code source dans "$(pkgdata)/source" et de générer "$(pkgdata)/Makefile" (Merci pour le rappel a "src" au lieu de "source").

Afin que vous puissiez le hacker une fois installer (esprit malsains s'abstenir).

Je dit encore une fois car j'en ai marre que la rétro-compatibilité soit si peu respecter de nos jours.

---

Je me suit vue contraint d'écrire une nouvelle version de mmp a cause d'un changement de comportement subite dans gtk-3 !

gtk+-3.20 != (<= gtk+-3.18)
Simplement parce que le slider du GtkScale of the timeline blinking with gtk+-3.20 and not with gtk+-3.18 !!!

---

Je crois que toutes nos racines sont bafoués par les nouveaux dev's pour je ne sait quelles raisons épiques:

Qui lit encore le code source d'un programme afin de changer le comportement de celui comme bon lui semble ???

Pas grand monde, c'est sûr, tous ce qui compte "ce n'est plus nous" mais "les clients".

Déjà qu'on a la vit dur en tant que programmeur alors si ont fait de notre art un produit qui doit rapporter gros, j'arrête ici.

---

Bizarre pour le scheme kate pas dispo pourtant la liste des schemes est indiquer en dur dans le code source:

Code : Sélectionner tout
1
2
 
 const char *schemes_string[] = { "build", "classic", "cobalt", "emacs",  "kate", "matrix", "oblivion", "slate", "solarized-dark", "solarized-light", "tango", "turbo", "vsdark", NULL } ;
Ha hic hack:

Tu n'a pas copier les schemes ?

Code : Sélectionner tout
1
2
3
4
 
${top_srcdir}/data/Styles/*.sh                   \
${top_srcdir}/data/Styles/*.xml                  \
${top_srcdir}/data/Styles/*.rng
le script *.sh exécute *.rng pour chaque fichier *.xml.

PS: J'avais pas vue la variable ${top_srcdir} !
Offres d'emploi IT
Dev. linux avec composantes desktop et sécurité - H/F
Preevio - Ile de France - Paris (75000)
Développeur iOS senior pour market place so chic
Mobiskill - Ile de France - Paris (75000)
Ingénieur développement informatique VB.NET, C#, Brest
People Centric - Bretagne - Brest

Voir plus d'offres Voir la carte des offres IT
Contacter le responsable de la rubrique GTK+