@@ -467,13 +467,14 @@ redata_fix_nl(redata_t *redata, int chunkno)

 }

 int

-redata_load(redata_t *redata, char *filename, int use_unsaved)

+redata_load(redata_t *redata, char *filename, int (*callback_question)(/*char *title, char *body, int nopts, char *opts[],void *userptr*/), void *userptr)

 {

         int fd,nread,totalread;

         int chunkno, avail;

         struct stat statbuf;

         rechunk_t *chunk;

         int i;

+        int reply;

         if(redata==NULL || filename==NULL)

                 return(-1); /* sanity check failed */

         redata_wipe(redata);

@@ -520,18 +521,20 @@ redata_load(redata_t *redata, char *filename, int use_unsaved)

                 redata_fix_nl(redata,chunkno);

         for(chunkno=0;chunkno<redata->sizechunks;chunkno++)

                 redata_whatin_refresh(redata,chunkno);

-        /* unsaved */

+        /* unsaved and other plugins */

         for(i=0;i<redata->sizeplugins;i++) {

-                if(use_unsaved) {

-                        /* apply missing changes and append new changes to unsaved */

-                        if(redata->plugins[i].postload!=NULL)

-                                redata->plugins[i].postload(redata,redata->plugins+i,filename);

-                } else {

-                        /* nuke existing unsaved (if exists) and prepare new unsaved */

-                        /* _trunc() fills itself redata->initialhash */

-                        if(redata->plugins[i].truncload!=NULL)

-                                redata->plugins[i].truncload(redata,redata->plugins+i,filename);

+                if(!redata->plugins[i].active)

+                        continue;

+                reply=-1;

+                if(redata->plugins[i].loadquestion!=NULL && callback_question!=NULL) {

+                        char *title, *body;

+                        int nopts;

+                        char **opts;

+                        if(redata->plugins[i].loadquestion(redata,redata->plugins+i,filename,&title,&body,&nopts,&opts)!=-1)

+                                reply=callback_question(title,body,nopts,opts,userptr);

                 }

+                if(redata->plugins[i].postload!=NULL)

+                        redata->plugins[i].postload(redata,redata->plugins+i,filename,reply);

         }

         /* all done */

         return(0);

@@ -13,6 +13,8 @@

 #include <limits.h>

+#define MAXPLUGINNAME 32

+

 typedef struct whatin_t {

         int nlcount;

 } whatin_t;

@@ -43,22 +45,19 @@ typedef struct undostack_t {

         char *buf;

 } undostack_t;

-#define PLUGIN_CHECKUSERCONFIRM 1 /* if check is Ok, confirm with user whether to postload or go inactive */

-

 typedef struct redata_plugin_t {

         int active;

+        char name[MAXPLUGINNAME];

         int (*unregister)(/*redata_t *redata, redata_plugin_t *plugin,char *filename*/);

-        /* checkload returns 0:Ok, 1:Not needed, -1: error, go inactive */

         int (*wipe)(/*redata_t *redata, redata_plugin_t *plugin,char *filename*/);

-        int (*checkload)(/*redata_t *redata, redata_plugin_t *plugin,char *filename*/);

-        int (*postload)(/*redata_t *redata, redata_plugin_t *plugin,char *filename*/);

-        int (*truncload)(/*redata_t *redata, redata_plugin_t *plugin,char *filename*/);

+        /* loadquestion returns -1 if no question needed */

+        int (*loadquestion)(/*redata_t *redata, redata_plugin_t *plugin,char *filename, char **title, char **body, int *nopts, char **opts[] */);

+        int (*postload)(/*redata_t *redata, redata_plugin_t *plugin,char *filename,int questionreply */);

         int (*postsave)(/*redata_t *redata, redata_plugin_t *plugin,char *oldfilename,char *newfilename*/);

         int (*add)(/*redata_t *redata, redata_plugin_t *plugin,undo_t *undo*/);

         int (*unadd)(/*redata_t *redata, redata_plugin_t *plugin,undo_t *undo*/);

         int (*commit)(/*redata_t *redata, redata_plugin_t *plugin,char *filename*/);

         void *userptr;

-        int flags;

 } redata_plugin_t;

 typedef struct redata_t {

@@ -77,7 +76,6 @@ typedef struct redata_t {

         redata_plugin_t plugins[1];

 } redata_t;

-#warning TODO: Make redata_xxx call the plugins

 redata_t *redata_init( int (*pluginregisterfn)(redata_t *redata, redata_plugin_t *slot), ...);

 void redata_free(redata_t *redata);

@@ -111,7 +109,7 @@ int redata_undo_inactivatelast(redata_t *redata, undostack_t *stack);

 int redata_undo_reactivatelast(redata_t *redata, undostack_t *stack);

 /* high level stuff */

-int redata_load(redata_t *redata, char *filename, int use_unsaved);

+int redata_load(redata_t *redata, char *filename, int (*callback_question)(/*char *title, char *body, int nopts, char *opts[],void *userptr*/), void *userptr);

 int redata_save(redata_t *redata, char *filename);

 int redata_op_add(redata_t *redata, long pos, char *buf, long buflen, undostack_t *fromhere);

@@ -28,6 +28,8 @@

+static int redata_unsaved_loadquestion(redata_t *redata, redata_plugin_t *slot,char *filename, char **title, char **body, int *nopts, char **opts[]);

+static int redata_unsaved_postload(redata_t *redata, redata_plugin_t *slot,char *filename,int questionreply);

 static int redata_unsaved_check_gen(redata_t *redata, redata_plugin_t *slot, char *filename);

 static char *unsaved_genname(char *filename, char *buf, int bufsize);

 static char *ptr_getlong(char *ptr,char *endptr,long *data);

@@ -46,15 +48,16 @@ redata_unsaved_register(redata_t *redata, redata_plugin_t *slot)

         memset(unsaved,0,sizeof(unsaved_t));

         unsaved->unsavedfd=-1;

         unsaved->sizebuf=unsaved->usedbuf=0;

+        strncpy(slot->name,"unsaved",sizeof(slot->name));

+        slot->name[sizeof(slot->name)-1]='\0';

         slot->unregister=redata_unsaved_unregister;

-        slot->checkload=redata_unsaved_check;

+        slot->loadquestion=redata_unsaved_loadquestion;

         slot->wipe=redata_unsaved_wipe;

-        slot->postload=redata_unsaved_loadappend;

-        slot->truncload=redata_unsaved_truncload;

+        slot->postload=redata_unsaved_postload;

         slot->postsave=redata_unsaved_trunc;

         slot->add=redata_unsaved_add;

         slot->unadd=redata_unsaved_unadd;

-        slot->flags=PLUGIN_CHECKUSERCONFIRM;

+        slot->commit=redata_unsaved_commit;

         return(0);

 }

@@ -484,6 +487,35 @@ redata_unsaved_commit(redata_t *redata, redata_plugin_t *slot,char *filename)

         return(0);

 }

+static int

+redata_unsaved_loadquestion(redata_t *redata, redata_plugin_t *slot,char *filename, char **title, char **body, int *nopts, char **opts[])

+{

+        static char mytitle[]={"Unsaved data from a previous session detected"};

+        static char mybody[]={"The file you're trying to load has some unsaved data from a previous session. I can recover the data. What do you want to do?"};

+        static char *myopts[]={"Recover unsaved data (safest option)","Don't use old unsaved data, delete old unsaved data (if you're sure what you're doing)"};

+        if(redata==NULL || slot==NULL || filename==NULL || title==NULL || body==NULL || nopts==NULL || opts==NULL)

+                return(-1); /* sanity check failed */

+        if(redata_unsaved_check(redata,slot,filename)==-1)

+                return(-1); /* no unsaved data on disk */

+        *title=mytitle;

+        *body=mybody;

+        *opts=myopts;

+        *nopts=2;

+        return(0);

+}

+

+static int

+redata_unsaved_postload(redata_t *redata, redata_plugin_t *slot,char *filename,int questionreply)

+{

+        /* questionreply is from loadquestion, specifically the selected element in the array "opts" */

+        if(questionreply==0) /* recover */

+                return(redata_unsaved_loadappend(redata, slot, filename));

+        else if(questionreply==1 || questionreply==-1) /* delete unsaved data */

+                return(redata_unsaved_truncload(redata, slot, filename));

+        return(-1);

+}

+

+

 static char *

 unsaved_genname(char *filename, char *buf, int bufsize)

 {

@@ -154,7 +154,7 @@ fprintf(stderr,"\ntest_newfile(%s%s%s,%s%s%s,%i,%i);\nResult: ",(filename!=NULL)

         redata_filehash(redata,filename,hash129_pre);

         free(mem),mem=NULL;

         /* load file */

-        if(redata_load(redata,filename,0)!=0) {

+        if(redata_load(redata,filename,NULL,NULL)!=0) {

                 unlink(filename);

                 return("couldn't load file");

         }

@@ -359,7 +359,7 @@ redata_save(redata,"test.redo");

                                 return("insuf. mem. for temp. buffer");

                         if(write_file(filename,mem,filesize)==-1)

                                 return("couldn't create temporary file");

-                        if(redata_load(redata,filename,0)!=0) {

+                        if(redata_load(redata,filename,NULL,NULL)!=0) {

                                 unlink(filename);

                                 return("couldn't load file");

                         }

@@ -43,7 +43,7 @@ main(int argc, char *argv[])

                 re_free(re),re=NULL;

                 return(2);

         }

-        if((redata_load(re->redata,re->filename,0))!=0)

+        if((redata_load(re->redata,re->filename,NULL,NULL))!=0)

                 re->flag_newfile=1;

         else

                 re->flag_newfile=0;