OpenLLM-France/wikimedia huggingface dataset:
# Programmation Java Swing

Swing est une bibliothèque graphique pour le langage de programmation Java, faisant partie du package Java Foundation Classes (JFC), inclus dans J2SE. Swing constitue l'une des principales évolutions apportées par Java 2 par rapport aux versions antérieures.
Swing offre la possibilité de créer des interfaces graphiques identiques quel que soit le système d'exploitation sous-jacent, au prix de performances moindres qu'en utilisant Abstract Window Toolkit (AWT). Il utilise le principe modèle-vue-contrôleur (MVC, les composants Swing jouent en fait le rôle de la vue au sens du MVC) et dispose de plusieurs choix d'apparence pour chacun des composants standards.
Avec l'apparition de Java 8 en mars 2014, JavaFX devient la bibliothèque graphique officielle du langage Java, pour toutes les sortes d'application (applications mobiles, applications sur poste de travail, applications Web), le développement de son prédécesseur Swing étant abandonné (sauf pour les corrections de bogues).
Les IDE pour le langage de programmation Java peuvent proposer des outils pour construire une interface graphique Swing de manière interactive, permettant l'ajout de composant par glisser-déposé avec la souris sur la surface d'une fenêtre, de modifier les propriétés de chaque composant, de lier des évènements à du code Java :
Ce livre n'utilise pas de tels outils pour la construction de l'interface graphique, car cela montre comment fonctionnent les composants derrière ce que cachent les outils.
Ce livre suppose que le lecteur connaît suffisamment le langage Java pour programmer en Java et comprendre les codes sources de ce livre.
Pour la programmation en Java, voir l'excellent livre Programmation Java.
Pour lire ce livre, commencez par la base commune introduisant les concepts de base communs aux différentes parties du livre. Ensuite chaque partie peut être lue indépendamment des autres.

## Sommaire

* Une version imprimable du livre « Programmation Java Swing » est disponible. (voir/ modifier)
* La lecture préalable de Programmation Java est conseillée.
* Introduction
* Composants
** Arbre
* Fenêtres
* Menus
* Actions
* Types de données et constantes
* Gestion de la disposition des composants
* Gestion des évènements
* Gestion des actions asynchrones
* Apparence de l'interface
* Contenu en HTML
* Créer un composant
** Une case à cocher à trois états
** Dessin d'un composant
** Dessin d'une étoile
** Dessin de texte et effets
* Créer une image

## Voir aussi

Consultez également ces pages dans d’autres projets Wikimedia :
* Ressources multimédia sur Commons.
* Article encyclopédique sur Wikipédia.
* Programmation Java
* Développer en Java
* Programmation JavaFX
* 6/68/681/681.3/681.3.0
# Programmation JavaScript/Stockage

* Introduction
    Programmer en deux minutes
*   * Page wiki
*   * Compteur en temps réel
*   * Site dans un document
* Outils de développement
* Syntaxe
** Ligne d'instruction
** Ordre d'évaluation
** Bloc d'instructions
** Identificateurs
** Expression littérale
** Commentaire
** Mots réservés
** Variables
** Opérateurs
** Structures de contrôle
** Exceptions et erreurs
** Fonctions utilisateur
** Évènement
* Objets prédéfinis
** window
** document
** navigator
** Array
** Boolean
** Date
** Error
** Function
** Math
** Number
** Object
** String
** Element
** RegExp
* Fonctions prédéfinies
* Programmation avancée
** Opérateurs de bits
** Fermeture
** Programmation objet
** Notation JSON
** AJAX
** Stockage
** Générateurs
** Interface DOM
** Objets Microsoft
* Frameworks
** Dojo
    Hello World
    Widgets
    Ressources
** jQuery
** Node.js
** React.js
* Tests
** Ava
** Jest
** Cypress
* Débogage
* Erreurs connues
* Références
* Introduction
    Programmer en deux minutes
*   * Page wiki
*   * Compteur en temps réel
*   * Site dans un document
* Outils de développement
* Syntaxe
** Ligne d'instruction
** Ordre d'évaluation
** Bloc d'instructions
** Identificateurs
** Expression littérale
** Commentaire
** Mots réservés
** Variables
** Opérateurs
** Structures de contrôle
** Exceptions et erreurs
** Fonctions utilisateur
** Évènement
* Objets prédéfinis
** window
** document
** navigator
** Array
** Boolean
** Date
** Error
** Function
** Math
** Number
** Object
** String
** Element
** RegExp
* Fonctions prédéfinies
* Programmation avancée
** Opérateurs de bits
** Fermeture
** Programmation objet
** Notation JSON
** AJAX
** Stockage
** Générateurs
** Interface DOM
** Objets Microsoft
* Frameworks
** Dojo
    Hello World
    Widgets
    Ressources
