(Courriels de diversion: <absorberait@retraiteraient-confus.com> <retarderait@negligions-sasser.com> <demi-cercles@fumiers-insonoriseras.com> <frissonnement@mousses-barmaid.com> <sursauter@gouape-suprematie.com> <escaladerions@magnolia-parlerez.com> <vogua@moyenne-veulerie.com> <defraîchisses@disparaissiez-seyaient.com> <liane@perturberiez-douer.com> <lino@prepares-delimitait.com> )
Vous avez ecrit (dans votre message du 15 5 2003)
> > Pour Qt, je ne partage pas ce point de vue. A moins que mon
> > point de vue ne soit faussé par de mauvaises utilisations
> > de Qt. (loin de moi l'idée de lancer un troll).
> Tu peux préciser ?
> Parce que j'ai même réussi à convertir un mec à fond C-only au
> C++ grâce à Qt. Alors, évidemment, c'est comme tout, Qt a ses
> limites (en particulier, les premieres fois, mettre en place le
> système de build est lourd). Mais j'aimerais sincèrement savoir
> ce qui t'a bloqué.
Puisque l'on m'invite à préciser, je viens de passer 2 minutes dans le
code de qt et j'en ai sortie deux extraits.
Je vous propose de vous mettre à ma place quelques instants et
d'essayer de comprendre ce que fait un bout de programme qt. Par
exemple un objet de type QTextEdit. Donc un petit coup d'oeuil au
fichier de définition de la classe et oh miracle : le premier élément
est une macro qui s'expense pour définir les éléments de base des
objets.
Moi je croyais que c++ était un language objet permettant l'héritage.
Mais ce n'est pas tout, immaginez que j'ai fait un petit etags pour
promener plus facilement dans le code avec xemacs... etags n'expanse
pas les macros donc ne voit pas tous les champs dans ce cas.
extrait de qobjectdefs.h
> #define Q_OBJECT \
> public: \
> virtual QMetaObject *metaObject() const { \
> return staticMetaObject(); \
> } \
> virtual const char *className() const; \
> virtual void* qt_cast( const char* ); \
> virtual bool qt_invoke( int, QUObject* ); \
> virtual bool qt_emit( int, QUObject* ); \
> QT_PROP_FUNCTIONS \
> static QMetaObject* staticMetaObject(); \
> QObject* qObject() { return (QObject*)this; } \
> QT_TR_FUNCTIONS \
> private: \
> static QMetaObject *metaObj;
extrait de qtextbrowser.h:
> class Q_EXPORT QTextBrowser : public QTextEdit
> {
> Q_OBJECT
> Q_PROPERTY( QString source READ source WRITE setSource )
> Q_OVERRIDE( int undoDepth DESIGNABLE false SCRIPTABLE false )
> Q_OVERRIDE( bool overwriteMode DESIGNABLE false SCRIPTABLE false )
> Q_OVERRIDE( bool modified SCRIPTABLE false)
> Q_OVERRIDE( bool readOnly DESIGNABLE false SCRIPTABLE false )
> Q_OVERRIDE( bool undoRedoEnabled DESIGNABLE false SCRIPTABLE false )
>
> public:
> QTextBrowser( QWidget* parent=0, const char* name=0 );
> ~QTextBrowser();
>
> QString source() const;
>
> public slots:
> virtual void setSource(const QString& name);
> virtual void backward();
> virtual void forward();
> virtual void home();
> virtual void reload();
> void setText( const QString &txt ) { setText( txt, QString::null ); }
> virtual void setText( const QString &txt, const QString &context );
>
> signals:
> void backwardAvailable( bool );
> void forwardAvailable( bool );
> void sourceChanged( const QString& );
> void highlighted( const QString& );
> void linkClicked( const QString& );
> void anchorClicked( const QString&, const QString& );
>
> protected:
> void keyPressEvent( QKeyEvent * e);
>
> private:
> void popupDetail( const QString& contents, const QPoint& pos );
> bool linksEnabled() const { return TRUE; }
> void emitHighlighted( const QString &s );
> void emitLinkClicked( const QString &s );
> QTextBrowserData *d;
>
> private: // Disabled copy constructor and operator=
> #if defined(Q_DISABLE_COPY)
> QTextBrowser( const QTextBrowser & );
> QTextBrowser& operator=( const QTextBrowser & );
> #endif
> };
Présentons une solution alternative pour écrire: une interface
graphique un exemple en tcl/tk :
viviane[~] wish
wish8.3 [~]label .l -text "Bonjour tout les Cultiens"
.l
wish8.3 [~]button .q -text Fermer -command exit
.q
wish8.3 [~]pack .l .q
wish8.3 [~]
Il m'a donc fallu 3 lignes pour écrire un programme qui écrit
bonjour.
Je vous propose aussi de jeter un coup d'oeil à un petit extrait du
code source de tk:
> /*
> * A data structure of the following type is kept for each text widget that
> * currently exists for this process:
> */
>
> typedef struct TkText {
> Tk_Window tkwin; /* Window that embodies the text. NULL
> * means that the window has been destroyed
> * but the data structures haven't yet been
> * cleaned up.*/
> Display *display; /* Display for widget. Needed, among other
> * things, to allow resources to be freed
> * even after tkwin has gone away. */
> Tcl_Interp *interp; /* Interpreter associated with widget. Used
> * to delete widget command. */
> Tcl_Command widgetCmd; /* Token for text's widget command. */
> TkTextBTree tree; /* B-tree representation of text and tags for
> * widget. */
> Tcl_HashTable tagTable; /* Hash table that maps from tag names to
> * pointers to TkTextTag structures. */
> int numTags; /* Number of tags currently defined for
> * widget; needed to keep track of
> * priorities. */
> Tcl_HashTable markTable; /* Hash table that maps from mark names to
> * pointers to mark segments. */
> Tcl_HashTable windowTable;/* Hash table that maps from window names
> * to pointers to window segments. If a
> * window segment doesn't yet have an
> * associated window, there is no entry for
> * it here. */
> Tcl_HashTable imageTable; /* Hash table that maps from image names
> * to pointers to image segments. If an
> * image segment doesn't yet have an
> * associated image, there is no entry for
> * it here. */
> Tk_Uid state; /* Normal or disabled. Text is read-only
> * when disabled. */
>
> /*
> * Default information for displaying (may be overridden by tags
> * applied to ranges of characters).
> */
>
> Tk_3DBorder border; /* Structure used to draw 3-D border and
> * default background. */
> int borderWidth; /* Width of 3-D border to draw around entire
> * widget. */
> int padX, padY; /* Padding between text and window border. */
> int relief; /* 3-d effect for border around entire
> * widget: TK_RELIEF_RAISED etc. */
> int highlightWidth; /* Width in pixels of highlight to draw
> * around widget when it has the focus.
> * <= 0 means don't draw a highlight. */
> XColor *highlightBgColorPtr;
> /* Color for drawing traversal highlight
> * area when highlight is off. */
> XColor *highlightColorPtr;/* Color for drawing traversal highlight. */
> Tk_Cursor cursor; /* Current cursor for window, or None. */
> XColor *fgColor; /* Default foreground color for text. */
> Tk_Font tkfont; /* Default font for displaying text. */
> int charWidth; /* Width of average character in default
> * font. */
> int spacing1; /* Default extra spacing above first display
> * line for each text line. */
> int spacing2; /* Default extra spacing between display lines
> * for the same text line. */
> int spacing3; /* Default extra spacing below last display
> * line for each text line. */
> char *tabOptionString; /* Value of -tabs option string (malloc'ed). */
> TkTextTabArray *tabArrayPtr;
> /* Information about tab stops (malloc'ed).
> * NULL means perform default tabbing
> * behavior. */
>
> /*
> * Additional information used for displaying:
> */
>
> Tk_Uid wrapMode; /* How to handle wrap-around. Must be
> * tkTextCharUid, tkTextNoneUid, or
> * tkTextWordUid. */
> int width, height; /* Desired dimensions for window, measured
> * in characters. */
> int setGrid; /* Non-zero means pass gridding information
> * to window manager. */
> int prevWidth, prevHeight;/* Last known dimensions of window; used to
> * detect changes in size. */
> TkTextIndex topIndex; /* Identifies first character in top display
> * line of window. */
> struct TextDInfo *dInfoPtr;/* Information maintained by tkTextDisp.c. */
>
> /*
> * Information related to selection.
> */
>
> TkTextTag *selTagPtr; /* Pointer to "sel" tag. Used to tell when
> * a new selection has been made. */
> Tk_3DBorder selBorder; /* Border and background for selected
> * characters. This is a copy of information
> * in *cursorTagPtr, so it shouldn't be
> * explicitly freed. */
> char *selBdString; /* Value of -selectborderwidth option, or NULL
> * if not specified (malloc'ed). */
> XColor *selFgColorPtr; /* Foreground color for selected text.
> * This is a copy of information in
> * *cursorTagPtr, so it shouldn't be
> * explicitly freed. */
> int exportSelection; /* Non-zero means tie "sel" tag to X
> * selection. */
> TkTextIndex selIndex; /* Used during multi-pass selection retrievals.
> * This index identifies the next character
> * to be returned from the selection. */
> int abortSelections; /* Set to 1 whenever the text is modified
> * in a way that interferes with selection
> * retrieval: used to abort incremental
> * selection retrievals. */
> int selOffset; /* Offset in selection corresponding to
> * selLine and selCh. -1 means neither
> * this information nor selIndex is of any
> * use. */
>
> /*
> * Information related to insertion cursor:
> */
>
> TkTextSegment *insertMarkPtr;
> /* Points to segment for "insert" mark. */
> Tk_3DBorder insertBorder; /* Used to draw vertical bar for insertion
> * cursor. */
> int insertWidth; /* Total width of insert cursor. */
> int insertBorderWidth; /* Width of 3-D border around insert cursor. */
> int insertOnTime; /* Number of milliseconds cursor should spend
> * in "on" state for each blink. */
> int insertOffTime; /* Number of milliseconds cursor should spend
> * in "off" state for each blink. */
> Tcl_TimerToken insertBlinkHandler;
> /* Timer handler used to blink cursor on and
> * off. */
>
> /*
> * Information used for event bindings associated with tags:
> */
>
> Tk_BindingTable bindingTable;
> /* Table of all bindings currently defined
> * for this widget. NULL means that no
> * bindings exist, so the table hasn't been
> * created. Each "object" used for this
> * table is the address of a tag. */
> TkTextSegment *currentMarkPtr;
> /* Pointer to segment for "current" mark,
> * or NULL if none. */
> XEvent pickEvent; /* The event from which the current character
> * was chosen. Must be saved so that we
> * can repick after modifications to the
> * text. */
> int numCurTags; /* Number of tags associated with character
> * at current mark. */
> TkTextTag **curTagArrayPtr; /* Pointer to array of tags for current
> * mark, or NULL if none. */
>
> /*
> * Miscellaneous additional information:
> */
>
> char *takeFocus; /* Value of -takeFocus option; not used in
> * the C code, but used by keyboard traversal
> * scripts. Malloc'ed, but may be NULL. */
> char *xScrollCmd; /* Prefix of command to issue to update
> * horizontal scrollbar when view changes. */
> char *yScrollCmd; /* Prefix of command to issue to update
> * vertical scrollbar when view changes. */
> int flags; /* Miscellaneous flags; see below for
> * definitions. */
> } TkText;
Maintenant vous pouvez choisir qt ou tcl/tk en connaissance du
source.
>
> > Pour la programmation graphique, mon rêve est de trouver un
> > modèle comme la théorie des languages pour la programmation
> > litérale (est-ce le bon terme ?). Dit autrement j'attend
> > toujours l'équivalent graphique de lex et yacc.
> J'ai du mal à comprendre ce que tu entends par là.
Malheureusement, je ne suis pas un spécialiste en language. Mais si
j'ai bien compris ce que l'on m'a expliqué : il n'est pas possible de
développer l'équivalent d'une syntaxe et d'une grammaire pour décrire
les interfaces graphiques. Il n'y a pas non plus d'outil de
vérification de la cohérence d'une interface graphique.
Je voulais donc dire à JDD que, selon mes connaissances, la
programmation graphique c'est du bricolage.
Pour Labview, vu la longueur de mon message, je ne vous mettrais pas
un exemple de programme C que j'ai été amené à développer. Dès que
l'on veut faire un peu plus que regarder un signal il faut écrire du
C.
Daniel.
--------------------------------------------------------------------
Les listes de diffusion occultes: <URL:http://www.CULTe.org/listes/>