#pragma implementation
#include <string.h>
#include <stdlib.h>
#include <limits.h>
#include <unistd.h>
#include <fcntl.h>
#include <misc.h>
#include <tlmplib.h>
#include "../framework/framework.h"
#include <tlmpdia.h>
#include "photo.h"
#include "photo.m"
#include <diajava.h>

static const char K_DIR[]="dir";
static const char K_PUBLISH[]="publish";
static const char K_COMMAND[]="command";
static const char K_COMPILE[]="compile";
static const char K_IMPORT[]="import";
static const char K_ARCHIVE[]="archive";
static const char K_VIEWCMD[]="viewcmd";

/*
	Get the path of the compilation script
*/
static const char *photo_getcompile()
{
	return linuxconf_getval(K_COMMAND,K_COMPILE,"/usr/lib/tlmp/lib/photo_compile");
}
/*
	Get the path of the import script
*/
static const char *photo_getimport()
{
	return linuxconf_getval(K_COMMAND,K_IMPORT,"/usr/lib/tlmp/lib/photo_import");
}

static const char *photo_getarchive()
{
	static char tmp[PATH_MAX];
	snprintf (tmp,sizeof(tmp)-1,"%s/.tlphoto",getenv("HOME"));
	return linuxconf_getval (K_DIR,K_ARCHIVE,tmp);
}

static const char *photo_getviewcmd()
{
	return linuxconf_getval (K_COMMAND,K_VIEWCMD,"/usr/X11R6/bin/display");
}


/*
	Set the program preferences
*/
static void photo_prefer()
{
	DIALOG dia;
	SSTRING compile (photo_getcompile());
	dia.newf_str (MSG_U(F_COMPILE,"Compilation command"),compile,60);
	SSTRING import (photo_getimport());
	dia.newf_str (MSG_U(F_IMPORT,"Import command"),import,60);
	SSTRING viewcmd (photo_getviewcmd());
	dia.newf_str (MSG_U(F_VIEWCMD,"View command"),viewcmd,60);
	SSTRING archive (photo_getarchive());
	dia.newf_str (MSG_U(F_ARCHIVEDIR,"Archive directory"),archive,60);
	dia.settype (DIATYPE_POPUP);
	int nof = 0;
	while (1){
		MENU_STATUS code = dia.edit (MSG_U(T_PREFER,"Preferences"),""
			,help_nil,nof);
		if (code == MENU_CANCEL || code == MENU_ESCAPE){
			break;
		}else{
			if (file_type (compile.get())!=0){
				xconf_error (MSG_U(E_NOCOMMAND,"Command does not exist: %s")
					,compile.get());
				nof = 0;
			}else if (file_type (import.get())!=0){
				xconf_error (MSG_R(E_NOCOMMAND),import.get());
				nof = 1;
			}else{
				linuxconf_replace (K_COMMAND,K_COMPILE,compile);
				linuxconf_replace (K_COMMAND,K_IMPORT,import);
				linuxconf_replace (K_COMMAND,K_VIEWCMD,viewcmd);
				linuxconf_replace (K_DIR,K_ARCHIVE,archive);
				linuxconf_save();
				break;
			}
		}
	}
}

<mod>
static void photo_showcmd(const char *cmd)
{
	<glocal>
		DIALOG dia;
	</glocal>
	glocal.dia.settype (DIATYPE_POPUP);
	<call walkpopen>(cmd,20,true);
	<f oneline>
		glocal.dia.newf_info ("  ",line);
		return 0;
	</f>
	<f oneerr>
		glocal.dia.newf_info ("**",line);
		return 0;
	</f>
	</call>
	int nof = 0;
	glocal.dia.edit (MSG_U(T_CAMERACMD,"Camera commands"),cmd,help_nil,nof,MENUBUT_CANCEL);
}
</mod>

<mod>
static int photo_execcmd(const char *cmd, bool bg)
{
	if (bg && fork() != 0) return 0;
	<glocal>
		SSTRING errs;
	</glocal>
	int ret = 0;
	<call walkpopen>(cmd,20,true);
	<f oneline>
		return 0;
	</f>
	<f oneerr>
		glocal.errs.appendf ("%s\n",line);
		return 0;
	</f>
	</call>
	if (bg){
		_exit (0);
	}else if (glocal.errs.is_filled()){
		xconf_error ("%s\n%s\n\n%s",MSG_R(T_CAMERACMD),cmd,glocal.errs.get());
		ret = -1;
	}
	return ret;
}
</mod>

static int photo_execcmd(const char *cmd)
{
	return photo_execcmd (cmd,false);
}


<mod>
static int photo_deltmpdir()
{
	int ret = 0;
	SSTRING dir;
	dir.setfromf ("/tmp/tlphoto.%d",getpid());
	if (file_exist(dir.get())){
		SSTRING cmd;
		cmd.setfromf ("rm -fr %s",dir.get());
		ret = photo_execcmd (cmd.get());
	}
	return ret;
}
</mod>

