\documentclass[a4paper, 11p]{article}
\usepackage{graphicx}
\usepackage{color}
\usepackage{epsfig}

\setlength{\hoffset}{-18pt}  	
\setlength{\oddsidemargin}{0pt} 	% Marge gauche sur pages impaires
\setlength{\evensidemargin}{9pt} 	% Marge gauche sur pages paires
\setlength{\marginparwidth}{54pt} 	% Largeur de note dans la marge
\setlength{\textwidth}{481pt} 		% Largeur de la zone de texte (17cm)
\setlength{\voffset}{-18pt} 		% Bon pour DOS
\setlength{\marginparsep}{7pt} 		% S\'eparation de la marge
\setlength{\topmargin}{0pt} 		% Pas de marge en haut
\setlength{\headheight}{0pt} 		% -13pt 	% Haut de page
\setlength{\headsep}{10pt} 			% Entre le haut de page et le texte
\setlength{\footskip}{27pt} 		% Bas de page + s\'eparation
\setlength{\textheight}{721pt} 		% +13 pt % Hauteur de la zone de texte (25cm)

\begin{document}

{\bf ATTENTION :}\\
- grille ex. : remplacer un 1 par un 3\\
- indices tab unidim : N*N (et non N*)\\
- autre (?) : check


\begin{tabular}{|clrc|}\hline
&\multicolumn{2}{c}{{\bf EXAMEN D'INITIATION AUX INTERFACES GRAPHIQUES}}												&\\
&{\bf Institut Galil\'ee - Universit\'e Paris~13}\hspace*{1.8cm} 	&{\bf Mardi 30 avril 2012 -- 14h-16h}					&\\
&{\bf Licence~1}													&{\bf Aucun document autoris\'e}	&\\
\hline
\end{tabular}

~\\

Le jeu de Sudoku se joue \`a un seul joueur sur une grille 9$\times$9, elle-m\^eme subdivis\'ee en 9 carr\'es~3$\times$3. Le but, partant d'une grille contenant quelques chiffres, est de placer un chiffre de 1 \`a 9 dans chaque case de sorte que~:
$$\left\{\begin{array}{l}
\textrm{chacun des 9 carr\'es}\\
\textrm{chacune des 9 lignes}\\
\textrm{chacune des 9 colonnes}
\end{array}\right\}\ \textrm{contienne {\em exactement une} occurrence de chaque chiffre de 1 \`a 9. Exemple de grille~:}$$

$$\begin{array}{lll}
\begin{array}{|ccc|ccc|ccc|}
\hline
	&6	&	&	&4	&	&	&	&9\\
	&3	&	&	&1	&	&8	&	&2\\
	&4	&9	&8	&3	&5	&	&	&\\\hline
	&1	&2	&	&	&3	&	&	&\\
3	&	&	&7	&	&1	&	&	&4\\
	&	&	&5	&	&	&1	&7	&\\\hline
	&	&	&3	&	&4	&6	&8	&\\
6	&	&3	&	&7	&	&	&2	&\\
1	&	&	&	&5	&	&	&9	&\\\hline
\multicolumn{9}{c}{\textrm{Initialisation}}
\end{array}	&\hspace*{1.5cm}
&\begin{array}{|ccc|ccc|ccc|}
\hline
8	&6	&1	&2	&4	&7	&5	&3	&9\\
5	&3	&7	&9	&1	&6	&8	&4	&2\\
2	&4	&9	&8	&3	&5	&7	&1	&6\\\hline
7	&1	&2	&4	&6	&3	&9	&5	&8\\
3	&5	&8	&7	&9	&1	&2	&6	&4\\
4	&9	&6	&5	&8	&2	&1	&7	&3\\\hline
9	&7	&5	&3	&2	&4	&6	&8	&1\\
6	&8	&3	&1	&7	&9	&4	&2	&5\\
1	&2	&4	&6	&5	&8	&3	&9	&7\\\hline
\multicolumn{9}{c}{\textrm{Grille remplie}}
\end{array}
\end{array}$$

\section{Prise en mains de la biblioth\`eque ``sudoku''}
Vous disposez d'une biblioth\`eque ({\em cf.}, fichier d'ent\^ete joint) repr\'esentant une grille de Sudoku. Cette biblioth\`eque est largement comment\'ee, nous donnons seulement deux pr\'ecisions compl\'ementaires~:
\begin{itemize} 
	\item {\em Gestion du champ `nb\_coup\_joue' et retour arri\`ere.} Le joueur peut placer le chiffre $5$ dans la case d'indice $(1,3)$ au cours du $10$\`e coup, puis le chiffre $9$ dans la case $(5,2)$ au $11$\`e coup, puis changer d'avis sur son coup pr\'ec\'edent et placer au $12$\`e coup le chiffre $8$ dans la case d'indice $(1,3)$. \`A l'issue de ce dernier coup, le champ `coup\_joue' de la case $(1,3)$ prend la valeur $12$, tandis que dans la grille, le champ `compteur\_coup' est inchang\'e et le champ `nb\_coup\_joue' est incr\'ement\'e de $1$. Supposons que `nb\_coup\_joue' vaille alors $12$. Si le joueur d\'ecide maintenant de faire un retour arri\`ere, la case d'indice $(1,3)$ est r\'einialis\'ee et dans la grille, les champs `compteur\_coup' et `nb\_coup\_joue' sont d\'ecr\'ement\'es de $1$. Si le joueur op\`ere de nouveau un retour arri\`ere, la case d'indice $(5,2)$ est r\'einialis\'ee et les champs `compteur\_coup' et `nb\_coup\_joue' sont de nouveau d\'ecr\'ement\'es de $1$. Le champ `nb\_coup\_joue' vaut alors $10$.  Si le joueur op\`ere encore un retour arri\`ere, il n'y a plus dans la grille de case jou\'ee au $10$\`e coup (puisqu'il s'agissait de la case $(1,3)$, modifi\'ee depuis)~: la fonction de retour arri\`ere d\'ecr\'emente alors `nb\_coup\_joue', jusqu'\`a trouver une case jou\'ee au coup ``nb\_coup\_joue', ou jusqu'\`a ce que `nb\_coup\_joue' vale $0$.
	\item {\em Indice des cases.} Les cases vis-\`a-vis du joueur ont deux indices $x$ et $y$, l'un indiquant la ligne (de $1$ \`a $9$), l'autre la colonne (\'egalement de $1$ \`a $9$). Dans la structure de donn\'ees, les cases sont stock\'ees dans un tableau unidimensionnel, elles n'ont donc qu'un indice. La case d'indice $(x,y)$ dans le jeu est repr\'esent\'ee dans la structure par la case d'indice $(N*N*(x-1))+(y-1)$ dans le tableau `tab\_case'.
\end{itemize} 

\subsection{Prise en mains des structures de donn\'ees \& de la biblioth\`eque ``sudoku''}
\begin{enumerate} 
\item Suite \`a une mauvaise manipulation, il faut r\'e\'ecrire certaines fonctions de la biblioth\`eque ``sudoku''. Il s'agit des fonctions \texttt{case\_get\_val\_joue}, \texttt{case\_set}, \texttt{grille\_initialiser} et \texttt{grille\_est\_resolue}.

\item Il manque certaines fonctionnalit\'es \`a la biblioth\`eque ``sudoku''. Donner le prototype et \'ecrire le code de deux nouvelles fonctions~:
	\begin{enumerate} 
	\item La fonction \texttt{grille\_afficher} qui repr\'esente l'\'etat de la grille, comme dans les figures du haut.

	\item La fonction \texttt{grille\_derouler} qui permet de retracer le d\'eroulement du jeu en affichant, pour chaque coup jou\'e de 1 au nombre de coups jou\'es de la partie~: si une case a \'et\'e jou\'ee lors de ce coup (et n'a pas \'et\'e rejou\'ee depuis), l'indice de ligne de cette case, l'indice de colonne de cette case, et la valeur attribu\'ee. Ex. d'affichage~:\\
		\texttt{\begin{tabular}{llll}
			coup 1:	&1	&1	&2\\
			coup 2:	&-	&-	&-\\%coup 2:	&1	&3	&5\\ ANNULER CAR 8 A PLACER
			coup 3:	&1	&3	&8\\
			coup 4:	&2	&1	&7\\
			coup 5:	&2	&3	&5
		\end{tabular}}
	\end{enumerate} 

\item Donner, en justifiant pas \`a pas leur \'evolution, la valeur des champs 'compteur\_joue' et 'nb\_coup\_joue' de la grille \`a la suite de la succession suivante d'instructions~:\\
		\texttt{\begin{tabular}{ll}
		1	&grille\_sudoku une\_grille;\\
		2	&grille\_initialiser(\& une\_grille);\\
		3	&grille\_joueurcoup(\& une\_grille, 1, 1, 2);\\
		4	&grille\_joueurcoup(\& une\_grille, 1, 3, 5);\\
		5	&grille\_joueurcoup(\& une\_grille, 1, 3, 8);\\
		6	&grille\_joueurcoup(\& une\_grille, 2, 1, 7);\\
		7	&grille\_joueurcoup(\& une\_grille, 2, 3, 5);\\
		8	&grille\_dejoueurcoup(\& une\_grille);\\
		9	&grille\_dejoueurcoup(\& une\_grille);\\
		10	&grille\_dejoueurcoup(\& une\_grille);\\
		11	&grille\_dejoueurcoup(\& une\_grille);\\
		12	&grille\_dejoueurcoup(\& une\_grille);\\
		\end{tabular}}
\end{enumerate} 

\section{Interface graphique du jeu de Sudoku}
Vous devez d\'evelopper l'interface graphique du jeu de sudoku, en gtk. L'interface attendue est minimaliste~: lorsqu'on lance l'application, une grille s'affiche dans une fen\^etre. Cette grille doit permettre au joueur d'inscrire un chiffre dans une case, et ce tant que la grille n'est pas totalement remplie. Le nombre de chiffres qui restent \`a d\'efinir est indiqu\'e par le titre de la fen\^etre, qui est de la forme ``Sudoku : xx valeur(s) \`a d\'efinir''. Enfin un bouton ``Rejouer'' permet de renouveler la grille.

\begin{enumerate} 
\item Composants graphiques ({\bf NB}~: vous pouvez \'evidemment r\'epondre en vous aidant d'un sch\'ema)~:
	\begin{enumerate}
	\item Quels sont les objets graphiques impliqu\'es ({\em ex.}, 3 boutons, 2 libell\'es, etc.)~?
	\item Comment ces objets sont-ils imbriqu\'es entre-eux ({\em ex.}, le bouton \texttt{toto} dans la fen\^etre \texttt{tata}, {\em etc.})~?
	\item Pour chaque imbrication d'un objet dans un autre, indiquer et justifier la fonction gtk \`a utiliser. Vous pouvez pour cela donner le prototype de la fonction si vous le connaissez, ou simplement d\'ecrire la fonction, l'objet gtk sur lequel elle est d\'efinie, sa vocation, ses param\`etres essentiels.  
	\end{enumerate}

\item Leur comportement~: 
	\begin{enumerate}
	\item Indiquer pour chaque composant interactif ({\em ex.} bouton, zone de saisie, {\em etc.}) son \'etat d'activit\'e en fonction de l'\'etat de la grille.
	\item Indiquer pour chaque libell\'e (qu'il s'agisse du titre d'une fen\^etre, du contenu d'une zone de saisie, de l'ic\^one d'un bouton, {\em etc.}) l'\'evolution de sa valeur en fonction de l'\'etat de la partie.
	\end{enumerate}

\item Sollicitations faites au mod\`ele ({\bf NB}~: pour les fonctions gtk, il n'est pas n\'ecessaire d'en conna\^{\i}tre le nom exact, mais leur vocation, et le type des arguments auxquels elles s'appliquent)~:
	\begin{enumerate}
	\item Par quelle fonction lance-t-on une interface graphique gtk~?
	\item Quelle(s) fonction(s) de la biblioth\`eque ``sudoku'' faut-il appeler pr\'ealablement au lancement de l'interface graphique~?
	\item Quelle(s) fonction(s) de la biblioth\`eque ``sudoku'' faut-il appeler lorsque sur l'interface, le joueur a choisi d'attribuer une valeur donn\'ee \`a une case donn\'ee~?
	\item Une fois une interface gtk lanc\'ee, comment peut-on l'arr\^eter~: par quelle action de l'utilisateur, par quelles fonctions gtk, par quels appels faits \`a ces fonctions dans votre programme~?
	\end{enumerate}

\item Comment faire en sorte que votre interface ait le comportement d\'ecrit dans les r\'eponses pr\'ec\'edentes~? Indiquer~:
	\begin{enumerate}
	\item le prototype et la vocation des fonctions que vous envisagez devoir \'ecrire (mais sans \'ecrire les fonctions)~;
	\item l'ensemble des appels que vous envisagez de faire \`a la fonction \texttt{gtk\_signal\_connect}~;
	\item les \'eventuelles structures de donn\'ees que vous envisagez de d\'efinir pour faire appel \`a ces fonctions.
	\end{enumerate}
	
\end{enumerate}

%\subsection*{Partie C : quelques r\'evisions en langage C et gtk}
%\begin{enumerate}
%\item Le programme suivant produit une erreur \`a la compilation~; quelles sont les instructions fautives~?\\
%		\texttt{\begin{tabular}{ll}
%		1&\#include $<$gtk/gtk.h$>$\\
%		2&int main (int argc, char *argv[~])\\
%		3&\{\\
%		4&$\ \ \ \ $GtkWindow* pFenetre = NULL;\\
%		5&$\ \ \ \ $gtk\_init(NULL, NULL);\\
%		6&$\ \ \ \ $pFenetre = gtk\_window\_new(GTK\_WINDOW\_TOPLEVEL);\\
%		7&$\ \ \ \ $gtk\_window\_set\_title(pFenetre, "toto");\\
%		8&$\ \ \ \ $gtk\_widget\_show\_all(GTK\_WIDGET(pFenetre));\\
%		9&$\ \ \ \ $gtk\_main();\\
%		10&$\ \ \ \ $return 0;\\
%		11&\}\\
%		\end{tabular}}
%\item Le programme suivant compile, mais produit des erreurs \`a l'ex\'ecution. Lesquelles, et pourquoi~?\\
%		\texttt{\begin{tabular}{ll}
%		1&\#include $<$gtk/gtk.h$>$\\
%		2&int main (int argc, char *argv[~])\\
%		3&\{\\
%		4&$\ \ \ \ $GtkWidget* pFenetre = NULL;\\	
%		5&$\ \ \ \ $GtkWidget* pBoutonQuitter = NULL;\\
%		6&$\ \ \ \ $gtk\_init(NULL, NULL);\\
%		7&$\ \ \ \ $pFenetre = gtk\_window\_new(GTK\_WINDOW\_TOPLEVEL);\\
%		8&$\ \ \ \ $pBoutonQuitter = gtk\_label\_new("\_Quitter");\\
%		9&$\ \ \ \ $gtk\_container\_add(GTK\_CONTAINER(pFenetre), pBoutonQuitter);\\
%		10&$\ \ \ \ $gtk\_window\_set\_title(GTK\_WINDOW(pFenetre), "tata (pour changer)");\\
%		11&$\ \ \ \ $gtk\_button\_set\_label(GTK\_BUTTON(pBoutonQuitter), "titi (soyons fous !)");\\
%		12&$\ \ \ \ $gtk\_widget\_show\_all(GTK\_WIDGET(pFenetre));\\
%		13&$\ \ \ \ $gtk\_main();\\
%		14&$\ \ \ \ $return 0;\\
%		15&\}\\
%		\end{tabular}}
%\end{enumerate}

\end{document}
