add a test proggy

.gitignore

@@ -3,62 +3,11 @@
 audio/t
 audio/*.wav
 
+nclooper
 ui/t
-
 files/t
 
-
-# ---> C
-# Prerequisites
-*.d
+sounds/*
 
 # Object files
 *.o
-*.ko
-*.obj
-*.elf
-
-# Linker output
-*.ilk
-*.map
-*.exp
-
-# Precompiled Headers
-*.gch
-*.pch
-
-# Libraries
-*.lib
-*.a
-*.la
-*.lo
-
-# Shared objects (inc. Windows DLLs)
-*.dll
-*.so
-*.so.*
-*.dylib
-
-# Executables
-*.exe
-*.out
-*.app
-*.i*86
-*.x86_64
-*.hex
-
-# Debug files
-*.dSYM/
-*.su
-*.idb
-*.pdb
-
-# Kernel Module Compile Results
-*.mod*
-*.cmd
-.tmp_versions/
-modules.order
-Module.symvers
-Mkfile.old
-dkms.conf
-

Makefile

@@ -0,0 +1,23 @@
+#
+#	NC-LOOPER --- another kluge from tth
+#
+
+CC      = gcc
+CCOPT   = -Wall -g -DDEBUG_LEVEL=0
+
+OBJS	= ui/ncfuncs.o files/smpllist.o files/ffuncs.o
+LIBS	= -lcurses
+
+all:	nclooper
+
+main.o:	main.c nclooper.h Makefile
+	$(CC) ${CCOPT} -c $< 
+
+interactive.o:	interactive.c nclooper.h Makefile
+	$(CC) ${CCOPT} -c $< 
+
+OBJS	+= interactive.o
+
+nclooper:	main.o ${OBJS} Makefile
+	$(CC) ${CCOPT} $< ${OBJS} ${LIBS} -o $@
+

audio/Makefile

@@ -1,6 +1,9 @@
+#
+#	NC-LOOPER --- another kluge from tth
+#
 
 CC      = gcc
-CCOPT   = -Wall -g -DDEBUG_LEVEL=1
+CCOPT   = -Wall -g -DDEBUG_LEVEL=0
 LIBS    = -lao -lsndfile -lm
 
 ao_output.o:       ao_output.c Makefile

audio/playfile.c

@@ -47,11 +47,11 @@ if (NULL==sndf)
 
 buffer = calloc(T_BUFF_WAVES, sizeof(short)*2);
 
-#if DEBUG_LEVEL
-fprintf(stderr, "samplerate : %d\n", sfinfo.samplerate);
-fprintf(stderr, "frames     : %ld\n", sfinfo.frames);
-fprintf(stderr, "seekable   : %d\n", sfinfo.seekable);
-#endif
+if (verbosity) {
+	fprintf(stderr, "samplerate : %d\n", sfinfo.samplerate);
+	fprintf(stderr, "frames     : %ld\n", sfinfo.frames);
+	fprintf(stderr, "seekable   : %d\n", sfinfo.seekable);
+	}
 
 for (pass=0; pass<loop; pass++) {
 

audio/t.c

@@ -19,14 +19,37 @@ void help(int k)
 {
 }
 /* --------------------------------------------------------------------- */
