[langage C - GTK+] Fonction window_set_resizable

[piwi]

Bonjour à tous.

Je progresse dans ma connaissance du C et actuellement je suis en train d'apprendre à créer des fenêtres. Je pense avoir compris comment fonctionnent les fonctions de personnalisation mais la fonction window_set_resizable me pose un souci.

void gtk_window_set_resizable(GtkWindow *window, gboolean resizable);

Juste histoire d'être au clair, pour voir si je maitrise la théorie. La fonction appelle deux paramètres:
1. Appel de la fenêtre. La fonction attend un type GtkWindow* or on déclare la fenêtre sous le type GtkWidget*. Du coup, j'utilise la macro GTK_WINDOW() pour faire la conversion.
2. Paramètre booléen.
- TRUE: la fenêtre est redimensionnable
- FALSE: la fenêtre n'est pas redimensionnable

Considérant ceci, pour rendre ma fenêtre non redimensionnable, j'entre la ligne suivante dans mon code

gtk_window_set_resizable(GTK_WINDOW(MaFenetre), FALSE);

Le résultat de ceci est que la fenêtre apparait minuscule indépendamment de la taille initiale spécifiée et je ne comprends pas pourquoi. Quelqu'un sait? Et évidemment comment faire pour que la fonction fonctionne comme attendue?

Note:
Je suis sous Linux Ubuntu.
J'utilise Code::Blocks et le compilateur est GNU GCC.

Par avance merci pour tout,
cordialement,
piwi
-----

[inviteb9f49292]

Le résultat de ceci est que la fenêtre apparait minuscule indépendamment de la taille initiale spécifiée et je ne comprends pas pourquoi. Quelqu'un sait?

Par hazard, ta fenêtre ne serait-elle pas vide? Une fenêtre s'affiche selon sa taille minimale permettant à ses composeants d'être visibles. Si il n'y a rien à l'intérieur, c'est normal qu'elle s'affiche en tout petit.
Le fait que ce phénomène apparraisse avec la fonction "gtk_window_set_resizable" est très certainement un "effet de bord".

Je progresse dans ma connaissance du C et actuellement je suis en train d'apprendre à créer des fenêtres.

Je ne suis pas sûr que tu ai choisi la bonne voie d'apprantissage avec GTK+. En effet, c'est du C utilisé dans une conception objet, ce qui est, je pense, déroutant lorsque l'on débute. Ce qui me confirme un peu ça c'est ta phrase

La fonction attend un type GtkWindow* or on déclare la fenêtre sous le type GtkWidget*. Du coup, j'utilise la macro GTK_WINDOW() pour faire la conversion.

le type "GtkWidget" est une classe générique dont dérive la classe "GtkWindow", le créateur de "GtkWindow" "gtk_window_new" (je suppose) retourne un pointeur de type "GtkWidget" mais c'est un "artifice technique" pour pouvoir faire de l'objet en C. Il me semble important de comprendre la notion de POO avec un langage "fait pour" (C++, jAVA...), _ET_ d'avoir de bonne base en C "classique" pour pouvoir mieux comprendre GTK+. De plus la documenttation de GTK+ est, je trouve, le gros point faible de cette bibliothèque.

[piwi]

Bonjour.

Tout d'abord, merci pour ta réponse précise et intéressante.
Concernant la fenetre, effectivement, c'était une fenêtre vide pour un programme test. Je n'ai pas eu l'initiative de tester la fonction sur une fenêtre avec un bouton. J'essairais ce soir, on verra bien.

Maintenant, pourquoi j'ai choisi d'utiliser GTK+.
Je ne suis absolument pas informaticien et je n'entends pas le devenir. Mon objectif est simplement de gagner une relative autonomie qui me permettra de réaliser quelques programmes simples qui pourront éventuellement me servir dans ma vie de tous les jours de biologiste.
Il y a une dizaine d'années j'avais commencé à apprendre le C++ sans y retoucher depuis. En revenant vers la programmation, je me suis dis qu'il fallait y aller tranquillement afin de bien assoir des bases. C'est pourquoi je me suis réorienté vers le C justement pour éliminer dans un premier temps la notion objet, et je suis reparti du début.
Maintenant, j'ai un petit projet fil rouge qui nécessite trois choses:
ma logique
le langage de programmation
une interface conviviale

