[BACK]Return to templateInstantiate.c CVS log [TXT] [DIR] Up to [Public] / Amaya / amaya

Diff for /Amaya/amaya/templateInstantiate.c between versions 1.40 and 1.41

version 1.40, 2007/06/07 10:41:29 version 1.41, 2007/06/08 09:53:28
Line 12 Line 12
   
 #include "Elemlist.h"  #include "Elemlist.h"
   
   #include "AHTURLTools_f.h"
 #include "EDITimage_f.h"  #include "EDITimage_f.h"
 #include "HTMLactions_f.h"  #include "HTMLactions_f.h"
 #include "HTMLsave_f.h"  #include "HTMLsave_f.h"
Line 30 Line 31
   
 typedef struct _InstantiateCtxt  typedef struct _InstantiateCtxt
 {  {
         char *                  templatePath;          char         *templatePath;
         char *                  instancePath;          char         *instancePath;
         char *                  schemaName;          char         *schemaName;
     Document      doc;
         DocumentType    docType;          DocumentType    docType;
         ThotBool                dontReplace;          ThotBool                  dontReplace;
 } InstantiateCtxt;  } InstantiateCtxt;
 #endif /* TEMPLATES */  #endif /* TEMPLATES */
   
   
 /*----------------------------------------------------------------------  /*----------------------------------------------------------------------
   CreateInstance    CreateInstance
     basedoc is the displayed doc that launchs the creation of instance
   ----------------------------------------------------------------------*/    ----------------------------------------------------------------------*/
 void  CreateInstance(char *templatePath, char *instancePath)  void  CreateInstance(char *templatePath, char *instancePath, int basedoc)
 {  {
 #ifdef TEMPLATES  #ifdef TEMPLATES
   Document     doc = 0;    Document          doc = 0, newdoc = 0;
   DocumentType docType;    DocumentType      docType;
   ElementType  elType;    ElementType       elType;
   Element      root, title, text;    Element           root, title, text;
   char        *s;    char             *localFile, *s;
   int          alreadyOnDoc = 0;  
   ThotBool     alreadyViewing = FALSE;  
   
   XTigerTemplate t = GetXTigerTemplate(templatePath);    XTigerTemplate t = GetXTigerTemplate(templatePath);
   if (t == NULL)    if (t == NULL)
Line 60  void  CreateInstance(char *templatePath, Line 61  void  CreateInstance(char *templatePath,
       InitConfirm (doc, 1, TtaGetMessage (AMAYA, AM_BAD_TEMPLATE));        InitConfirm (doc, 1, TtaGetMessage (AMAYA, AM_BAD_TEMPLATE));
       return;        return;
     }      }
     // the template document
   doc = GetTemplateDocument (t);    doc = GetTemplateDocument (t);
   while (alreadyOnDoc < DocumentTableLength-1 && !alreadyViewing)    // localize the new created document
     {    if (DontReplaceOldDoc)
       alreadyOnDoc++;      newdoc = TtaGetNextDocumentIndex ();
       if (DocumentURLs[alreadyOnDoc])    else
         alreadyViewing = !strcmp (DocumentURLs[alreadyOnDoc],instancePath);      newdoc = basedoc;
     }  #ifdef IV
     localFile = GetLocalPath (newdoc, instancePath);
   #else
     localFile = TtaStrdup (instancePath);
   #endif
   if (!TtaPrepareUndo (doc))    if (!TtaPrepareUndo (doc))
     {      {
       TtaOpenUndoSequence (doc, NULL, NULL, 0, 0);        TtaOpenUndoSequence (doc, NULL, NULL, 0, 0);
Line 86  void  CreateInstance(char *templatePath, Line 90  void  CreateInstance(char *templatePath,
         docType = docXml;          docType = docXml;
       // update all links        // update all links
       SetRelativeURLs (doc, instancePath, "", FALSE, FALSE, FALSE);        SetRelativeURLs (doc, instancePath, "", FALSE, FALSE, FALSE);
         
         // prepare the new document view
         TtaExtractName (instancePath, DirectoryName, DocumentName);
         // save in the local path
       switch (docType)        switch (docType)
         {          {
         case docSVG:          case docSVG:
           TtaExportDocumentWithNewLineNumbers (doc, instancePath, "SVGT");            TtaExportDocumentWithNewLineNumbers (doc, localFile, "SVGT");
           break;            break;
         case docMath:          case docMath:
           TtaExportDocumentWithNewLineNumbers (doc, instancePath, "MathMLT");            TtaExportDocumentWithNewLineNumbers (doc, localFile, "MathMLT");
           break;            break;
         case docHTML:          case docHTML:
           // Initialize the document title            // Initialize the document title
Line 118  void  CreateInstance(char *templatePath, Line 125  void  CreateInstance(char *templatePath,
                 // Look for the first text child                  // Look for the first text child
                 TtaNextSibling (&text);                  TtaNextSibling (&text);
             }              }
           if (TtaGetDocumentProfile(doc)==L_Xhtml11 || TtaGetDocumentProfile(doc)==L_Basic)            if (TtaGetDocumentProfile(doc) == L_Xhtml11 ||
             TtaExportDocumentWithNewLineNumbers (doc, instancePath, "HTMLT11");                TtaGetDocumentProfile(doc) == L_Basic)
               TtaExportDocumentWithNewLineNumbers (doc, localFile, "HTMLT11");
           else            else
             TtaExportDocumentWithNewLineNumbers (doc, instancePath, "HTMLTX");              TtaExportDocumentWithNewLineNumbers (doc, localFile, "HTMLTX");
           break;            break;
         default:          default:
           TtaExportDocumentWithNewLineNumbers (doc, instancePath, NULL);            localFile = GetLocalPath (newdoc, instancePath);
             TtaExportDocumentWithNewLineNumbers (doc, localFile, NULL);
           break;            break;
         }          }
               
       TtaCloseUndoSequence (doc);        TtaCloseUndoSequence (doc);
       TtaUndoNoRedo (doc);        TtaUndoNoRedo (doc);
       TtaClearUndoHistory (doc);        TtaClearUndoHistory (doc);
     }        RemoveParsingErrors (doc);
   
   if (!alreadyViewing)  #ifdef IV
     {        GetAmayaDoc (instancePath, NULL, basedoc, basedoc, CE_INSTANCE,
       // Open the instance                     !DontReplaceOldDoc, NULL, NULL);
       TtaExtractName (instancePath, DirectoryName, DocumentName);        TtaSetDocumentModified (newdoc);
   #else
       CallbackDialogue (BaseDialog + OpenForm, INTEGER_DATA, (char *) 1);        CallbackDialogue (BaseDialog + OpenForm, INTEGER_DATA, (char *) 1);
   #endif
     }      }
   else    TtaFreeMemory (localFile);
     {  
       // Reload on the existing view  
       Reload (alreadyOnDoc, 0);  
     }  
   
     
   // Intend to fix access rights for templates.    // Intend to fix access rights for templates.
   Template_PrintRights(TtaGetMainRoot(doc));    Template_FixAccessRight (t, TtaGetMainRoot(doc), doc);
     
   TtaSetDisplayMode (doc, NoComputedDisplay);  
   Template_FixAccessRight(t, TtaGetMainRoot(doc), doc, TRUE);  
   TtaSetDisplayMode (doc, DisplayImmediately);  
     
   Template_PrintRights(TtaGetMainRoot(doc));  
   
 #endif /* TEMPLATES */  #endif /* TEMPLATES */
 }  }
   
 /*----------------------------------------------------------------------  /*----------------------------------------------------------------------
   ----------------------------------------------------------------------*/    ----------------------------------------------------------------------*/
 void InstantiateTemplate_callback (int newdoc, int status,  char *urlName, char *outputfile,  void InstantiateTemplate_callback (int newdoc, int status,  char *urlName,
                                    char *proxyName, AHTHeaders *http_headers, void * context)                                     char *outputfile,
                                      char *proxyName, AHTHeaders *http_headers,
                                      void * context)
 {  {
 #ifdef TEMPLATES  #ifdef TEMPLATES
         InstantiateCtxt *ctx = (InstantiateCtxt*)context;          InstantiateCtxt *ctx = (InstantiateCtxt*)context;
   
         DoInstanceTemplate (ctx->templatePath);          DoInstanceTemplate (ctx->templatePath);
   CreateInstance (ctx->templatePath, ctx->instancePath);    CreateInstance (ctx->templatePath, ctx->instancePath, ctx->doc);
   TtaFreeMemory (ctx->templatePath);    TtaFreeMemory (ctx->templatePath);
   TtaFreeMemory (ctx->instancePath);    TtaFreeMemory (ctx->instancePath);
   TtaFreeMemory (ctx);    TtaFreeMemory (ctx);
Line 187  void InstantiateTemplate (Document doc, Line 187  void InstantiateTemplate (Document doc,
       ctx->templatePath = TtaStrdup (templatename);        ctx->templatePath = TtaStrdup (templatename);
       ctx->instancePath = TtaStrdup (docname);        ctx->instancePath = TtaStrdup (docname);
       ctx->schemaName = GetSchemaFromDocType(docType);        ctx->schemaName = GetSchemaFromDocType(docType);
         ctx->doc = doc;
       ctx->docType = docType;        ctx->docType = docType;
                                   
       GetAmayaDoc (templatename, NULL, doc, doc, CE_MAKEBOOK, FALSE,         GetAmayaDoc (templatename, NULL, doc, doc, CE_MAKEBOOK, FALSE, 
                    (void (*)(int, int, char*, char*, char*, const AHTHeaders*, void*)) InstantiateTemplate_callback,                     (void (*)(int, int, char*, char*, char*,
                                const AHTHeaders*, void*)) InstantiateTemplate_callback,
                    (void *) ctx);                     (void *) ctx);
     }      }
         else          else
     {      {
       DoInstanceTemplate (templatename);        DoInstanceTemplate (templatename);
       CreateInstance (templatename, docname);        CreateInstance (templatename, docname, doc);
     }        }  
 #endif /* TEMPLATES */  #endif /* TEMPLATES */
 }  }
Line 470  Element Template_InsertUseChildren(Docum Line 472  Element Template_InsertUseChildren(Docum
   
   
 /*----------------------------------------------------------------------  /*----------------------------------------------------------------------
   Set access rights.  
   \param rec if true, set rights for all children  
   ----------------------------------------------------------------------*/  
 void Template_SetAccessRight(Element el, AccessRight right, Document doc, ThotBool rec)  
 {  
 #ifdef TEMPLATES  
   Element     child;  
     
   if (el && doc)  
     {  
       TtaSetAccessRight(el, right, doc);  
       if (rec)  
         {  
           child = TtaGetFirstChild(el);  
           while (child)  
             {  
               Template_SetAccessRight(child, right, doc, rec);  
               TtaNextSibling(&child);  
             }  
         }  
     }  
 #endif /* TEMPLATES */  
 }  
   
 /*----------------------------------------------------------------------  
   Dump access rights.  
   \param rec if true, set rights for all children  
   ----------------------------------------------------------------------*/  
 void Template_PrintRights(Element el)  
 {  
 #ifdef TEMPLATES  
 #ifdef AMAYA_DEBUG  
   ElementType elType;  
   Element     child;  
     
   static int  dec = 0;   
     
   elType = TtaGetElementType(el);  
   printf("PrintAccessRight ");  
   for(int i=0; i<dec; i++)  
     printf("  ");   
   printf("%s:%d:%s : ", TtaGetSSchemaName(elType.ElSSchema), elType.ElTypeNum, TtaGetElementTypeName(elType));  
     
   dec++;  
     
   switch(TtaGetAccessRight(el))  
   {  
   case ReadOnly:  
     printf("ReadOnly\n");  
     break;  
   case ReadWrite:  
       printf("ReadWrite\n");  
       break;  
   case Hidden:  
       printf("Hidden\n");  
       break;  
   case Inherited:  
       printf("Inherited\n");  
       break;  
   default:  
       printf("other\n");  
       break;  
   }  
   child = TtaGetFirstChild(el);  
   while (child)  
     {  
           Template_PrintRights(child);  
       TtaNextSibling(&child);  
     }  
   dec--;  
 #endif /* AMAYA_DEBUG */  
 #endif /* TEMPLATES */    
 }  
   
 /*----------------------------------------------------------------------  
   Fix access rights.    Fix access rights.
   \param rec if true, set rights for all children  
   ----------------------------------------------------------------------*/    ----------------------------------------------------------------------*/
 void Template_FixAccessRight(XTigerTemplate t, Element el, Document doc, ThotBool rec)  void Template_FixAccessRight (XTigerTemplate t, Element el, Document doc)
 {  {
 #ifdef TEMPLATES  #ifdef TEMPLATES
   ElementType elType;    ElementType elType;
Line 556  void Template_FixAccessRight(XTigerTempl Line 482  void Template_FixAccessRight(XTigerTempl
   char        currentType[MAX_LENGTH];    char        currentType[MAX_LENGTH];
   Declaration decl;    Declaration decl;
       
   static int  dec = 0;   
     
   if (t && el && doc)    if (t && el && doc)
     {      {
       elType = TtaGetElementType(el);        elType = TtaGetElementType(el);
               if (elType.ElSSchema == TtaGetSSchema ("Template", doc))
 #ifdef AMAYA_DEBUG  
       printf("FixAccessRight ");  
       for(int i=0; i<dec; i++)  
         printf("  ");   
       printf("%s:%d:%s : ", TtaGetSSchemaName(elType.ElSSchema), elType.ElTypeNum, TtaGetElementTypeName(elType));  
   
       dec++;  
 #endif /* AMAYA_DEBUG */  
       if (elType.ElSSchema == TtaGetSSchema("Template", doc))  
         {          {
           switch(elType.ElTypeNum)            switch (elType.ElTypeNum)
             {              {
             case Template_EL_TEXT_UNIT:              case Template_EL_TEXT_UNIT:
               TtaSetAccessRight( el, ReadWrite, doc);                //TtaSetAccessRight( el, ReadWrite, doc);
 #ifdef AMAYA_DEBUG                return;
               printf("ReadWrite");  
 #endif /* AMAYA_DEBUG */  
               break;  
             case Template_EL_useEl:              case Template_EL_useEl:
             case Template_EL_useSimple:              case Template_EL_useSimple:
               GiveAttributeStringValueFromNum(el, Template_ATTR_currentType,                GiveAttributeStringValueFromNum(el, Template_ATTR_currentType,
Line 591  void Template_FixAccessRight(XTigerTempl Line 503  void Template_FixAccessRight(XTigerTempl
                     {                      {
                       case SimpleTypeNat:                        case SimpleTypeNat:
                       case XmlElementNat:                        case XmlElementNat:
 #ifdef AMAYA_DEBUG                          TtaSetAccessRight (el, ReadWrite, doc);
                         printf("ReadWrite\n");                          return;
 #endif /* AMAYA_DEBUG */  
                         Template_SetAccessRight(el, ReadWrite, doc, TRUE);  
                         rec = FALSE;  
                         break;  
                       default:                        default:
 #ifdef AMAYA_DEBUG                          TtaSetAccessRight (el, ReadOnly, doc);
                         printf("ReadOnly\n");                           break;
 #endif /* AMAYA_DEBUG */  
                         TtaSetAccessRight(el, ReadOnly, doc);  
                         break;  
                     }                      }
                 }                  }
 #ifdef AMAYA_DEBUG  
               else  
                   printf("no decl\n");  
 #endif /* AMAYA_DEBUG */  
               break;                break;
             case Template_EL_bag:              case Template_EL_bag:
 #ifdef AMAYA_DEBUG  
               printf("ReadWrite\n");  
 #endif /* AMAYA_DEBUG */  
               TtaSetAccessRight(el, ReadWrite, doc);                TtaSetAccessRight(el, ReadWrite, doc);
               break;                break;
             default:              default:
 #ifdef AMAYA_DEBUG  
               printf("ReadOnly\n");  
 #endif /* AMAYA_DEBUG */  
               TtaSetAccessRight(el, ReadOnly, doc);                TtaSetAccessRight(el, ReadOnly, doc);
               break;                break;
             }              }
         }          }
 //      else (elType.ElSSchema == TtaGetSSchema("HTML", doc))  
 //      {  
 //          
 //      }  
       else  
         {  
 #ifdef AMAYA_DEBUG  
           printf("Inherited\n");  
 #endif /* AMAYA_DEBUG */  
           TtaSetAccessRight(el, Inherited, doc);  
         }  
   
       if (rec)        child = TtaGetFirstChild (el);
         // fix access right to children
         while (child)
         {          {
           child = TtaGetFirstChild(el);            Template_FixAccessRight (t, child, doc);
           while (child)            TtaNextSibling (&child);
             {  
               Template_FixAccessRight(t, child, doc, rec);  
               TtaNextSibling(&child);  
             }  
         }          }
       dec--;  
     }      }
 #endif /* TEMPLATES */  #endif /* TEMPLATES */
 }  }
Removed from v.1.40  
changed lines
  Added in v.1.41

Webmaster