** jQuery
** Node.js
** React.js
* Tests
** Ava
** Jest
** Cypress
* Débogage
* Erreurs connues
* Références
[ Modifier le sommaire ]
Pour persister des données dans l'ordinateur de l'utilisateur, on distingue trois méthodes :
* Les cookies (<= 4 Mo).
* Le stockage web local, alias LocalStorage (<= 10 Mo).
* L'Indexed Database API, alias IndexedDB (<= 50 Mo).

## Références

* ↑ https://www.html5rocks.com/en/tutorials/offline/quota-research/
# Programmation C-C++/C++ : La couche objet/Extension de la notion de type du C

Cours de C/C++ :
| C++ : La couche objet ||
| | Généralités |
| | Extension de la notion de type du C |
| | Déclaration de classes en C++ |
| | Encapsulation des données |
| | Héritage |
| | Classes virtuelles |
| | Fonctions et classes amies |
| | Constructeurs et destructeurs |
| | Pointeur this |
| | Données et fonctions membres statiques |
| | Surcharge des opérateurs |
| | Des entrées - sorties simplifiées |
| | Méthodes virtuelles |
| | Dérivation |
| | Méthodes virtuelles pures - Classes abstraites |
| | Pointeurs sur les membres d'une classe |
| Livre original de C. Casteyde ||
Il faut avant tout savoir que la couche objet n'est pas un simple ajout au langage C, c'est une véritable extension. En effet, les notions qu'elle a apportées ont été intégrées au C à tel point que le typage des données de C a fusionné avec la notion de classe. Ainsi, les types prédéfinis char, int, double, etc. représentent à présent l'ensemble des propriétés des variables ayant ce type. Ces propriétés constituent la classe de ces variables, et elles sont accessibles par les opérateurs. Par exemple, l'addition est une opération pouvant porter sur des entiers (entre autres) qui renvoie un objet de la classe entier. Par conséquent, les types de base se manipuleront exactement comme des objets. Du point de vue du C++, les utiliser revient déjà à faire de la programmation orientée objet.
De même, le programmeur peut, à l'aide de la notion de classe d'objets, définir de nouveaux types. Ces types comprennent la structure des données représentées par ces types et les opérations qui peuvent leur être appliquées. En fait, le C++ assimile complètement les classes avec les types, et la définition d'un nouveau type se fait donc en définissant la classe des variables de ce type.
# Programmation C-C++/C++ : La couche objet/Fonctions et classes amies

Cours de C/C++ :
| C++ : La couche objet ||
| | Généralités |
| | Extension de la notion de type du C |
| | Déclaration de classes en C++ |
| | Encapsulation des données |
| | Héritage |
| | Classes virtuelles |
| | Fonctions et classes amies |
| | Constructeurs et destructeurs |
| | Pointeur this |
| | Données et fonctions membres statiques |
| | Surcharge des opérateurs |
| | Des entrées - sorties simplifiées |
| | Méthodes virtuelles |
| | Dérivation |
| | Méthodes virtuelles pures - Classes abstraites |
| | Pointeurs sur les membres d'une classe |
| Livre original de C. Casteyde ||
Il est parfois nécessaire d'avoir des fonctions qui ont un accès illimité aux champs d'une classe. En général, l'emploi de telles fonctions traduit un manque d'analyse dans la hiérarchie des classes, mais pas toujours. Elles restent donc nécessaires malgré tout.
De telles fonctions sont appelées des fonctions amies. Pour qu'une fonction soit amie d'une classe, il faut qu'elle soit déclarée dans la classe avec le mot clé friend.
Il est également possible de faire une classe amie d'une autre classe, mais dans ce cas, cette classe devrait peut-être être une classe fille. L'utilisation des classes amies peut traduire un défaut de conception.

## Fonctions amies

Les fonctions amies se déclarent en faisant précéder la déclaration classique de la fonction du mot clé friend à l'intérieur de la déclaration de la classe cible. Les fonctions amies ne sont pas des méthodes de la classe cependant (cela n'aurait pas de sens puisque les méthodes ont déjà accès aux membres de la classe).

### Exemple 8-8. Fonctions amies

Il est possible de déclarer amie une fonction d'une autre classe, en précisant son nom complet à l'aide de l'opérateur de résolution de portée.

## Classes amies

Pour rendre toutes les méthodes d'une classe amies d'une autre classe, il suffit de déclarer la classe complète comme étant amie. Pour cela, il faut encore une fois utiliser le mot clé friend avant la déclaration de la classe, à l'intérieur de la classe cible. Cette fois encore, la classe amie déclarée ne sera pas une sous-classe de la classe cible, mais bien une classe de portée globale.

### Exemple 8-9. Classe amie