Le choix de GTK arrive au troisième point. Ce dont j'ai besoin, c'est d'une fenetre avec des boites d'entrées de texte, des boutons, et une sortie de texte. J'ai essayé de coder une fenetre via windows.h, c'est long, c'est pénible. Il m'a semblé que GTK pouvait faire tout ce dont j'ai besoin. Ce qu'il faut bien comprendre c'est que je ne le vois que comme une boite à outil. Je veux pouvoir m'en servir, pas nécessairement comprendre à fond comment il marche.

Mais je suis un gars curieux! Tu me dis que GTK est codé en C mais orienté objet. Comment?
J'ai compris qu'il y avait une hiérarchie entre les différents éléments de GTK avec une notion d'héritage. Quand tu parles de classe pour GtkWidget par exemple. Est ce qu'il s'agit d'une vraie classe au sens C++? Moi j'avais compris cette notion de hérarchie comme ayant a voir avec les listes chainées (d'où les pointeurs). J'ai un peu compris quelque chose ou je suis à la masse?
Sinon, pourquoi toujours créer un GtkWidget que l'on "transforme" (j'ai lu transtyper sans réellement comprendre le sens profond du mot) en autre chose? Enfin dernière question, que font exactement les macro (de transtypage?) type GTK_WINDOW()?

Je ne sais pas si tu auras la patience de discuter avec moi. Mais comment jusqu'à présent je progresse seul, je pense que discuter certains points devrait être enrichissant.

Cordialement,
piwi

Note: je vais chercher de la doc sur la programmation orientée objet en C.

[inviteb9f49292]

C'est pourquoi je me suis réorienté vers le C justement pour éliminer dans un premier temps la notion objet

Le C est un langage compliqué car il oblige le développeur à faire de la sale besogne, le genre de sale besogne qui est gérée automatiquement par un langage comme JAVA par exemple. De plus, la notion d'objet n'a finalement pas grand chose à voir avec le langage, mais c'est une notion, je pense, indispensable, en informatique quelque soit le domaine (je fais de l'informatique embarquée, je ne fais que du C et pourtant mon type de conception est très souvent orientée objet).

Comme tu ne souhaites pas te reconvertir dans l'informatique, je pense que tu devrais t'orienter vers un langage qui réponds mieux à ton besoin. JAVA pourrait être pas mal car multi-plateforme, beaucoup de bibliothèques existentes, design d'IHM assez facile etc...
Il y a certainement mieux comme langage pour "bricoleurs débutants" (ce n'est pas péjoratif), mais je ne pourrais pas plus t'aider, je n'y connais rien à tous ces PERL, RUBY et autres PYTHON.

Si tu décides de continuer malgré tout avec le C:
Bravo, c'est le plus beau langage (après le français, encore que...). Si tu sais faire tes coeurs d'algo en C, il te reste l'aspect IHM à apprendre. Et pour ça, je persiste et signe, laisse tomber GTK+ (attention c'est une très bonne bibliothèque, mais vraiment pas orienté pour les débutants / développeurs occasionnels). Jette un coup d'oeil à Qt, c'est du C++ donc la syntaxe est celle du C plus des fioritures, la doc officielle est complète et détaillée, des tuto en français et de qualité en abondance sur la toile... De plus, tu mettras un pieds dans l'objet, et si tu utilises Qt dans sa toute puissance, et pas seulement comme bibliothèque graphique, tu pourras faire des applications portables (les aspects réseau, multi-thread etc font partie de la bibliothèque).

Mais je suis un gars curieux! Tu me dis que GTK est codé en C mais orienté objet. Comment?

