Synthèse de la discussion ayant conduit à l'adoption du projet Farfelue



Mais avant les Liens en rapport avec le projet Farfelue :




Noms des participants de la discussion initiale / nombres de messages :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
koala01   	   100
fcharton 	    57
yan 	            33
metagoto 	    16
Klaim 	            14
epsilon68 	    13
Lavock 	            13
Goten 	            12
Jean-Marc.Bourguet   9
JolyLoic 	     7
Matthieu Brucher     7
Alp                  6
bruno_pages          5
ElPedro              5
spidermario          4
dtrosset             4
Luc Hermitte         3
obliveon             2
poukill              2
rurouni alex         1
ram-0000             1
gl                   1
eyquem               1
Florian Goo          1
Yakuzan              1
dourouc05            1
nikko34              1
ambroise_petitgenet  1
Joe Dralliam         1
Kalith               1

Première tentative d'approche sur la question en milieu de débat :


Qu'est ce que Farfelue ?

Farfelue est une librairie d'interface utilisateur, mais pas un Framwork comme pourrait l'être JVM ou dotNET


Élément de comparaison :
Qt2.3, l'ensemble des fichiers CPP représente 310000 lignes de code.


Intérêt de Farfelue :

  • Moderne.
  • Optimisé.
  • Préserve les ressources systèmes.
  • Proche de l'OS (l'encapsulation des primitives de l'OS cible est prioritaire sur les librairies tierces).
  • Pas de super-objet pour accroitre le potentiel d'évolutivité et de flexibilité de la librairie Farfelue.
  • Utilise des concepts de génie logiciel et les algorithmes associés (code générique (Template...) / Patron de conception | L’agrégation et les Templates sont préférées à l'héritage).
  • Procédure de compilation et de portage simplifiée (conf make tools family)
  • Non intrusive, pas d'invention sémantiques/syntaxiques ou pseudo-langage (Conf BEGIN_MESSAGE_MAP)
  • Simple d'emploi pour l'utilisateur final depuis une interface de contrôle adaptée ().
  • Open source (LGPL v3).
  • Extensible.
  • Multi-paradigmes.
  • Documentation en anglais, en français.
  • Portable (x11 et Windows 32 / 64 bits).



Fonctionnalités primaires ou de premier ordre :

  • Support et gestions des Timers.
  • Support et gestions des différents formats d'images.
  • Interface "skinable" (?).
  • Intégration de fonctionnalité d'animation.
  • Support des modes matriciel/ vectoriel.
  • Support de l'Unicode avec système d'internationalisation (gestion/(intégration?) de différentes fontes | Traduction des textes d'interface (Conf. barre de menu...)) et prise en charge du "Bidimode" (sens de l'écriture).
  • Librairie étagée (un système de donnée pouvant être utilisé par différents systèmes de traitement (moteurs de rendu...) et pouvant être interfacé avec différents systèmes de saisis (souris, clavier ...)).
  • Possibilité de composition/d'agrégation d'éléments d'interfaces ("binding") et possibilité d'établir une liaison dynamique entre leurs données ("Data binding").
  • Interface déclarative basée sur XML*? CSS*? ...? ("DeclarativeUI" : conf. exemple Qt sur http://qt.developpez.com/doc/latest/qtquick.html).
  • Threadsafe:
    Thread-safe est un terme utilisé en informatique et qui n’a pas d’équivalent en français. Le terme s’en rapprochant le plus serait la 'réentrance' bien qu’il s’agisse d’un concept légèrement différent. On dit qu’un programme ou qu'une portion de code est thread-safe s’il fonctionne correctement durant une exécution simultanée par plusieurs threads (processus légers). Si cette propriété d’un programme n’est pas importante dans le cadre d’une exécution mono-tâche, elle en devient essentielle dans le cadre de la programmation concurrente et pour les systèmes d'exploitation récents qui utilisent pour la plupart le concept de threads.
  • Nouvelle norme C++: C++0x/C++11.
  • Standardisé:
  • Basé sur la standard library (dinkumward, stllib++) (ex TR1) (variadic template ...) / boost (partiellement (boost thread ...))
  • Interopérable:
    Farfelue doit être interopérable avec la SL et BOOST et pas seulement compatible, ainsi les types fondamentaux (std::string, std::list, std::vector ...) ne doivent pas être redefinies (conf. Qt avec QList, QVector...).
  • Code interne kernel.
  • Rendu visuel des applications en 2D, avec un "look'n feel" à l'image du système d'exploitation. Interface personnalisable et customisable.



Fonctionnalités non prioritaires :
  • Support de la 3D.
  • Potentiel d'intégrabilité dans des Framworks tiers (exemple: Qt).
  • Composition pouvant être assistée par une interface RAD s'articulant autour de la bibliothèque.



API utilisées :
  • GDI (|GDIPLUS?).
  • Xorg.
  • GD+.


Librairies d'extensions candidates :


Moteurs de rendu cité autre que les candidats :


Librairies citées lors du débat :


Librairies citées comme présentant des similitudes avec Farfelue :


Librairies citées prenant en charge l'aspect DeclarativeUI :



Concepts et autres Liens utiles :



Vidéos citées :
Qt / New user interface paradigms en anglais :
commencez la lecture à partir de la position 11min28s 301 Moved Permanently)
autres vidéos : http://www.developpez.net/forums/d81...eclarative-ui/


Autres notions abordées pendant le débat :
  • Streams Vs Serialization [(exportation, sauvegarde de donnés)]
  • Introspection.
  • Callback/boost.signal2



Types d'Hebergements et hébergeurs de projets potentiels :



Outils en rapport avec l'hébergement, la gestion des sources ou du projet (disponible ou envisageable) :



Outils d'aide à la conception :
  • BOUML



Style de code, outils et applications aidant à la mise en forme des codes sources :



Développement :
L'objectif est de rallier 20 développeurs ainsi qu'un designer ou une personne douée en graphisme à raison d'une heure d'activité journalière sur le projet, dans la mesure du possible.
Pour faire votre demande, par ici -> (http://www.developpez.net/forums/d91...-ecriture-svn/)


Merci.