<mod>
static int photo_edittxt (
	const char *fpath,		// text file path
	FRAMEWORK_INFO &info,
	_F_FRAMEWORK &c)
{
	<glocal>
		SSTRING txt;
	</glocal>
	<call loadfile>(fpath,false);
	<f missing>
		// Do nothing
	</f>
	<f oneline>
		glocal.txt.append (line);
		return 0;
	</f>
	</call>
	DIALOG dia;
	info.msgs.waitfor (dia);
	dia.newf_textarea (NULL,glocal.txt,50,10);
	int nof = 0;
	const char *fname = strrchr(fpath,'/');
	if (fname == NULL){
		fname = fpath;
	}else{
		fname++;	// Skip the slash
	}
	int ret = -1;
	while (1){
		MENU_STATUS code = dia.edit (fname,"",help_nil,nof);
		if (code == MENU_CANCEL || code == MENU_ESCAPE){
			break;
		}else if (code == MENU_MESSAGE){
			if (c.must_end (info.msgs)){
				break;
			}
		}else{
			<call savefile>(fpath,false);
			<f dowrite>
				fputs (glocal.txt.get(),fout);
				return 0;
			</f>
			</call>
			ret = 0;
			break;
		}
	}
	return ret;
}
</mod>

/*
	Load the first line of a file if it exist
*/
<mod>
static void photo_loadfirstline (const char *file, SSTRING &line)
{
	<glocal>
		SSTRING *line;
	</glocal>
	glocal.line = &line;
	line.setempty();
	<call loadfile>(file,true);
	<f missing>
	</f>
	<f oneline>
		glocal.line->setfrom(line);
		return -1;
	</f>
	</call>
}
</mod>