C'est une bonne maladie.
Je ne connais pas en profondeurs GTK+, j'en suis un simple utilisateur, si tu veux bien comprendre le détail je pense que la seule solution est de regarder les sources du composeant "GObject" dispo dans la "glib".

Quand tu parles de classe pour GtkWidget par exemple. Est ce qu'il s'agit d'une vraie classe au sens C++?

Non pas au sens strict du C++ puisque ce langage possède le mot clef "class" pour rendre compte du concept de classe de la programmation OO. Et c'est là que l'on touche à la difficulté de GTK+ (et de la POO en C): comme en C le mot clef "class" n'existe pas, il faut faire appel à des artifices de codages pour rendre compte de la notion de classe.

Moi j'avais compris cette notion de hérarchie comme ayant a voir avec les listes chainées (d'où les pointeurs). J'ai un peu compris quelque chose ou je suis à la masse?

Non c'est plutôt basé sur l'aggregation, en deux mots de pseudo code:

struct ClasseBase {
   int _entier;
};

struct ClasseDerivee {
   struct ClasseBase super;
   int _autre;
}

struct ClasseDerivee obj;
(struct ClasseBase*)(&obj) == &obj;
/* valide ssi le champ "parent" est le premier champ de la structure derivee */
(struct ClasseBase*)(&obj)->_entier = 12345; 
obj.super._entier == 12345;

Voici 2 pointeurs que je trouvent pas trop mal pour comprendre comment faire de l'objet en C:
celui-làpour les 1er chapitres
et celui-ci.

Sinon, pourquoi toujours créer un GtkWidget que l'on "transforme" (j'ai lu transtyper sans réellement comprendre le sens profond du mot) en autre chose?

Attention transtyper ce n'est pas transformer, mais manipuler une instance d'un type comme une instance d'un certain type (à priori différent).
C'est tout l'intérêt de la POO, imagines que tu ai besoin d'un tableau d'objet graphique, alors tu déclares un tableau de "GtkWidget*", puis au moment de la création de chacun des objets tu les spécialises en "GtkWindow" et autre "GtkDialog". Pour leur utilisation, soit tu fais appelles a une méthode "générale" de "GtkWidget", auquel cas tu te fiches de savoir quel est le type exact de l'objet sur lequel tu appelles la méthodes, soit c'est une méthode propre une classe dérivée ("gtk_window_set_resizable" pour la classe "GtkWindow" par ex), auquel cas il faut s'assurer que l'instance est bien une GtkWindow ou dérivé.

Enfin dernière question, que font exactement les macro (de transtypage?) type GTK_WINDOW()?

Elles font (si je me souviens bien) bien plus que du transtypage puisqu'elles vérifient que le transtypage est valide au point de vue de la hierachie des classes: GTK_WINDOW vérifie que l'instance que tu lui passes est de type GtkWindow ou d'une classe dérivée de GtkWindow, puis transtype (simple cast).

J'espère t'avoir apporté quelques débuts de fragments d'éléments de réponses.

[A voir en vidéo sur Futura]

[piwi]

Merci beaucoup pour ta réponse qui m'apporte pas mal d'informations.