On remarquera plusieurs choses importantes. Premièrement, l'amitié n'est pas transitive. Cela signifie que les amis des amis ne sont pas des amis. Une classe A amie d'une classe B, elle-même amie d'une classe C, n'est pas amie de la classe C par défaut. Il faut la déclarer amie explicitement si on désire qu'elle le soit. Deuxièmement, les amis ne sont pas hérités. Ainsi, si une classe A est amie d'une classe B et que la classe C est une classe fille de la classe B, alors A n'est pas amie de la classe C par défaut. Encore une fois, il faut la déclarer amie explicitement. Ces remarques s'appliquent également aux fonctions amies (une fonction amie d'une classe A amie d'une classe B n'est pas amie de la classe B, ni des classes dérivées de A).
# Programmation C-C++/C++ : La couche objet/Pointeur this

Cours de C/C++ :
| C++ : La couche objet ||
| | Généralités |
| | Extension de la notion de type du C |
| | Déclaration de classes en C++ |
| | Encapsulation des données |
| | Héritage |
| | Classes virtuelles |
| | Fonctions et classes amies |
| | Constructeurs et destructeurs |
| | Pointeur this |
| | Données et fonctions membres statiques |
| | Surcharge des opérateurs |
| | Des entrées - sorties simplifiées |
| | Méthodes virtuelles |
| | Dérivation |
| | Méthodes virtuelles pures - Classes abstraites |
| | Pointeurs sur les membres d'une classe |
| Livre original de C. Casteyde ||
Nous allons à présent voir comment les fonctions membres, qui appartiennent à la classe, peuvent accéder aux données d'un objet, qui est une instance de cette classe. Cela est indispensable pour bien comprendre les paragraphes suivants.
À chaque appel d'une fonction membre, le compilateur passe implicitement un pointeur sur les données de l'objet en paramètre. Ce paramètre est le premier paramètre de la fonction. Ce mécanisme est complètement invisible au programmeur, et nous ne nous attarderons pas dessus.
En revanche, il faut savoir que le pointeur sur l'objet est accessible à l'intérieur de la fonction membre. Il porte le nom « this ». Par conséquent, *this représente l'objet lui-même. Nous verrons une utilisation de this dans le paragraphe suivant (surcharge des opérateurs).
localiser
this est un pointeur constant, c'est-à-dire qu'on ne peut pas le modifier (il est donc impossible de faire des opérations arithmétiques dessus). Cela est tout à fait normal, puisque le faire reviendrait à sortir de l'objet en cours (celui pour lequel la méthode en cours d'exécution travaille).
Il est possible de transformer ce pointeur constant en un pointeur constant sur des données constantes pour chaque fonction membre. Le pointeur ne peut toujours pas être modifié, et les données de l'objet ne peuvent pas être modifiées non plus. L'objet est donc
Dans la fonction membre lit, il est impossible de modifier l'objet. On ne peut donc accéder qu'en lecture seule à i. Nous verrons une application de cette possibilité dans la Section 8.15.
localiser
Il est à noter qu'une méthode qui n'est pas déclarée comme étant const modifie a priori les données de l'objet sur lequel elle travaille. Donc, si elle est appelée sur un objet déclaré const, une erreur de compilation se produit. Ce comportement est normal. On devra donc toujours déclarer const une méthode qui ne modifie pas réellement l'objet, afin de laisser à l'utilisateur le choix de déclarer const ou non les objets de sa classe.
# Programmation GTK2 en Pascal/Les listes déroulantes

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie
Les listes déroulantes ou combobox en anglais ont été complètement revues dans la version 2 de Gtk+, l'objet GtkCombo ne doit plus être utilisé. Elles sont liées maintenant aux objets des listes et des arbres. Elle peuvent néanmoins être utilisées de manière simple en mode texte :
* GtkComboBox
* GtkComboBoxEntry
# Programmation GTK2 en Pascal/Les sélections

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie
Les sélections sont des fenêtres de dialogue souvent utilisées dans des applications pour sélectionner différentes choses : un fichier, une couleur, etc. Gtk+ en met à disposition un certain nombre, parmi ceux-ci nous verrons :
* La sélection d'un fichier : GtkFileSelection
* La sélection d'une couleur : GtkColorSelectionDialog
Il existe également la sélection d'une police de caractères.
# Programmation GTK2 en Pascal/Les visuels

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie
Gtk+ possède toute une série de contrôles visuels, c'est à dire qui ne permettent que l'affichage de données :
* GtkLabel
* GtkImage
* GtkStatusBar
* GtkProgressBar
* GtkDrawingArea
# Programmation GTK2 en Pascal/Le placement des contrôles

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie
Le placement des contrôles visuels avec Gtk+ peut paraître de prime abord complexe. Mais quand on a bien compris la logique du système, cela ne pose pas de problèmes particuliers.

## La particularité de Gtk+