/*
	Copy a file to a directory.
	Return -1 if any errors.
*/
<mod>
static int photo_copy2dir (
	const char *file,
	const char *dir,
	bool update_only,
	DIALOG &dia,
	int &status,
	SSTRING &fstatus,
	const char *cnv_str)
{
	glocal DIALOG *dia = &dia;
	glocal int *status = &status;
	int ret = -1;
	if (file_mkdirp (dir,-1,-1,0755)!=-1){
		const char *name = strrchr(file,'/');
		if (name == NULL){
			name = file;
		}else{
			name++;
		}
		SSTRING tmp;
		tmp.setfromf ("%s/%s",dir,name);
		fstatus.setfrom (file);
		status = 0;
		dia.reload();
		// fprintf (stderr,"file_copy %s -> %s\n",file,tmp.get());
		struct stat source_st,dest_st;
		if (!update_only
			|| stat(file,&source_st)==-1	// Not likely
			|| stat(tmp.get(),&dest_st)==-1	// Not likely
			|| source_st.st_size != dest_st.st_size){
			if (cnv_str != NULL && cnv_str[0] != '\0'){
				SSTRING cmd;
				cmd.setfromf ("convert %s %s %s",cnv_str,file,tmp.get());
				diagui_flush();
				<call walkpopen>(cmd.get(),10,true);
				<f oneline>
					return 0;
				</f>
				<f oneerr>
					fprintf (stderr,"err: %s\n",line);
					return 0;
				</f>
				</call>
			}else{
				ret = <call copyfile> (file,tmp.get());
				<f progress>
					*glocal.status = sofar*100/size;
					glocal.dia->reload();
					diagui_flush();
				</f>
				</call>
			}
		}
	}
	return ret;
}
</mod>
<mod>
static void photo_publish (
	const char *dir,		// Directory containing the photos
	SSTRINGS &dels,			// Photos to exclude
	const char *destdir,	// Target directory where we must
							// put the webpage and the photos
	bool pub_photos,		// Copy photos
	bool pub_thumbs,		// Copy thumbs
	bool update_only,		// Copy only missing file (and different size)
	const char *cnv_str)	// Argument for the convert program or NULL
{
	glocal DIALOG dia;
	glocal SSTRING copying;		// File being copied
	glocal SSTRING desc;		// Description of the photo
	glocal int copying_status = 0;
	glocal int publish_status = 0;
	glocal const char *dir = dir;
	glocal const char *destdir = destdir;
	glocal SSTRINGS *dels = &dels;
	glocal bool pub_photos = pub_photos;
	glocal bool pub_thumbs = pub_thumbs;
	glocal bool update_only = update_only;
	glocal const char *cnv_str = cnv_str;
	glocal SSTRINGS photos;		// List of jpg to publish

	glocal int nbphotos = 0;
	// How many files to copy
	<call walkfs>(glocal.dir);
	<f onefile>
		if (strstr(basename,".jpg")!=NULL
			&& strstr(basename,".th.jpg")==NULL
			&& glocal.dels->lookup(basename)==-1){
			glocal.nbphotos++;
			glocal.photos.add (new SSTRING(basename));
		}
	</f>
	</call>

	glocal.dia.settype (DIATYPE_POPUP);
	glocal.dia.newf_str (MSG_U(F_SUBJECT,"Subject"),glocal.desc);
	glocal.dia.set_lastreadonly();
	glocal.dia.newf_gauge ("",glocal.publish_status,glocal.nbphotos);

	glocal.dia.newf_str (MSG_U(F_FILE,"Copying file"),glocal.copying);
	glocal.dia.set_lastreadonly();
	glocal.dia.newf_gauge ("",glocal.copying_status,100);
	int nof = 0;
	glocal.dia.show (MSG_U(F_PUBLISHING,"Publishing"),"",help_nil,nof,0);

	SSTRING tmp;
	tmp.setfromf ("%s/index.html",destdir);
	<call savefile>(tmp.get(),false);
	<f dowrite>
		glocal FILE *fout = fout;
		fputs ("<html>\n",fout);
		fputs ("<head>\n",fout);
		fputs ("</head>\n",fout);
		fputs ("<body>\n",fout);
		SSTRING tmp;
		tmp.setfromf ("%s/description",glocal.dir);
		<call loadfile>(tmp.get(),true);
		<f missing>
			fputs (MSG_U(I_NODESC,"No description"),glocal.fout);
		</f>
		<f oneline>
			if (noline == 0){
				fprintf (glocal.fout,"<center><h1>%s</h1></center>\n",line);
				fputs ("<p><dl><dd>\n",glocal.fout);
			}else{
				fprintf (glocal.fout,"%s\n",line);
			}
			return 0;
		</f>
		<f end>	
			fputs ("</dl>\n",glocal.fout);
		</f>
		</call>
		fputs ("<table border=0><tr>\n",fout);
		glocal int rowcnt=0;
		for (int i=0; i<glocal.photos.getnb(); i++){
			const char *basename = glocal.photos.getitem(i)->get();
			glocal SSTRING prec;
			glocal SSTRING next;
			glocal SSTRING name;
			glocal SSTRING file_image;
			glocal SSTRING file_html;
			glocal SSTRING file_txt;
			glocal SSTRING path;
			glocal SSTRING path_th;

			if (i!=0){
				const char *pt = glocal.photos.getitem(i-1)->get();
				int len = strlen(pt)-4;
				glocal.prec.setfromf ("%*.*s.html",len,len,pt);
			}
			if (i < glocal.photos.getnb()-1){
				const char *pt = glocal.photos.getitem(i+1)->get();
				int len = strlen(pt)-4;
				glocal.next.setfromf ("%*.*s.html",len,len,pt);
			}

			glocal.name.setfrom (basename,strlen(basename)-4);
			glocal.file_image.setfromf ("%s.jpg",glocal.name.get());
			glocal.file_txt.setfromf ("%s/%s.txt",glocal.dir,glocal.name.get());
			glocal.file_html.setfromf ("%s/%s.html",glocal.destdir,glocal.name.get());
			glocal.path.setfromf ("%s/%s.jpg",glocal.dir,glocal.name.get());
			glocal.path_th.setfromf ("%s/%s.th.jpg",glocal.dir,glocal.name.get());

			if (glocal.rowcnt == 3){
				fputs ("<tr>",glocal.fout);
				glocal.rowcnt = 0;
			}
			fputs ("<td width=33%>",glocal.fout);
			glocal.rowcnt++;
			fprintf (glocal.fout,"<a href=%s.html><img src=%s.th.jpg></a>\n"
				,glocal.name.get(),glocal.name.get());
			fputs ("<br>\n",glocal.fout);
			// Create the large image html file
			<call savefile>(glocal.file_html.get(),false);
			<f dowrite>
				glocal FILE *fout_html = fout;
				fputs ("<html><body>\n",fout);
				fprintf (fout,"<a href=index.html>%s</a>\n"
						,MSG_U(I_INDEX,"Index"));
				if (glocal.prec.is_filled()){
					fprintf (fout,"<a href=%s>%s</a>\n",glocal.prec.get()
						,MSG_U(I_PREC,"Précédant"));
				}
				if (glocal.next.is_filled()){
					fprintf (fout,"<a href=%s>%s</a>\n",glocal.next.get()
						,MSG_U(I_NEXT,"Suivant"));
				}
				fputs ("<p>\n",fout);
				fputs ("<center>\n",fout);
				// Read the description associated with the file
				<call loadfile>(glocal.file_txt.get(),false);
				<f missing>
					glocal.desc.setfrom (MSG_U(I_NODESCRIPTION,"*** No description ***"));
				</f>
				<f oneline>
					if (noline == 0){
						glocal.desc.setfrom (line);
						glocal.desc.strip_end();
					}
					// We limit description in the index html file
					if (noline < 4){
						fputs (line,glocal.fout);
					}else if (noline == 4){
						fputs ("<strong>...</strong>\n",glocal.fout);
					}
					fputs (line,glocal.fout_html);
					return 0;
				</f>
				</call>
				fputs ("</center>\n",fout);
				fputs ("<p>\n",fout);
				fprintf (fout,"<center><img src=%s.jpg></center>\n",glocal.name.get());
				fputs ("</html></body>\n",fout);
				return 0;
			</f>
			</call>
			fprintf (glocal.fout,"</td>\n");
			glocal.publish_status++;				
			glocal.dia.reload();
			if (glocal.destdir != NULL){
				// Copy the image and the thumbnail
				if (glocal.pub_photos){
					photo_copy2dir (glocal.path.get(),glocal.destdir
						,glocal.update_only
						,glocal.dia,glocal.copying_status
						,glocal.copying,glocal.cnv_str);
				}
				if (glocal.pub_thumbs){
					photo_copy2dir (glocal.path_th.get(),glocal.destdir
						,glocal.update_only
						,glocal.dia,glocal.copying_status
						,glocal.copying,NULL);
				}
			}
		}
		fputs ("</table>\n",fout);
		fputs ("</body>\n",fout);
		fputs ("</html>\n",fout);
		return 0;
	</f>
	</call>
}
</mod>