Je ne prends absolument pas mal d'être un programmeur du dimanche (ou locution synonyme). C'est ce que je suis et c'est en l'assumant pleinement que je pense progresser le mieux. Je n'ai aucune prétention.
En revanche j'ai un objectif, à savoir obtenir une autonomie suffisante pour pouvoir prétendre à "avoir des connaissances dans les languages de programmation C/C++". De plus en plus, l'informatique entre dans la biologie par diverses portes. En apprenant à programmer je ne fais donc pas que m'amuser, je développe une compétence qui me sera sans doute utile dans mon travail comme sur mon CV. C'est pourquoi, si je ne me mets aucune pression et si j'integre une notion de plaisir dans tout cela, j'essaie de le faire avec méthode et rigueur.
Pour cela, je me suis constitué un projet fil rouge ambitieux pour moi, mais dont les tenants me semblent raisonnables. J'ai appris à utiliser le language C pour faire ce dont j'ai besoin pour ce fil rouge. J'ai déjà développé plusieurs outils qui fonctionnent en C "mode console" . Donc, pour répondre à ta question de la maitrise de l'algo, je ne prétends pas être capable de tout faire, mais je sais déjà faire plusieurs choses, et en tout cas je suis dans les clous des objectifs que je me suis fixé. Comme tu le disais, je suis à me pencher sur l'interface utilisateur/programme. Ceci réponds à une autre de tes questions. Je pense m'être suffisamment investi dans le C pour qu'il soit dommage de lacher maintenant pour me retourner vers un autre language. Je vais attendre d'être plus à l'aise avec le C avant de regarder ailleurs. Je pense que ce sera plus facile si j'ai déjà une bonne base solide sur laquelle m'appuyer pour tout de suite cerner les similitudes et les différences et comprendre comment se structure un language d'une manière générale. Je ne perds pas de vue ton conseil et je retiens qu'il faudra que je m'intéresse au Java

Je ne sais pas pourquoi je me suis tourné vers GTK en fait... Sans doute parce que, un peu perdu, j'ai survolé des tutos et que j'ai vu dans GTK les moyens de faire ce que je veux faire. Je vais quand même suivre ton conseil et je vais regarder de près Qt. Toutefois, à l'utilisation, GTK n'est quand même pas très compliqué (pour l'instant! Je n'ai vu que comment faire une fenetre, un bouton, un label et je suis en train de voir pour les entrées textes). Si je ne comprends pas totalement ce qu'il y a sur le moteur, j'arrive quand même à le faire fonctionner (enfin, pour l'instant), et pour moi, disons dans un premier temps, c'est l'essentiel.

Sinon, merci pour l'explication technique. Je pense avoir compris l'explication du transtypage.

Je risque de revenir ce soir, une fois que j'aurais mis un peu les mains dans tout cela.

@+
piwi

[inviteb9f49292]

En apprenant à programmer je ne fais donc pas que m'amuser, je développe une compétence qui me sera sans doute utile dans mon travail comme sur mon CV.

Ah! Tu ne voulais pas faire de l'informatique ton métier, mais l'utiliser de manière professionnelle c'est, à mon sens, presque tout comme, finie de jouer, on utilise les outils des pros. Je ne connais pas franchement de logiciel orienté biologie, mais si la performance peu être une nécessité, alors pas d'hésitation il faut effectivement s'orienter sur le C / C++. D'autre pourrait te conseiller JAVA, mais pour un "pro" (même occasionnel) je suis franchement pas fan...

Je pense m'être suffisamment investi dans le C pour qu'il soit dommage de lacher maintenant pour me retourner vers un autre language.

Je suis d'accords, mais l'aspect POO est indispensable (ne serait ce que pour les IHM), mais difficilement accessible par le C en 1ère approche.

Je vais quand même suivre ton conseil et je vais regarder de près Qt.

C'est, à mon avis, la meilleure solution pour toi car:
1°) c'est du C++, donc ce que tu connais du C te servira, et le "surplus" de syntaxe est pas énorme. En plus, tu pourras récupérer les bout de code en C que tu aurais déjà écris tel que.
2°) Plus tu utiliseras les modules de la bibliothèque Qt, plus tes applications seront portables (moyennant recompilation) sur Windows, MAC, Solaris... La portabilité c'est le genre de truc qu'il faut penser dès l'écriture, après c'est (souvent) trop tard.
3°) Un premier contact avec de la POO facile.
4°) Une fois que tu sais faire une IHM avec Qt, tu verras que faire de l'IHM en JAVA ou en GTK+ (les seuls autres avec lesquels j'ai "jouer") c'est franchement identique.

Je risque de revenir ce soir, une fois que j'aurais mis un peu les mains dans tout cela.

Il y a peu de chance vu la qualité de la documentation Qt... Bon amusement / apprentissage.