+int envoyer_du_son(char *fname, int k)
+{
+ao_device		*device;
+int			foo;
+
+device = init_ao_output(44100);
+if (verbosity) fprintf(stderr, "AO init    -> %p\n", device);
+
+switch (k) {
+	case 0:
+		foo = blast_this_file(fname, device, 1);
+		fprintf(stderr, "blast file -> %d\n", foo);
+		break;
+
+	case 1:
+		foo = play_some_stuff(device, 0);
+		fprintf(stderr, "play stuff -> %d\n", foo);
+		break;
+	}
+
+foo = close_ao_output(device);
+if (verbosity) fprintf(stderr, "AO close   -> %d\n", foo);
+
+return 0;
+}
+/* --------------------------------------------------------------------- */
 
 int main(int argc, char *argv[])
 {
-int			foo;
-ao_device		*device;
 int			opt;
 
-
 while ((opt = getopt(argc, argv, "hv")) != -1) {
 	switch(opt) {
 		case 'h':	help(0);			break;
@@ -38,18 +61,7 @@ while ((opt = getopt(argc, argv, "hv")) != -1) {
 fprintf(stderr, "argc = %d, optind = %d\n", argc, optind);
 #endif
 
-device = init_ao_output(44100);
-fprintf(stderr, "AO init    -> %p\n", device);
-
-foo = play_some_stuff(device, 0);
-fprintf(stderr, "play stuff -> %d\n", foo);
-
-foo = blast_this_file("AK14V-ORDRES.wav", device, 3);
-fprintf(stderr, "blast file -> %d\n", foo);
-
-foo = close_ao_output(device);
-fprintf(stderr, "AO close   -> %d\n", foo);
-
+envoyer_du_son("AK14V-ORDRES.wav", 0);
 
 return 0;
 }

build.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+
+# ------------------------------------------------------------------
+
+function build
+{
+echo =================== $1 ====================
+curdir=${PWD}
+cd $1
+make t
+error=$?
+cd ${curdir}
+
+if [ ${error} -ne 0 ]
+then
+	echo === error on $1 = ${error}
+	exit
+fi
+}
+
+# ------------------------------------------------------------------
+
+build files
+build ui
+build audio
+
+# ------------------------------------------------------------------
+
+printf "\n...final...\n"
+make
+
+# ------------------------------------------------------------------
+
+
+
+
+

files/Makefile

@@ -1,11 +1,18 @@
+#
+#	NC-LOOPER --- another kluge from tth
+#
+
 CC      = gcc
-CCOPT   = -Wall -g -DDEBUG_LEVEL=1
+CCOPT   = -Wall -g -DDEBUG_LEVEL=0
 
 ffuncs.o:  ffuncs.c ffuncs.h Makefile
 	$(CC) ${CCOPT} -c $<
 
+smpllist.o:  smpllist.c smpllist.h ffuncs.h Makefile
+	$(CC) ${CCOPT} -c $<
+
 LIBS	= 
-OBJS	= ffuncs.o
+OBJS	= ffuncs.o smpllist.o
 
 t:	t.c ${OBJS} Makefile
 	$(CC) ${CCOPT} $< ${OBJS} ${LIBS} -o $@

files/ffuncs.h

@@ -2,19 +2,6 @@
  *		various file functions
  */
 
-/* --------------------------------------------------------------------- */
-
-/* two arbitrary magic number */
-#define   SZ_TEXT	20
-#define   SZ_PATH	400
-
-typedef struct	{
-	char		key;
-	int		flags;
-	char		text[SZ_TEXT+1];
-	char		path[SZ_PATH+1];
-	} SampleRef;
-
 
 /* --------------------------------------------------------------------- */
 

files/samples.list

@@ -1,3 +1,4 @@
 a | bla bla | ../AK14V-ORDRES.wav
 z |znare|znare.wav
    B | plop ! | ../AK14V-ORDRES.wav
+c	| classic	|	foo.wav

files/smpllist.c

@@ -0,0 +1,148 @@
+
+#include  <stdio.h>
+#include  <stdlib.h>
+#include  <string.h>
+#include  <ctype.h>
+
+#include  "../nclooper.h"
+
+#include  "ffuncs.h"
+#include  "smpllist.h"
+
+/* --------------------------------------------------------------------- */
+extern int		verbosity;
+/* --------------------------------------------------------------------- */
+void affiche_un_sample(SampleRef *sref, int options)
+{
+printf("%c  %02X  [%-20s]  %s\n", sref->key, sref->flags, sref->text,
+						sref->path);
+}
+/* --------------------------------------------------------------------- */
+void affiche_liste_des_samples(SampleRef samples[])
+{
+int			foo;
+
+for (foo=0; foo<26; foo++) {
+	printf("%2d  %02x    %-30s %s\n", foo, samples[foo].key,
+					samples[foo].text,
+					samples[foo].path);
+	}
+}
+/* --------------------------------------------------------------------- */
+int decode_la_ligne(char *line, SampleRef *sref)
+{
+char			*ptr, *cp;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( '%s' %p )\n", __func__, line, sref);
+// dump(line);
+#endif
+
+/*
+ *	ON THE WAY TO PARSING HELL
+ */
+ptr = strtok(line, "|");
+if (NULL==ptr) {
+	fprintf(stderr, "fubarized\n");
+	return -1;
+	}
+cp = ltrim(rtrim(ptr));
+if (verbosity) fprintf(stderr, "key   [%s]\n", cp);
+if ( ! isalpha(*cp)) {
+	fprintf(stderr, "invalid key 0x%02x\n", *cp);
+	return -2;
+	}
+sref->key = toupper(*cp);
+
+ptr = strtok(NULL, "|");
+if (NULL==ptr) {
+	fprintf(stderr, "line to short\n");
+	return -3;
+	}
+cp = ltrim(rtrim(ptr));
+if (verbosity) fprintf(stderr, "text  [%s]\n", cp);
+if (strlen(cp) > SZ_TEXT) {
+	fprintf(stderr, "text too long\n");
+	return -4;
+	}
+strcpy(sref->text, cp);
+
+ptr = strtok(NULL, "|");
+if (NULL==ptr) {
+	fprintf(stderr, "line to short\n");
+	return -6;
+	}
+cp = ltrim(rtrim(ptr));
+if (verbosity) fprintf(stderr, "path  [%s]\n", cp);
+if (strlen(ptr) > SZ_PATH) {
+	fprintf(stderr, "path too long\n");
+	return -5;
+	}
+strcpy(sref->path, cp);
+
+return 0;
+}
+
+/* --------------------------------------------------------------------- */
+#define T_LINE		500
+
+int lecture_liste_des_samples(char *fname, SampleRef *samples)
+{
+FILE			*fp;
+char			line[T_LINE+1];
+int			ln;				/* line number */
+int			foo, bar, idx;
+SampleRef		sample;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( '%s' )\n", __func__, fname);
+#endif
+
+/*
+ *	first step : clean the current list
+ */
+for (foo=0; foo<26; foo++) {
+	memset(samples+foo, 0, sizeof(SampleRef));
+	}
+
+
+if (NULL==(fp=fopen(fname, "r"))) {
+	perror(fname);
+	exit(1);
+	}
+
+ln = 1;
+while (NULL != fgets(line, T_LINE, fp)) {
+
+	/* degommer l'eventuel \n */
+	bar = strlen(line);
+	if (0==bar) {
+		fprintf(stderr,"line %d very short\n", ln);
+		continue;
+		}
+	bar--;			/* backspace one char */
+	if ('\n' == line[bar]) line[bar]='\0';
+
+	memset(&sample, 0, sizeof(SampleRef));
+	foo = decode_la_ligne(line, &sample);
+#if DEBUG_LEVEL > 1
+	fprintf(stderr, "decode la ligne -> %d\n\n", foo);
+#endif
+	if (!foo) {
+		affiche_un_sample(&sample, 0);
+		idx = tolower(sample.key) - 'a';
+		if (idx<0 || idx>25) {
+			/* serious bug here */
+			break;
+			}
+		memcpy(samples+idx, &sample, sizeof(SampleRef));
+		}
+
+	ln++;
+	}
+
+fclose(fp);
+
+return -1;
+}
+/* --------------------------------------------------------------------- */

files/smpllist.h

@@ -0,0 +1,14 @@
+
+
+/* --------------------------------------------------------------------- */
+
+
+void affiche_un_sample(SampleRef *sref, int options);
+
+void affiche_liste_des_samples(SampleRef samples[]);
+
+int decode_la_ligne(char *line, SampleRef *sref);
+int lecture_liste_des_samples(char *fname, SampleRef *array);
+
+
+

files/t.c

@@ -1,148 +1,47 @@
 /*
- *      NcLooper        test des fonctions fichier (???)
+ *	small proggy for testing some functions
  */
 
+
 #include  <stdio.h>
-#include  <stdlib.h>
-#include  <unistd.h>
 #include  <string.h>
-#include  <ctype.h>
 
 #include  "ffuncs.h"
 
-/* --------------------------------------------------------------------- */
+int verbosity = 1;
 
-int			verbosity;
-
-/* --------------------------------------------------------------------- */
-void affiche_un_sample(SampleRef *sref)
+int test_of_the_trim_funcs(int foo)
 {
-printf("%c %02X [%-20s]  %s\n", sref->key, sref->flags, sref->text,
-						sref->path);
-}
-/* --------------------------------------------------------------------- */
-static int decode_la_ligne(char *line, SampleRef *sref)
-{
-char			*ptr, *cp;
+char	buffer[200];
 
-#if DEBUG_LEVEL
-fprintf(stderr, ">>> %s ( '%s' %p )\n", __func__, line, sref);
-// dump(line);
-#endif
+printf("     --- %s ---\n\n", __func__);
 
-/*
- *	ON THE WAY TO PARSING HELL
- */
-ptr = strtok(line, "|");
-cp = ltrim(rtrim(ptr));
-fprintf(stderr, "key   [%s]\n", cp);
-if ( ! isalpha(*cp)) {
-	fprintf(stderr, "invalid key 0x%02x\n", *cp);
-	return -2;
-	}
-sref->key = toupper(*cp);
+strcpy(buffer, "nothing to trim");
+dump(buffer, NULL);
+puts("");
 
-ptr = strtok(NULL, "|");
-if (NULL==ptr) {
-	fprintf(stderr, "line to short\n");
-	return -3;
-	}
-cp = ltrim(rtrim(ptr));
-fprintf(stderr, "text  [%s]\n", cp);
-if (strlen(cp) > SZ_TEXT) {
-	fprintf(stderr, "text too long\n");
-	return -4;
-	}
-strcpy(sref->text, cp);
+strcpy(buffer, "trailing spaces    ");
+dump(buffer, NULL);
+rtrim(buffer);
+dump(buffer, NULL);
+puts("");
 
-ptr = strtok(NULL, "|");
-if (NULL==ptr) {
-	fprintf(stderr, "line to short\n");
-	return -6;
-	}
-fprintf(stderr, "path  [%s]\n", ltrim(rtrim(ptr)));
-if (strlen(ptr) > SZ_TEXT) {
-	fprintf(stderr, "path too long\n");
-	return -5;
-	}
-strcpy(sref->path, ptr);
+strcpy(buffer, "   leading spaces");
+dump(buffer, NULL);
+ltrim(buffer);
+dump(buffer, NULL);
+puts("");
 
 return 0;
 }
-/* --------------------------------------------------------------------- */
-#define T_LINE		300
-
-int essai_lecture_liste(char *fname)
-{
-FILE			*fp;
-char			line[T_LINE+1];
-int			ln;				/* line number */
-int			foo, bar;
-SampleRef		sample;
-
-#if DEBUG_LEVEL
-fprintf(stderr, ">>> %s ( '%s' )\n", __func__, fname);
-#endif
-
-if (NULL==(fp=fopen(fname, "r"))) {
-	perror(fname);
-	exit(1);
-	}
-
-ln = 1;
-while (NULL != fgets(line, T_LINE, fp)) {
-
-	// fprintf(stderr, "%3d = %s", ln, line);
-
-	/* degommer l'eventuel \n */
-	bar = strlen(line);
-	if (0==bar) {
-		fprintf(stderr,"line %d very short\n", ln);
-		continue;
-		}
-	bar--;			/* backspace one char */
-	if ('\n' == line[bar]) line[bar]='\0';
-
-	memset(&sample, 0, sizeof(SampleRef));
-	foo = decode_la_ligne(line, &sample);
-	fprintf(stderr, "decode la ligne -> %d\n\n", foo);
-	affiche_un_sample(&sample);
-
-	ln++;
-	}
-
-fclose(fp);
-
-return -1;
-}
-/* --------------------------------------------------------------------- */
-void help(int k)
-{
-puts("Test des fonctions de gestion des fichiers");
-exit(0);
-}
-/* --------------------------------------------------------------------- */
 
 int main(int argc, char *argv[])
 {
-int			foo;
-int			opt;
-char			*listname = "samples.list";
 
-while ((opt = getopt(argc, argv, "hv")) != -1) {
-	switch(opt) {
-		case 'h':	help(0);			break;
-		case 'v':	verbosity++;			break;
-		}
-	}
+(void)test_of_the_trim_funcs(0);
+
 
-#if DEBUG_LEVEL
-fprintf(stderr, "argc = %d, optind = %d\n", argc, optind);
-#endif
 
-foo = essai_lecture_liste(listname);
-fprintf(stderr,"essai lecture '%s' -> %d\n", listname, foo);
 
 return 0;
 }
-/* --------------------------------------------------------------------- */

interactive.c

@@ -0,0 +1,83 @@
+/*
+ *		NCLOOPER		INTERACTIVE
+ */
+
+#include  <stdio.h>
+#include  <unistd.h>
+
+#include  "nclooper.h"
+
+/* --------------------------------------------------------------------- */
+
+extern int			verbosity;
+
+/* --------------------------------------------------------------------- */
+static int la_grande_boucle(SampleRef *psmpl, int notused)
+{
+static int		curpos = 0;
+int			key;
+int			flag_exit = 0;
+char			line[120];
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p %d )\n", __func__, psmpl, notused);
+#endif
+
+do	{
+
+	sprintf(line, "curpos %4d", curpos);
+	mvaddstr(1,50, line);
+
+	refresh();
+
+	/* - - - - handle human input, be careful */
+	noecho();
+	key = getch();
+	echo();
+	// sprintf(line, "   key %4d", key);
+	// mvaddstr(2,50, line);
+
+	switch(key) {
+		case KEY_UP:
+			if (curpos < 25) curpos++;
+			break;
+		case KEY_DOWN:
+			if (curpos > 0)  curpos--;
+			break;
+		}		// end of swict
+
+
+	flag_exit = ('X' == key);
+	} while ( ! flag_exit );
+
+return -1;
+}
+/* --------------------------------------------------------------------- */
+int enter_interactive(SampleRef *psmpl, int notused)
+{
+int		foo, row, col;
+char		txt[99];
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %p %d )\n", __func__, psmpl, notused);
+#endif
+
+
+for (foo=0; foo<26; foo++) {
+	idx2position(foo, &row, &col);
+	sprintf(txt, "%3d", foo);
+	mvaddstr(row, col, txt);
+	if (psmpl[foo].key) {
+		standout();
+		mvaddch(row, col+4, psmpl[foo].key);
+		standend();
+		}
+	}
+refresh();
+
+foo = la_grande_boucle(psmpl, notused);		/* wtf ?
+						   notused is used ? */
+
+return -1;
+}
+/* --------------------------------------------------------------------- */

main.c

@@ -0,0 +1,115 @@
+/*
+ *      NcLooper        test des fonctions fichier (???)
+ */
+ 
+#include  <stdio.h>
+#include  <stdlib.h>
+#include  <unistd.h>
+#include  <string.h>
+#include  <ctype.h>
+#include  <ao/ao.h>
+
+#include  "nclooper.h"
+
+/* --------------------------------------------------------------------- */
+
+int			verbosity;
+
+SampleRef		the_samples[26];
+
+/* --------------------------------------------------------------------- */
+void help(int k)
+{
+puts("NcLooper : version pas finie...");
+exit(0);
+}
+/* --------------------------------------------------------------------- */
+/*
+ *	all the basic engines are up, we have to fire ncurses
+ */
+int introduction(int k)
+{
+int			foo;
+ao_device		*device;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %d )\n", __func__, k);
+#endif
+
+foo = init_ecran(__func__);
+sleep(1);
+
+/* check the sound subsystem */
+
+
+return -1;
+}
+/* --------------------------------------------------------------------- */
+int start_the_engine(int k)
+{
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %d )\n", __func__, k);
+#endif
+
+if (k) {
+	fprintf(stderr, "%s: k %d is not null ?\n", __func__, k);
+	exit(1);
+	}
+
+return -1;
+}
+/* --------------------------------------------------------------------- */
+int conclusion(int k)
+{
+int			foo;
+
+#if DEBUG_LEVEL
+fprintf(stderr, ">>> %s ( %d )\n", __func__, k);
+#endif
+
+foo = fin_ecran();
+
+return -1;
+}
+/* --------------------------------------------------------------------- */
+
+int main(int argc, char *argv[])
+{
+int			foo;
+int			opt;
+int			mode = 0;
+char			*listname = "files/samples.list";
+
+while ((opt = getopt(argc, argv, "hl:m:v")) != -1) {
+	switch(opt) {
+		case 'h':	help(0);			break;
+		case 'l':	listname = optarg;		break;
+		case 'm':	mode = atoi(optarg);		break;
+		case 'v':	verbosity++;			break;
+		}
+	}
+
+#if DEBUG_LEVEL
+fprintf(stderr, "argc = %d, optind = %d\n", argc, optind);
+#endif
+
+foo = lecture_liste_des_samples(listname, the_samples);
+fprintf(stderr,"retour lecture liste '%s' -> %d\n", listname, foo);
+
+foo = start_the_engine(mode);
+fprintf(stderr,"retour start engine -> %d\n", foo);
+
+introduction(0);
+
+foo = enter_interactive(the_samples, 0);
+#if DEBUG_LEVEL
+fprintf(stderr, "retour 'enter interactive' -> %d\n", foo);
+#endif
+
+conclusion(0);
+
+return 0;
+}
+/* --------------------------------------------------------------------- */
+