static void photo_publish (const char *dir, SSTRINGS &dels)
{
	DIALOG dia;
	SSTRING destdir;
	FIELD_COMBO *comb = dia.newf_combo (MSG_U(F_TARGETDIR,"Target directory")
		,destdir);
	SSTRINGS tb;
	{
		linuxconf_getall (K_DIR,K_PUBLISH,tb,true);
		if (tb.getnb()==0){
			SSTRING *s = new SSTRING;
			s->setfromf ("%s/n/html",getenv("HOME"));
			tb.add (s);
		}
		for (int i=0; i<tb.getnb(); i++){
			comb->addopt (tb.getitem(i)->get());
		}
	}
	char export_photo = 1, export_thumbs = 1;
	dia.newf_chk (MSG_U(F_PUBLISH,"Publish"),export_photo
		,MSG_U(I_PUBLISHPHOTOS,"photos"));
	dia.newf_chk (MSG_R(F_PUBLISH),export_thumbs
		,MSG_U(I_PUBLISHTHUMBS,"thumbnails"));
	char copyonly = 1;
	dia.newf_chk (MSG_U(F_COPYONLY,"Copy only"),copyonly,MSG_U(I_COPYONLY,"modified files"));
	SSTRING cnv_str;
	cnv_str.setfrom ("-resize 1024x768");
	dia.newf_str (MSG_U(F_CNV_STR,"Convert command argument"),cnv_str);
	dia.settype (DIATYPE_POPUP);
	if (dia.edit (MSG_U(T_PUBLISHDIR,"Publication directory"),"",help_nil)
		== MENU_ACCEPT){
		if (tb.lookup(destdir.get())==-1){
			tb.insert (0,new SSTRING(destdir));
		}
		for (int i=10; i<tb.getnb(); i++) tb.remove_del(10);
		linuxconf_replace (K_DIR,K_PUBLISH,tb);
		linuxconf_save();
		photo_publish (dir,dels,destdir.get(),export_photo,export_thumbs
			,copyonly,cnv_str.get());
		xconf_notice (MSG_U(N_DONE,"Opération complètée"));
	}
}

