1 files changed, 181 insertions, 0 deletions
diff --git a/doc/objects.txt b/doc/objects.txt
new file mode 100644
index 0000000..956ad74
--- /dev/null
+++ b/doc/objects.txt
@@ -0,0 +1,181 @@
+Let me say this in french. Sorry for english-only-speaking people, i'll translate someday.
+
+L'idée principale motivant le développement de T/CE est celle d'un nouveau protocole entre le
+noyau et les applications utilisateur.
+
+Les objets du systèmes sont accessibles sous la forme d'un système de fichiers dans lequel on
+navigue, sauf que les objets sont en fait bien plus que de simples fichiers.
+
+Ce protocole se base sur trois définitions fondamentales :
+-- Interfaces :
+Une interface est un ensemble de définitions (de prototypes, donc) de méthodes qui
+peuvent être implémentées par un objet du système.
+Parmi les méthodes, il y a des méthodes publiques, faites pour être appellées par les
+applications utilisateurs, et des méthodes internes au noyau.
+-- Classe :
+Une classe, c'est un regroupement d'interfaces avec leur implémentation spécifique.
+-- Objet :
+Un objet du système est d'une classe précise, et correspond donc à un des objets gérés
+par le code de cette classe. On peut appeller toutes les méthodes des interfaces implémentées
+par la classe de l'objet sur cet objet.
+
+Ce n'est peut-être pas très clair, alors illustrons :
+
+Interface : Keyboard
+- OutputToConsole(Console)
+Interface : Console
+- SetActiveVT (VirtualTerminal)
+- NewBufferedVT (char*)						// crée un nouveau terminal virtuel - char* = le nom
+- (internal) receiveKeyboardInput(int)
+- (internal) repaint(char*)
+- (internal) write(int, char*)
+Interface : VirtualTerminal
+- Read(int, char*)
+- Write(int, char*)
+- (internal) receiveKeyboardInput(int)
+- (internal) outputToConsole(Console, int, int)	// int, int = dimensions de la console
+
+Classe : PS2Keyboard
+- Garde en mémoire la console à qui il envoie les données
+- Quand une touche est pressée/relâchée, appeller receiveKeyboardInput sur cette console
+- Implémenter la méthode OutputToConsole pour changer la console à qui les données sont envoyées
+Classe : TextConsole
+- Implémente la gestion de l'écran texte VGA de base
+- Garde en mémoire le VirtualTerminal actif
+- Transmet l'entrée clavier au VirtualTerminal actif
+- Lorsqu'on lui demande de changer le VT actif :
+    il signale à l'ancien VT de ne plus émettre,
+	il signale au nouveau VT d'émettre vers cette console
+		et spécifie au nouveau VT la bonne dimension d'écran
+Classe : BufferedVirtualTerminal
+- Il garde en mémoire LA Console vers laquelle il doit émettre, ainsi que ses dimensions
+- Garde un buffer de tout ce qui passe sur la console, et un buffer de l'écran actif.
+- Lorsqu'il reçoit une entrée clavier, la bufferise, puis la restitue lors du prochain appel à Read
+- Lorsqu'on écrit quelque chose dessus avec Write, il le garde dans son buffer
+		et le donne aussi au terminal virtuel de sortie, s'il y en a un
+
+
+Implémentation :
+
+// Structures
+
+struct Interface {
+	char* name;
+	int method_count;
+	int public_method_count;
+
+	NumberedMethod numberedMethods[];
+	int methodNumbers[];
+};
+
+struct NumberedMethod {
+	Interface *iface;
+	int numberInIface;
+};
+
+type MethodPtr (function pointer type);
+
+struct InterfaceImpl {
+	Interface *interface;
+	MethodPtr methods[];
+};
+
+struct Class {
+	char* name;
+	MethodPtr *findChild;
+	InterfaceImpl interfaces[];		//zero-terminated list
+};
+
+struct Object {
+	Class *class;
+	void *data;
+};
+
+// setup code
+
+void Class_setup(Class* class) {
+	for (int i = 0; class->interfaces[i] != 0; i++) {
+		Interface_setup(class->interfaces[i]->interface)
+	}
+}
+
+ExpandableTable<NumberedMethod*> allMethods;
+
+void Interface_setup(Interface* iface) {
+	if (iface->numberedMethods != 0) return;
+	iface->numberedMethods = malloc(iface->method_count * sizeof(NumberedMethod));
+	iface->methodNumbers = malloc(iface->method_count * sizeof(int));
+	
+	for (int i = 0; i < iface->method_count; i++) {
+		iface->methodNumbers[i] = allMethods.register(&impl->numberedMethods[i])
+		iface->numberedMethods[i]->numberInIface = i;
+		iface->numberedMethods[i]->ptr = impl->methods[i];
+	}
+}
+
+void Object_callByNumber(Object *obj, int number, params...) {
+	NumberedMethod *method = allMethods.get(number);
+	for (int i = 0; obj->class->interfaces[i] != 0; i++) {
+		InterfaceImpl impl = obj->class->interfaces[i];
+		if (method->iface == impl->interface) {
+			MethodPtr fct = impl->methods[method->numberInIface];
+			return fct (params...)
+		}
+	}
+	return E_NOT_IMPLEMENTED;
+}
+
+// Exemple
+
+struct ConsoleMethods {
+	MethodPtr SetActiveVT;
+	MethodPtr NewBufferedVT;
+	MethodPtr receiveKeyboardInput;
+	MethodPtr repaint;
+	MethodPtr write;
+};
+
+Interface ConsoleIface = {
+	name: "Console",
+	method_count: 5,
+	public_method_count: 2,
+
+	numberedMethods: 0, methodNumbers: 0,	// internal
+};
+
+ConsoleMethods TextConsole_as_Console = {
+	SetActiveVT: TextConsole_SetActiveVT,
+	NewBufferedVT: TextConsole_NewBufferedVT,
+	receiveKeyboardInput: TextConsole_receiveKeyboardInput,
+	repaint: TextConsole_repaint,
+	write: TextConsole_write,
+};
+
+Class TextConsoleClass = {
+	name: "TextConsole",
+	findChild: Console_findChild,
+	interfaces: {
+		{ ConsoleIface, (MethodPtr*)TextConsole_as_Console },
+		0
+	},
+};
+
+struct TextConsole {
+	Object object;
+
+	//... data ...
+};
+
+// Other example
+
+struct FolderMethods {
+	MethodPtr GetChildList;
+};
+
+Interface FolderIface = {
+	name: "Folder",
+	method_count: 1,
+	public_method_count: 1,
+
+	numberedMethods: 0, methodNumbers: 0,	// internal
+};