nclooper.h

@@ -0,0 +1,23 @@
+/*
+ *		NcLooper
+ */
+
+
+/* two arbitrary magic number */
+#define   SZ_TEXT	20
+#define   SZ_PATH	400
+
+typedef struct	{
+	char		key;
+	int		flags;
+	char		text[SZ_TEXT+1];
+	char		path[SZ_PATH+1];
+	} SampleRef;
+
+#include  "files/smpllist.h"
+#include  "files/ffuncs.h"
+
+#include  "ui/ncfuncs.h"
+
+
+int enter_interactive(SampleRef *, int notused);

ui/ncfuncs.c

@@ -2,20 +2,24 @@
  *	NcLooper--- interface curses, fonctions de base
  */
 
+#include <stdio.h>
+#include <curses.h>
 
-#include  <curses.h>
+#include  "ncfuncs.h"
 
 /* --------------------------------------------------------------------- */
-int init_ecran(char *txt)
+int init_ecran(const char *txt)
 {
 initscr();
 
 standout();
-border('o', 'o', 'o', 'o', 'X', 'X', 'X', 'X');
+// border('o', 'o', 'o', 'o', 'X', 'X', 'X', 'X');
 standend();
 mvaddstr(1, 5, txt);
 refresh();
 
+keypad(stdscr, 1);
+
 return -1;
 }
 /* --------------------------------------------------------------------- */