/*
	Import the content of the camara in a directory choosen
	by the user.

	Return -1 if any errors. dir will contain the directory
	selected by the user. The directory is created as needed.
*/
<mod>
static int photo_import (SSTRING &dir)
{
	<glocal>
		SSTRING desc;
	</glocal>
	dir.setfrom (photo_getarchive());
	dir.setfrom (linuxconf_getval(K_DIR,K_IMPORT,dir.get()));
	DIALOG dia;
	dia.settype (DIATYPE_POPUP);
	FIELD_COMBO *comb = dia.newf_combo (MSG_R(F_DIRECTORY),dir,50);
	comb->addopt (photo_getarchive());
	dia.newf_textarea (MSG_U(F_DESCRIPTION,"Description"),glocal.desc,50,10);
	int nof = 0;
	int ret = -1;
	while (1){
		MENU_STATUS code = dia.edit (MSG_U(T_IMPORTDIR,"Import photos")
			,MSG_U(I_IMPORTDIR
				,"Enter the path of the directory where you want\n"
				 "import the photos. The directory will be created as needed.\n"
				 "Fill a description for the album.")
			,help_nil
			,nof);
		if (code == MENU_ESCAPE || code == MENU_CANCEL){
			break;
		}else{
			SSTRING cmd;
			// First we must know how many photos
			<glocal>
				int nb;
				DIALOG dia;		// Use to present the progress bars
				int thumbs;
				int images;
				bool importing_images;
				SSTRING errs;
			</glocal>
			glocal.nb = 0;
			cmd.setfrom ("jphoto tree");
			<call walkpopen>(cmd.get(),5,true);
			<f oneline>
				if (strcasestr(line,".jpg")!=NULL) glocal.nb++;
				return 0;
			</f>
			</call>
			glocal.thumbs = glocal.images = 0;
			glocal.importing_images = true;
			glocal.dia.newf_gauge (MSG_U(F_THUMBNAILS,"Thumb nails"),glocal.thumbs,glocal.nb);
			glocal.dia.newf_gauge (MSG_U(F_PHOTOS,"Photos"),glocal.images,glocal.nb);
			glocal.dia.settype (DIATYPE_POPUP);
			int nof=0;
			glocal.dia.show (MSG_U(T_IMPORTING,"Importing"),"",help_nil,nof,0);
			if (dir.get()[0] != '/'){
				// Relative directory, turn it into absolute
				char cwd[PATH_MAX];
				if (getcwd(cwd,sizeof(cwd)-1)!=NULL){
					dir.setfromf ("%s/%s",cwd,dir.get());
				}
			}
			cmd.setfromf ("%s %s",photo_getimport(),dir.get());
			ret = <call walkpopen>(cmd.get(),20,true);
			<f oneline>
				if (strcmp(line,"#IMAGES")==0){
					glocal.importing_images = true;
				}else if (strcmp(line,"#THUMBS")==0){
					glocal.importing_images = false;
				}else if (strstr(line,".jpg")!=NULL){
					if (glocal.importing_images){
						glocal.images++;
					}else{
						glocal.thumbs++;
					}
					glocal.dia.reload();
					diagui_flush();
				}
				return 0;
			</f>
			<f oneerr>
				glocal.errs.appendf ("%s\n",line);
				return 0;
			</f>
			</call>
			if (ret > 0 && glocal.errs.is_empty()){
				SSTRING file;
				file.setfromf ("%s/description",dir.get());
				<call savefile>(file.get(),false);
				<f dowrite>
					fputs (glocal.desc.get(),fout);
					return 0;
				</f>
				</call>
				linuxconf_replace (K_DIR,K_IMPORT,dir.get());
				linuxconf_save();
				break;
			}else{
				xconf_error (MSG_U(E_IMPORTFAIL,"Import failed:\n%s")
					,glocal.errs.get());
			}
		}
	}
	return ret;
}
</mod>

struct PHOTO_ST{
	PRIVATE_MESSAGE msg;	// Click on photo;
	PRIVATE_MESSAGE del;	// Click on the delete flag
	PRIVATE_MESSAGE pub;	// Click on the publish flag
	bool published;			// Is this photo published
	bool deleted;			// Is this photo deleted
	SSTRING desc;			// One line description
	SSTRING last;			// Was this the last photo reviewed
							// Should be a small icon
	FIELD_BUTTON_ICON *fdel;	// To change button content
	FIELD_BUTTON_ICON *fpub;
	PHOTO_ST(){
		published = true;
		deleted = false;
		fpub = NULL;
		fdel = NULL;
	}
};

