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

Diff for /Amaya/amaya/templates.c between versions 1.246 and 1.247

version 1.246, 2009/09/02 16:09:21 version 1.247, 2009/09/03 15:19:35
Line 1067  ThotBool RepeatButtonClicked (NotifyElem Line 1067  ThotBool RepeatButtonClicked (NotifyElem
       if (Template_CanInsertRepeatChild (repeatEl))        if (Template_CanInsertRepeatChild (repeatEl))
         {          {
           firstEl = TtaGetFirstChild (repeatEl);            firstEl = TtaGetFirstChild (repeatEl);
           listtypes = Template_GetListTypes (t, firstEl);            if (firstEl)
               listtypes = Template_GetListTypes (t, firstEl);
             else
               listtypes = Template_GetListTypes (t, repeatEl);
           if (listtypes)            if (listtypes)
             {              {
 #ifdef TEMPLATE_DEBUG  #ifdef TEMPLATE_DEBUG
Line 1778  ThotBool TemplateElementWillBeDeleted (N Line 1781  ThotBool TemplateElementWillBeDeleted (N
 {  {
 #ifdef TEMPLATES  #ifdef TEMPLATES
   Document       doc = event->document;    Document       doc = event->document;
   Element        elem = event->element;    Element        el = event->element;
   Element        xtElem, parent = NULL, sibling;    Element        xtEl, parent = NULL, sibling;
   ElementType    xtType, elType;    ElementType    xtType, elType;
   char          *type;  
   Declaration    dec;  
   SSchema        templateSSchema;    SSchema        templateSSchema;
   XTigerTemplate t;    XTigerTemplate t;
   ThotBool       selparent = FALSE;  
   
   if (event->info==1)    if (event->info==1)
     return FALSE;      return FALSE;
   
   if (!TtaGetDocumentAccessMode(event->document))    if (!TtaGetDocumentAccessMode(doc))
     return TRUE;      return TRUE;
     if (!IsTemplateInstanceDocument (doc))
       return FALSE; // If template or library, pass to specialized functions.
   
   templateSSchema = TtaGetSSchema ("Template", event->document);    templateSSchema = TtaGetSSchema ("Template", doc);
   if (templateSSchema == NULL)    if (templateSSchema == NULL)
     return FALSE; // let Thot do the job      return FALSE; // let Thot do the job
   
   t = GetXTigerDocTemplate(doc);    t = GetXTigerDocTemplate(doc);
   if (Template_IsTemplate(t)||Template_IsLibrary(t))    elType = TtaGetElementType (el);
     return FALSE; // If template or library, pass to specialized functions.    xtEl = GetFirstTemplateParentElement (el);
     if (elType.ElSSchema == templateSSchema &&
   xtElem = GetFirstTemplateParentElement(elem);        (elType.ElTypeNum == Template_EL_repeat ||
   if (xtElem)         elType.ElTypeNum == Template_EL_bag))
       {
         // clean up the content of the bag or repeat
         sibling = TtaGetFirstChild (el);
         xtEl = el;
         TtaOpenUndoSequence (doc, el, el, 0, 0);
         while (sibling)
           {
             el = sibling;
             TtaNextSibling (&sibling);
             TtaRegisterElementDelete (el, doc);
             TtaDeleteTree (el, doc);
           }
         if (elType.ElTypeNum == Template_EL_repeat)
           {
             // regenerate the minimum of instances
             parent = GetParentLine (xtEl, templateSSchema);
             InstantiateRepeat (t, xtEl, doc, parent, TRUE);
           }
         TtaCloseUndoSequence (doc);
         TtaSelectElement (doc, xtEl);
       }
     else if (xtEl)
     {      {
       xtType = TtaGetElementType(xtElem);        xtType = TtaGetElementType (xtEl);
       if (xtType.ElTypeNum==Template_EL_bag)        if (xtType.ElTypeNum==Template_EL_bag)
           return FALSE; // xt:bag always allow remove children.
         else
         {          {
           elType = TtaGetElementType(elem);            // look for the enclosing use
           if (elType.ElSSchema==templateSSchema &&            if (elType.ElSSchema != templateSSchema)
               (elType.ElTypeNum==Template_EL_useSimple ||  
                elType.ElTypeNum==Template_EL_useEl))  
             {              {
               // Remove element manually.                // check if the element is alone
               TtaOpenUndoSequence(doc, elem, elem, 0, 0);                sibling = el;
               TtaRegisterElementDelete(elem, doc);                TtaNextSibling (&sibling);
               TtaDeleteTree(elem, doc);                while (sibling == NULL)
               TtaCloseUndoSequence(doc);                  {
               return TRUE;                    // there is no next element
                     sibling = el;
                     TtaPreviousSibling (&sibling);
                     if (parent == xtEl)
                       break;
                     if (sibling == NULL)
                       {
                         el = parent;
                         parent = TtaGetParent (el);
                         sibling = el;
                         TtaNextSibling (&sibling);
                       }
                   }
                 if (sibling)
                   return TRUE; // cannot delete
             }              }
           else  
             return FALSE; // xt:bag always allow remove children.            xtEl = TtaGetParent (el);
         }            xtType = TtaGetElementType (xtEl);
       else if (xtType.ElTypeNum == Template_EL_useSimple ||            if (xtType.ElSSchema == templateSSchema &&
                xtType.ElTypeNum == Template_EL_useEl)                (xtType.ElTypeNum == Template_EL_repeat ||
         {                 xtType.ElTypeNum == Template_EL_bag))
           parent = TtaGetParent(elem);  
           if (xtElem != parent)  
             {              {
               type = GetAttributeStringValueFromNum (xtElem, Template_ATTR_currentType, NULL);                // delete the use within a bag or a repeat
               dec = Template_GetDeclaration(t, type);                TtaOpenUndoSequence (doc, el, el, 0, 0);
               TtaFreeMemory (type);                TtaRegisterElementDelete (el, doc);
                 TtaDeleteTree (el, doc);
               if (dec && dec->nature == XmlElementNat)  
                 // Can remove only if the current type is a target element.  
                 return FALSE;  
               else  
                 return TRUE;  
             }              }
         }            if (xtType.ElTypeNum == Template_EL_repeat)
       else if (xtType.ElTypeNum == Template_EL_repeat)  
         {  
           sibling = TtaGetSuccessor (elem);  
           if (sibling == NULL)  
             {              {
               // there is no next element                // regenerate the minimum of instances
               sibling = TtaGetPredecessor (elem);                parent = GetParentLine (xtEl, templateSSchema);
               if (sibling == NULL)                InstantiateRepeat (t, xtEl, doc, parent, TRUE);
                 selparent = TRUE;  
             }              }
           TtaRegisterElementDelete (elem, doc);            TtaCloseUndoSequence (doc);
           TtaDeleteTree (elem, doc);            TtaSelectElement (doc, xtEl);
           parent = GetParentLine (xtElem, templateSSchema);  
           InstantiateRepeat (t, xtElem, doc, parent, TRUE);  
           if (selparent)  
             // look for the new sibling  
             sibling = TtaGetFirstChild (parent);  
           if (sibling)  
             TtaSelectElement(doc, sibling);  
           else  
             TtaSelectElement(doc, parent);  
           return TRUE;  
         }          }
     }      }
     return TRUE; // don't let thot do something
   //TODO Test if current element is use or repeat.  
   // Because if an element is delete and it is the unique child of its parent,  
   // the parent intends to destroy itself.  
   
   return TRUE;  
 #else /* TEMPLATES */  #else /* TEMPLATES */
   return FALSE;    return FALSE;
 #endif /* TEMPLATES */  #endif /* TEMPLATES */
Line 2471  void Template_ModifyUnionElement(Documen Line 2482  void Template_ModifyUnionElement(Documen
   XTigerTemplate t = GetXTigerDocTemplate(doc);    XTigerTemplate t = GetXTigerDocTemplate(doc);
   SSchema        sstempl = TtaGetSSchema ("Template", doc);    SSchema        sstempl = TtaGetSSchema ("Template", doc);
   ElementType    unionType;    ElementType    unionType;
   char          *proposed, *checked, *name, *types=NULL;    char          *proposed, *checked, *name, *types = NULL;
   
   if (doc && unionEl && t && sstempl)    if (doc && unionEl && t && sstempl)
     {      {
Removed from v.1.246  
changed lines
  Added in v.1.247

Webmaster