@@ -27,3 +31,12 @@ endwin();
 return 0;
 }
 /* --------------------------------------------------------------------- */
+int idx2position(int idx, int *prow, int *pcol)
+{
+
+*prow = 6 + (idx % 13);
+*pcol = 4 + (40*(idx/13));
+
+return 0;
+}
+/* --------------------------------------------------------------------- */

ui/ncfuncs.h

@@ -2,7 +2,10 @@
  *	NcLooper--- interface curses, fonctions de base
  */
 
+#include  <curses.h>
 
-int init_ecran(char *txt);
+int init_ecran(const char *txt);
 int fin_ecran(void);
 
+int idx2position(int idx, int *prow, int *pcol);
+

ui/t.c

@@ -6,24 +6,26 @@
 #include  <stdlib.h>
 #include  <unistd.h>
 
+#include  "../nclooper.h"
 #include  "ncfuncs.h"
 
 /* --------------------------------------------------------------------- */
+
 int			verbosity;
 
 /* --------------------------------------------------------------------- */
 void help(int k)
 {
-puts("plop...");
+puts("test des fonctions de l'interface utilisateur");
 exit(0);
 }
 /* --------------------------------------------------------------------- */
 
 int main(int argc, char *argv[])
 {
-int			foo;
+int			foo, idx;
 int			opt;
-
+int			row, col;
 
 while ((opt = getopt(argc, argv, "hv")) != -1) {
 	switch(opt) {
@@ -37,9 +39,19 @@ fprintf(stderr, "argc = %d, optind = %d\n", argc, optind);
 #endif
 
 foo = init_ecran("* NcLooper *");
-sleep(2);
 
+for (idx=0; idx<26; idx++) {
+	foo = idx2position(idx, &row, &col);
+	standout();
+	mvaddch(row, col,   '<');
+	mvaddch(row, col+1, 'A' + idx);
+	mvaddch(row, col+2, '>');
+	standend();
+	mvaddstr(row, col+5, "bla bla bla...");
+	}
+	refresh();
 
+sleep(3);
 
 fin_ecran();