<mod>
int main (int argc, char *argv[])
{
	<call tlmpprogram>(argc,argv,"tlmpwork");
	<f usage>
	</f>
	<f showerror>
		xconf_error ("%s",msg);
	</f>
	<f main_noarg>
		glocal PRIVATE_MESSAGE loaddesc;
		<obj FRAMEWORK fram>(MSG_U(T_TLPHOTO,"TLMP Photo"));
		<f about>
			<call aboutbox>("TLMP photo",TLMPWORK_VERSION,TLMPWORK_RELEASE);
			<f intro>
				printf (MSG_U(I_ABOUT
					,"This is TLMP photo\n"
					 "\n"
					 "This software is used to manage photos from a digital\n"
					 "camera, documente them and publish albums on the internet\n"));
			</f>
			<f authors>
				printf ("Jacques Gélinas jack@solucorp.qc.ca\n");
			</f>
			<f license>
				setgpl();
			</f>
			<f see_also>
				printf (MSG_U(I_HOMESITE,"Home site http://www.solucorp.qc.ca/tlmp\n"));
			</f>
			</call>
		</f>
		<f layout>
			layout_area1(true);
		</f>
		<f menubar>
			topmenu(MSG_U(M_FILE,"File"));
			menuentry (1,MSG_U(M_BROWSEDIR,"Browse directory"));
			menuentry (2,MSG_U(M_PREFER,"Preferences"));
			menuentry (3,MSG_U(M_CLOSE,"Close"));
			menuentry (99,MSG_U(M_QUIT,"Quit"));
			endmenu();
			topmenu (MSG_U(M_CAMERA,"Camera"));
			menuentry (101,MSG_U(F_CAMINFO,"Camera info"));
			menuentry (102,MSG_U(F_CAMCONTENT,"Content"));
			menuentry (103,MSG_U(F_CAMFREE,"Flash usage"));
			menuentry (104,MSG_U(F_CAMTHUMB,"Import photos"));
			menuentry (105,MSG_U(F_ERASEFLASH,"Erase all pictures"));
			endmenu();
			helpmenu();
			endmenu();
		</f>
		<f menudo>
			if (id == 1){
				DIALOG dia;
				dia.settype (DIATYPE_POPUP);
				SSTRING dir;
				dia.newf_str (MSG_U(F_DIRECTORY,"Directory"),dir,60);
				if (dia.edit ("","",help_nil)==MENU_ACCEPT){
					newdocument (strdup(dir.get()));
				}
			}else if (id == 2){
				photo_prefer();
			}else if (id == 99){
				end();
			}else if (id == 101){
				photo_showcmd ("jphoto status");
			}else if (id == 102){
				photo_showcmd ("jphoto tree");
			}else if (id == 103){
				photo_showcmd ("jphoto storage");
			}else if (id == 104){
				SSTRING dir;
				if (photo_import(dir) != -1){
					dialog_sendmessage (glocal.loaddesc);
					newdocument (strdup(dir.get()));
				}
			}else if (id == 105){
			}
		</f>
		<f taskbar>
		</f>
		<f taskdo>
		</f>
		<f area1>
			const char *dir = (const char *)info.data;
			glocal	FRAMEWORK_INFO *info = &info;

			if (info.nbdocument==1){
				glocal SSTRINGS dirs;
				<call editrecords>(MSG_U(T_INDEX,"Index"),"",help_nil);
				<f head>
					newf_head (MSG_U(H_CATALOGS,"Catalogs\tDescription"));
					nobutton();
					sortable();
					sortpolicy ("aa");
					waitfor(glocal.info->msgs.ending);
					waitfor(glocal.info->msgs.mayend);
					waitfor(glocal.loaddesc);
				</f>
				<f message>
					if (glocal.FRAMEWORK.must_end(glocal.info->msgs)){
						endedit();
					}
				</f>
				<f load>
					glocal.dirs.remove_all();
					<call walkfs>(photo_getarchive());
					<f onefile>
						if (file_type(path)==1){
							glocal.dirs.add (new SSTRING(relpath));
							SSTRING descfile;
							descfile.setfromf ("%s/description",path);
							SSTRING desc;
							photo_loadfirstline (descfile.get(),desc);
							glocal.editrecords.new_menuitem (relpath,desc.get());
						}
					</f>
					</call>
				</f>
				<f editone>
					const char *dir = glocal.dirs.getitem(no)->get();
					char tmp[PATH_MAX];
					sprintf (tmp,"%s/%s",photo_getarchive(),dir);
					if (uistate.rightb){
						DIALOG_MENUPOPUP pop;
						pop.new_menuitem ("",MSG_R(M_EDIT));
						pop.new_menuitem ("",MSG_U(M_PUBLISH,"Publish"));
						pop.new_menuitem ("",MSG_R(M_DELETE));
						int sel = 0;
						if (pop.editmenu (NULL,sel)==MENU_OK){
							if (sel == 0){
								strcat (tmp,"/description");
								photo_edittxt (tmp,*glocal.info,glocal.FRAMEWORK);
							}else if (sel == 1){
								SSTRINGS dels;
								photo_publish(tmp,dels);
							}else if (sel == 2){
								// Delete everything
							}
						}
					}else{
						glocal.FRAMEWORK.newdocument ((void*)strdup(tmp));
					}
				</f>
				</call>
			}else if (strstr (dir,".txt")!=NULL){
				// A comment file
				if (photo_edittxt (dir,info,*this) != -1){
					dialog_sendmessage(glocal.loaddesc);
				}
			}else{
				// A directory
				glocal DIALOG dia;
				glocal SSTRINGS files;
				glocal const char *dir = dir;
				glocal int n = dir_getlist (dir,".jpg",glocal.files);

				glocal.dia.waitfor (glocal.loaddesc);
				info.msgs.waitfor (glocal.dia);
				diagui_seticonpath (dir);
				for (int i=0; i<glocal.n; i++){
					const char *s = glocal.files.getitem(i)->get();
					if (strstr(s,".th")!=NULL){
						glocal.files.remove_del(i);
						glocal.n--;
						i--;
					}
				}
				glocal PHOTO_ST *photos = new PHOTO_ST[glocal.n];
				// Read the saved state of the publish buttons
				SSTRING notpub;
				notpub.setfromf ("%s/notpublished",dir);
				<call loadfile>(notpub.get(),true);
				<f missing>
					// This is ok, the file is optional
				</f>
				<f oneline>
					int look = glocal.files.lookup(line);
					if (look != -1){
						glocal.photos[look].published = false;
					}
					return 0;
				</f>
				</call>
				for (int i=0; i<glocal.n; i+=3){
					if (i > 0) glocal.dia.newline();
					for (int j=i; j<i+3 && j<glocal.n; j++){
						PHOTO_ST *st = glocal.photos + j;
						const char *file = glocal.files.getitem(j)->get();
						SSTRING tmp;
						tmp.setfromf ("%s/%s.th.xpm",dir,file);
						if (file_exist(tmp.get())){
							glocal.dia.new_button_icon (tmp.get(),file,st->msg);
						}else{
							tmp.setfromf ("%s/%s.th.jpg",dir,file);
							if (file_exist(tmp.get())){
								glocal.dia.new_button_icon (tmp.get(),file,st->msg);
							}else{
								glocal.dia.new_button (file,"",st->msg);
							}
						}
						glocal.dia.gui_dispolast (GUI_H_CENTER,4,GUI_V_CENTER,1);
					}
					glocal.dia.newline();
					for (int j=i; j<i+3 && j<glocal.n; j++){
						PHOTO_ST *st = glocal.photos + j;
						SSTRING txt;
						txt.setfromf ("%s/%s.txt",dir,glocal.files.getitem(j)->get());
						photo_loadfirstline (txt.get(),st->desc);
						st->desc.truncate(20);
						glocal.dia.newf_str (NULL,st->last,1);
						glocal.dia.set_lastreadonly();
						glocal.dia.newf_str (NULL,st->desc,20);
						glocal.dia.set_lastreadonly();
						st->fdel = glocal.dia.new_button_icon ("kept",MSG_U(B_DELETETHIS,"Delete photo"),st->del);
						st->fpub = glocal.dia.new_button_icon (
							st->published ? "published" : "notpublished"
							,MSG_U(B_PUBLISHTHIS,"Publish photo"),st->pub);
					}
				}
				int nof = 0;
				glocal.dia.setbutinfo (MENU_USR1,MSG_R(M_PUBLISH),MSG_R(M_PUBLISH));
				glocal.dia.setbutinfo (MENU_USR2,MSG_U(B_COMMIT,"Commit deletion"),MSG_R(B_COMMIT));
				glocal.dia.setbutinfo (MENU_USR3,MSG_U(B_ALL,"Publish all"),MSG_R(B_ALL));
				glocal.dia.setbutinfo (MENU_USR4,MSG_U(B_NONE,"None"),MSG_R(B_NONE));
				glocal.dia.setbutinfo (MENU_USR5,MSG_U(B_INDEX,"Index"),MSG_R(B_INDEX));
				glocal.dia.waitfor (glocal.info->docmsgs.menubar);
				while (1){
					MENU_STATUS code = glocal.dia.edit (dir,"",help_nil,nof
						,MENUBUT_CANCEL|MENUBUT_USR1|MENUBUT_USR2
							|MENUBUT_USR3|MENUBUT_USR4|MENUBUT_USR5);
					bool must_reload = false;
					if (code == MENU_ESCAPE || code == MENU_CANCEL){
						break;
					}else if (code == MENU_MESSAGE){
						if (must_end (info.msgs)){
							break;
						}else if (dialog_testmessage(glocal.loaddesc)){
							must_reload = true;
						}else if (dialog_testmessage(glocal.info->docmsgs.menubar)){
							if (glocal.info->menuid == 3){
								break;
							}
						}else{
							for (int i=0; i<glocal.n; i++){
								PHOTO_ST *st = glocal.photos + i;
								if (dialog_testmessage(st->msg)){
									for (int j=0; j<glocal.n; j++){
										glocal.photos[j].last.setempty();
									}
									st->last.setfrom (">");
									glocal.dia.reload();
									UISTATE uist;
									diajava_lastmousestate(uist);
									// fprintf (stderr,"uist %d %d %d shift %d\n",uist.leftb,uist.middleb,uist.rightb,uist.shiftkey);
									if (uist.shiftkey || uist.rightb){
										DIALOG_MENUPOPUP pop;
										pop.new_menuitem ("",MSG_U(M_VIEW,"View"));
										pop.new_menuitem ("",MSG_U(M_EDIT,"Edit comment"));
										pop.new_menuitem ("",MSG_U(M_MODIFY,"Modify image"));
										pop.new_menuitem ("",MSG_U(M_DELETE,"Delete"));
										int sel = 0;
										if (pop.editmenu (NULL,sel)==MENU_OK){
											SSTRING cmd;
											if (sel == 0){
												// Show the photo
												cmd.setfromf ("%s %s/%s.jpg"
													,photo_getviewcmd()
													,dir,glocal.files.getitem(i)->get());
												photo_execcmd(cmd.get(),true);
											}else if (sel == 1){
												cmd.setfromf ("%s/%s.txt"
													,dir,glocal.files.getitem(i)->get());
												newdocument (strdup(cmd.get()));
											}else if (sel == 2){
												// Modify
												cmd.setfromf ("gimp %s/%s.jpg"
													,dir,glocal.files.getitem(i)->get());
												photo_execcmd(cmd.get(),true);
											}else if (sel == 3){
												st->deleted = ! st->deleted;
												st->fdel->seticon (st->deleted ? "deleted" : "kept");
											}
										}
									}else{
										// Show the photo
										SSTRING cmd;
										cmd.setfromf ("%s %s/%s.jpg"
											,photo_getviewcmd()
											,dir,glocal.files.getitem(i)->get());
										photo_execcmd(cmd.get(),true);
									}
									break;
								}else if (dialog_testmessage(st->del)){
									st->deleted = ! st->deleted;
									st->fdel->seticon (st->deleted ? "deleted" : "kept");
								}else if (dialog_testmessage(st->pub)){
									st->published = ! st->published;
									st->fpub->seticon (st->published ? "published" : "notpublished");
									<call savefile>(notpub.get(),false);
									<f dowrite>
										for (int i=0; i<glocal.n; i++){
											if (!glocal.photos[i].published){
												fprintf (fout,"%s\n",glocal.files.getitem(i)->get());
											}
										}
										return 0;
									</f>
									</call>
								}
							}
						}
					}else if (code == MENU_USR1){
						SSTRINGS dels;
						for (int i=0; i<glocal.n; i++){
							PHOTO_ST *st = glocal.photos + i;
							if (!st->published){
								SSTRING *s = new SSTRING;
								s->setfromf ("%s.jpg",glocal.files.getitem(i)->get());
								dels.add (s);
							}
						}
						photo_publish (dir,dels);
					}else if (code == MENU_USR2){
						for (int i=0; i<glocal.n; i++){
							PHOTO_ST *st = glocal.photos + i;
							if (st->deleted){
								for (int j=0; j<3; j++){
									SSTRING cmd;
									static const char *exts[]={"jpg","th.jpg","txt"};
									cmd.setfromf ("%s/%s.%s"
										,dir,glocal.files.getitem(i)->get(),exts[j]);
									unlink (cmd.get());
								}
							}
						}
						break;
					}else if (code == MENU_USR3
						|| code == MENU_USR4){
						for (int i=0; i<glocal.n; i++){
							PHOTO_ST *st = glocal.photos + i;
							st->published = code == MENU_USR3;
							st->fpub->seticon (code == MENU_USR3 ? "published" : "notpublished");
						}
					}else if (code == MENU_USR5){
						// Build the index.html file in the photo directory
						SSTRING indexfile;
						indexfile.setfromf ("%s/index.html",dir);
						<call savefile>(indexfile.get(),false);
						<f dowrite>
							fprintf (fout,"<html>\n");
							fprintf (fout,"<body>\n");
						
							fprintf (fout,"<table border=0>\n");
							for (int i=0; i<glocal.files.getnb(); i+=3){
								fprintf (fout,"<tr>\n");
								for (int j=i; j<i+3 && j<glocal.files.getnb(); j++){
									const char *name = glocal.files.getitem(j)->get();
									fprintf (fout,"<td><a href=%s.jpg><img src=%s.th.jpg></a><br>"
										,name,name);
									<glocal>
										FILE *fout;
									</glocal>
									glocal.fout = fout;
									SSTRING txt;
									txt.setfromf ("%s/%s.txt",glocal.dir,name);
									<call loadfile>(txt.get(),true);
									<f missing>
									</f>
									<f oneline>
										fprintf (glocal.fout,"%s\n",line);
										return -1;
									</f>
									</call>
									fprintf (fout,"</td>\n");
								}
								fprintf (fout,"</tr>\n");
							}
							fprintf (fout,"</body>\n");
							fprintf (fout,"</html>\n");
							xconf_notice (MSG_U(I_INDEXDONE,"File %s was created")
								,fname);
							return 0;
						</f>
						</call>
					}
					if (must_reload){
						for (int i=0; i<glocal.n; i++){
							PHOTO_ST *st = glocal.photos + i;
							SSTRING txt;
							txt.setfromf ("%s/%s.txt",dir,glocal.files.getitem(i)->get());
							photo_loadfirstline (txt.get(),st->desc);
							st->desc.truncate(20);
						}
						glocal.dia.reload();
					}
				}
				delete [] glocal.photos;
			}
			free ((void*)dir);
		</f>
		</obj>
		fram.newdocument ();
		fram.loop();
		photo_deltmpdir();
		return 0;
	</f>
	</call>
}
</mod>