De nombreuses API de gestion d'interface graphique fonctionne en positionnant le contrôle visuel de manière très précise en indiquant les coordonnées en pixels. Gtk+ ne fonctionne pas ainsi. À la création d'un contrôle, on lui fournit un ensemble de paramètres généraux et c'est Gtk+ qui va précisément s'occuper du positionnement, de la largeur, etc.
Les avantages sont une application qui s'adapte très bien à la taille de la fenêtre et donc à son redimensionnement, à la taille de l'écran, aux thèmes Gtk+, etc.

## Les conteneurs

Afin de placer un contrôle visuel de base comme un bouton, ou un champ de saisie dans une fenêtre, on va utiliser des conteneurs. Des conteneurs spéciaux existent qui regroupent les contrôles de manière verticale ou bien horizontale, il s'agit des GtkVBox et des GtkHBox.
* Voici un exemple de conteneur GtkVBox dans lequel on a placé des boutons. Ceux-ci s'empilent verticalement dans le conteneur.
* Ci-dessous, voici un exemple de conteneur GtkHBox.

## L'empilement des conteneurs

On peut placer un ou plusieurs conteneurs dans un autre conteneur. C'est d'ailleurs ce qu'on fait quand on place un GtkVBox par exemple dans une fenêtre. La fenêtre est un conteneur.
Cette combinaison va nous permettre de définir des interfaces très complexes.
Voici ci-dessus un exemple relativement simple. On peut bien entendu imbriquer plusieurs GtkBox l'une dans l'autre.
# Programmation GTK2 en Pascal/Les conteneurs

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie
GTK+ permet de gérer plusieurs types de conteneurs.
# Programmation GTK2 en Pascal/Les fenêtres

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie
GTK+ permet de gérer plusieurs types de fenêtres :
* GtkWindow : La fenêtre classique
* GtkDialog : La boîte de dialogue, c'est une fenêtre avec par exemple 2 boutons qui vont être le plus souvent OK et Annuler.
* GtkMessageDialog : La boîte de message, qui est une petite fenêtre permettant d'afficher un message d'erreur par exemple.
# Programmation GTK2 en Pascal/Les menus

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie
Les menus sont des contrôles complexes et sont donc découpés en plusieurs classes de contrôles.
La barre de menu tout d'abord :
Le menu en lui-même :
La classe de base des menus :
Les éléments d'un menu :
* GtkMenuItem
* GtkImageMenuItem
* GtkRadioMenuItem
* GtkCheckMenuItem
* GtkSeparatorMenuItem
* GtkTearoffMenuItem

### Étapes pour créer un menu

* Création d'une barre de menu
* Création d'un item de menu (exemple : Fichier)
* Attachement de cet item dans la barre de menu
* Création d'un menu
* Attachement de ce menu à l'item de la barre de menu (créé en 2.)
* Création d'un item de menu (exemple : Nouveau, Ouvrir, Sauvegarder, etc.)
* Attachement de cet item au menu (créé en 4.)
* Création des autres items (on boucle sur 6. et 7.)
* Si on veut une autre entrée de menu dans la barre de menu (exemple Édition, Aide, etc.), on recommence à 2.
# Programmation GTK2 en Pascal/La saisie de données

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie
La saisie de données est l'autre élément important d'une interface graphique permettant d'établir la communication avec l'utilisateur. Gtk+ permet la gestion de plusieurs contrôles de ce type :
* GtkEntry
* GtkHScale
* GtkVScale
* GtkSpinButton
# Programmation GTK2 en Pascal/Les décorations

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie
Les contrôles décoratifs ne sont pas indispensables mais permettent de réaliser des interfaces graphiques plus agréables, plus ergonomiques. On va y trouver les cadres qui permettent de regrouper visuellement des contrôles et des lignes qui permettent au contraire de séparer les contrôles :
* GtkFrame
* GtkHSeparator
* GtkVSeparator
# Programmation GTK2 en Pascal/Les boutons

* Programmation GTK2 en Pascal
* Introduction
* Pré-requis
* Logiciels nécessaires
* Installation sous Linux
* Installation sous Windows
* Installation sous Mac/OS
* Une application minimale
* Les bases
* La notion d'objet
* La gestion des évènements
* Le placement des contrôles
* Les contrôles (widgets) Gtk
* Les fenêtres
* Les conteneurs
* Les visuels
* Les boutons
* La saisie de données
* Les listes déroulantes
* Les menus
* Les décorations
* La barre d'outils
* Les sélections
* Les zones de texte
* Les listes et arbres
* La Glib : objets et fonctions
* Dessiner avec le Gdk
* Conclusion
* Bibliographie
Les boutons sont un élément important d'une interface graphique vu qu'ils sont facilement manipulables à la souris. Gtk+ permet la gestion de plusieurs contrôles de ce type :
* GtkButton
* GtkToggleButton
* GtkCheckButton
* GtkRadioButton