swad-core/swad_syllabus.c

// swad_syllabus.c: syllabus

/*
    SWAD (Shared Workspace At a Distance),
    is a web platform developed at the University of Granada (Spain),
    and used to support university teaching.

    This file is part of SWAD core.
    Copyright (C) 1999-2024 Antonio Ca<EFBFBD>as Vargas

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as
    published by the Free Software Foundation, either version 3 of the
    License, or (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
/*****************************************************************************/
/********************************* Headers ***********************************/
/*****************************************************************************/

#define _GNU_SOURCE 		// For asprintf
#include <linux/limits.h>	// For PATH_MAX
#include <stddef.h>		// For NULL
#include <stdio.h>		// For asprintf
#include <stdlib.h>		// For free ()
#include <stdsoap2.h>		// For SOAP_OK and soap functions
#include <string.h>		// For string functions
#include <time.h>		// For time ()
#include <unistd.h>		// For SEEK_SET

#include "swad_action_list.h"
#include "swad_box.h"
#include "swad_changelog.h"
#include "swad_config.h"
#include "swad_database.h"
#include "swad_error.h"
#include "swad_form.h"
#include "swad_forum.h"
#include "swad_global.h"
#include "swad_HTML.h"
#include "swad_info_database.h"
#include "swad_parameter.h"
#include "swad_string.h"
#include "swad_xml.h"

/*****************************************************************************/
/***************************** Public constants ******************************/
/*****************************************************************************/

Syl_WhichSyllabus_t Syl_WhichSyllabus[Syl_NUM_WHICH_SYLLABUS] =
  {
   [Syl_NONE      ] = Syl_NONE,
   [Syl_LECTURES  ] = Syl_LECTURES,
   [Syl_PRACTICALS] = Syl_PRACTICALS
  };

/*****************************************************************************/
/************** External global variables from others modules ****************/
/*****************************************************************************/

extern struct Globals Gbl;

/*****************************************************************************/
/***************************** Private constants *****************************/
/*****************************************************************************/

#define Syl_MAX_LEVELS_SYLLABUS		  10

#define Syl_MAX_BYTES_ITEM_COD		(Syl_MAX_LEVELS_SYLLABUS * (10 + 1) - 1)

#define Syl_MAX_CHARS_TEXT_ITEM		(1024 - 1)	// 1023
#define Syl_MAX_BYTES_TEXT_ITEM		((Syl_MAX_CHARS_TEXT_ITEM + 1) * Str_MAX_BYTES_PER_CHAR - 1)	// 16383

#define Syl_WIDTH_NUM_SYLLABUS 20

static const char *ClassSyllabus[1 + Syl_MAX_LEVELS_SYLLABUS] =
  {
   [ 0] = "",
   [ 1] = "SYL1",
   [ 2] = "SYL2",
   [ 3] = "SYL3",
   [ 4] = "SYL3",
   [ 5] = "SYL3",
   [ 6] = "SYL3",
   [ 7] = "SYL3",
   [ 8] = "SYL3",
   [ 9] = "SYL3",
   [10] = "SYL3",
  };

/*****************************************************************************/
/******************************* Private types *******************************/
/*****************************************************************************/

struct ItemSyllabus
  {
   int Level;
   int CodItem[1 + Syl_MAX_LEVELS_SYLLABUS];
   bool HasChildren;
   char Text[Syl_MAX_BYTES_TEXT_ITEM + 1];
  };

/*****************************************************************************/
/***************************** Private variables *****************************/
/*****************************************************************************/

struct LstItemsSyllabus Syl_LstItemsSyllabus;

/*****************************************************************************/
/***************************** Private prototypes ****************************/
/*****************************************************************************/

static unsigned Syl_GetParItemNumber (void);

static void Syl_ShowSyllabus (struct Syl_Syllabus *Syllabus);
static void Syl_ShowRowSyllabus (struct Syl_Syllabus *Syllabus,unsigned NumItem,
                                 int Level,int *CodItem,const char *Text,bool NewItem);
static void Syl_PutFormItemSyllabus (struct Syl_Syllabus *Syllabus,
                                     bool NewItem,unsigned NumItem,int Level,int *CodItem,const char *Text);
static void Syl_PutParsSyllabus (void *Syllabus);

static void Syl_WriteNumItem (char *StrDst,FILE *FileTgt,int Level,int *CodItem);

static void Syl_ChangePlaceItemSyllabus (Syl_ChangePosItem_t UpOrDownPos);
static void Syl_ChangeLevelItemSyllabus (Syl_ChangeLevelItem_t IncreaseOrDecreaseLevel);

static void Syl_OpenSyllabusFile (const struct Syl_Syllabus *Syllabus,
                                  char PathFile[PATH_MAX + 1],
                                  FILE **XML);
static void Syl_CloseXMLFile (FILE **XML);

/*****************************************************************************/
/************************** Reset syllabus context ***************************/
/*****************************************************************************/

void Syl_ResetSyllabus (struct Syl_Syllabus *Syllabus)
  {
   Syllabus->PathDir[0] = '\0';
   Syllabus->NumItem = 0;
   Syllabus->ViewType = Vie_VIEW;
   Syllabus->WhichSyllabus = Syl_DEFAULT_WHICH_SYLLABUS;
  }

/*****************************************************************************/
/************* Get parameter about which syllabus I want to see **************/
/*****************************************************************************/

Syl_WhichSyllabus_t Syl_GetParWhichSyllabus (void)
  {
   /***** Get which syllabus I want to see *****/
   return (Syl_WhichSyllabus_t)
	  Par_GetParUnsignedLong ("WhichSyllabus",
				  0,
				  Syl_NUM_WHICH_SYLLABUS - 1,
				  (unsigned long) Syl_DEFAULT_WHICH_SYLLABUS);
  }

/*****************************************************************************/
/****************** Put parameter with type of syllabus **********************/
/*****************************************************************************/

void Syl_PutParWhichSyllabus (void *SyllabusSelected)
  {
   if (SyllabusSelected)
      if (*((Syl_WhichSyllabus_t *) SyllabusSelected) != Syl_NONE)
         Par_PutParUnsigned (NULL,"WhichSyllabus",
                             (unsigned) *((Syl_WhichSyllabus_t *) SyllabusSelected));
  }

/*****************************************************************************/
/************************ Write form to select syllabus **********************/
/*****************************************************************************/

void Syl_PutFormWhichSyllabus (Syl_WhichSyllabus_t WhichSyllabus)
  {
   extern const char *Txt_SYLLABUS_WHICH_SYLLABUS[Syl_NUM_WHICH_SYLLABUS];
   Syl_WhichSyllabus_t WhichSyl;

   /***** If no syllabus ==> nothing to do *****/
   switch (Gbl.Crs.Info.Type)
     {
      case Inf_LECTURES:
      case Inf_PRACTICALS:
	 break;
      default:	// Nothing to do
	 return;
     }

   /***** Form to select which syllabus I want to see (lectures/practicals) *****/
   Frm_BeginForm (ActSeeSyl);
      HTM_DIV_Begin ("class=\"SEL_BELOW_TITLE DAT_%s\"",The_GetSuffix ());
	 HTM_UL_Begin (NULL);

	 for (WhichSyl  = (Syl_WhichSyllabus_t) 1;
	      WhichSyl <= (Syl_WhichSyllabus_t) (Syl_NUM_WHICH_SYLLABUS - 1);
	      WhichSyl++)
	   {
	    HTM_LI_Begin (NULL);
	       HTM_LABEL_Begin (NULL);
		  HTM_INPUT_RADIO ("WhichSyllabus",
				   ((WhichSyl == WhichSyllabus) ? HTM_CHECKED :
								  HTM_NO_ATTR) | HTM_SUBMIT_ON_CLICK,
				   "value=\"%u\"",(unsigned) WhichSyl);
		  HTM_Txt (Txt_SYLLABUS_WHICH_SYLLABUS[WhichSyl]);
	       HTM_LABEL_End ();
	    HTM_LI_End ();
	   }
	 HTM_UL_End ();
      HTM_DIV_End ();
   Frm_EndForm ();
  }

/*****************************************************************************/
/************ Get parameter item number in edition of syllabus ***************/
/*****************************************************************************/

static unsigned Syl_GetParItemNumber (void)
  {
   return (unsigned) Par_GetParUnsignedLong ("NumI",
					     0,
					     UINT_MAX,
					     0);
  }

/*****************************************************************************/
/********************** Check if syllabus is not empty ***********************/
/*****************************************************************************/
// Return true if info available

bool Syl_CheckSyllabus (struct Syl_Syllabus *Syllabus,long CrsCod)
  {
   bool InfoAvailable;

   /***** Load syllabus from XML file to memory *****/
   Syl_LoadListItemsSyllabusIntoMemory (Syllabus,CrsCod);

   /***** Number of items > 0 ==> info available *****/
   InfoAvailable = (Syl_LstItemsSyllabus.NumItems != 0);

   /***** Free memory used to store items *****/
   Syl_FreeListItemsSyllabus ();

   return InfoAvailable;
  }

/*****************************************************************************/
/************** Load syllabus from file to memoruy and edit it ***************/
/*****************************************************************************/
// Return true if info available

bool Syl_CheckAndShowSyllabus (struct Syl_Syllabus *Syllabus)
  {
   /***** Load syllabus from XML file to memory *****/
   Syl_LoadListItemsSyllabusIntoMemory (Syllabus,Gbl.Hierarchy.Node[Hie_CRS].HieCod);

   switch (Gbl.Action.Act)
     {
      case ActEditorSyl:
      case ActDelItmSyl:
      case ActUp_IteSyl:
      case ActDwnIteSyl:
      case ActRgtIteSyl:
      case ActLftIteSyl:
      case ActInsIteSyl:
      case ActModIteSyl:
         Syllabus->ViewType = Vie_EDIT;
         break;
      default:
         Syllabus->ViewType = Vie_VIEW;
         break;
     }

   if (Syllabus->ViewType == Vie_EDIT ||
       Syl_LstItemsSyllabus.NumItems)
     {
      /***** Write the current syllabus *****/
      Syl_ShowSyllabus (Syllabus);
      return true;
     }

   return false;
  }

/*****************************************************************************/
/****************************** Edit a syllabus ******************************/
/*****************************************************************************/
// Return true if info available

void Syl_EditSyllabus (void)
  {
   extern const char *Hlp_COURSE_Syllabus_edit;
   extern const char *Txt_INFO_TITLE[Inf_NUM_TYPES];
   struct Syl_Syllabus Syllabus;

   /***** Reset syllabus context *****/
   Syl_ResetSyllabus (&Syllabus);

   /***** Get syllabus type *****/
   Syllabus.WhichSyllabus = Syl_GetParWhichSyllabus ();
   Gbl.Crs.Info.Type = (Syllabus.WhichSyllabus == Syl_LECTURES ? Inf_LECTURES :
							         Inf_PRACTICALS);

   /***** Begin box *****/
   Box_BoxBegin (Txt_INFO_TITLE[Gbl.Crs.Info.Type],
		 NULL,NULL,
		 Hlp_COURSE_Syllabus_edit,Box_NOT_CLOSABLE);

      /***** Edit syllabus *****/
      Syl_CheckAndShowSyllabus (&Syllabus);

   /***** End box *****/
   Box_BoxEnd ();
  }

/*****************************************************************************/
/*** Read from XML and load in memory a syllabus of lectures or practicals ***/
/*****************************************************************************/

void Syl_LoadListItemsSyllabusIntoMemory (struct Syl_Syllabus *Syllabus,
                                          long CrsCod)
  {
   char PathFile[PATH_MAX + 1];
   FILE *XML = NULL;	// XML file for syllabus
   long PostBeginList;
   unsigned NumItem = 0;
   int N;
   int CodItem[1 + Syl_MAX_LEVELS_SYLLABUS];	// To make numeration
   int Result;
   unsigned NumItemsWithChildren = 0;

   /* Path of the private directory for the XML file with the syllabus */
   snprintf (Syllabus->PathDir,sizeof (Syllabus->PathDir),"%s/%ld/%s",
	     Cfg_PATH_CRS_PRIVATE,CrsCod,
	     Syllabus->WhichSyllabus == Syl_LECTURES ? Cfg_SYLLABUS_FOLDER_LECTURES :
		                                       Cfg_SYLLABUS_FOLDER_PRACTICALS);

   /***** Open the file with the syllabus *****/
   Syl_OpenSyllabusFile (Syllabus,PathFile,&XML);

   /***** Go to the start of the list of items *****/
   if (!Str_FindStrInFile (XML,"<lista>",Str_NO_SKIP_HTML_COMMENTS))
      Err_WrongSyllabusFormatExit ();

   /***** Save the position of the start of the list *****/
   PostBeginList = ftell (XML);

   /***** Loop to count the number of items *****/
   for (Syl_LstItemsSyllabus.NumItems = 0;
	Str_FindStrInFile (XML,"<item",Str_NO_SKIP_HTML_COMMENTS);
	Syl_LstItemsSyllabus.NumItems++);

   /***** Allocate memory for the list of items *****/
   if ((Syl_LstItemsSyllabus.Lst = calloc (Syl_LstItemsSyllabus.NumItems + 1,
                                           sizeof (*Syl_LstItemsSyllabus.Lst))) == NULL)
      Err_NotEnoughMemoryExit ();

   /***** Return to the start of the list *****/
   fseek (XML,PostBeginList,SEEK_SET);

   for (N  = 1;
	N <= Syl_MAX_LEVELS_SYLLABUS;
	N++)
      CodItem[N] = 0;
   Syl_LstItemsSyllabus.NumLevels = 1;

   /***** If the syllabus is empty ==> initialize an item to be edited *****/
   if (Syl_LstItemsSyllabus.NumItems == 0)
     {
      /* Level of the item */
      Syl_LstItemsSyllabus.Lst[0].Level = 1;

      /* Code (numeration) of the item */
      CodItem[1] = 1;
      for (N = 1;
	   N <= Syl_MAX_LEVELS_SYLLABUS;
	   N++)
	 Syl_LstItemsSyllabus.Lst[0].CodItem[N] = CodItem[N];

      /* Text of the item  */
      Syl_LstItemsSyllabus.Lst[0].Text[0] = '\0';
     }
   else
      /***** Loop to read and store all items of the syllabus *****/
      for (NumItem = 0;
	   NumItem < Syl_LstItemsSyllabus.NumItems;
	   NumItem++)
	{
	 /* Go to the start of the item */
	 if (!Str_FindStrInFile (XML,"<item",Str_NO_SKIP_HTML_COMMENTS))
	    Err_WrongSyllabusFormatExit ();

	 /* Get the level */
	 Syl_LstItemsSyllabus.Lst[NumItem].Level = Syl_ReadLevelItemSyllabus (XML);
	 if (Syl_LstItemsSyllabus.Lst[NumItem].Level > Syl_LstItemsSyllabus.NumLevels)
	    Syl_LstItemsSyllabus.NumLevels = Syl_LstItemsSyllabus.Lst[NumItem].Level;

	 /* Set the code (number) of the item */
	 CodItem[Syl_LstItemsSyllabus.Lst[NumItem].Level]++;
	 for (N  = Syl_LstItemsSyllabus.Lst[NumItem].Level + 1;
	      N <= Syl_MAX_LEVELS_SYLLABUS;
	      N++)
	    CodItem[N] = 0;
	 for (N  = 1;
	      N <= Syl_MAX_LEVELS_SYLLABUS;
	      N++)
	    Syl_LstItemsSyllabus.Lst[NumItem].CodItem[N] = CodItem[N];

	 /* Get the text of the item */
	 Result = Str_ReadFileUntilBoundaryStr (XML,Syl_LstItemsSyllabus.Lst[NumItem].Text,
	                                        "</item>",strlen ("</item>"),
	                                        (unsigned long long) Syl_MAX_BYTES_TEXT_ITEM);
	 if (Result == 0) // Str too long
	   {
	    if (!Str_FindStrInFile (XML,"</item>",Str_NO_SKIP_HTML_COMMENTS)) // End the search
	       Err_WrongSyllabusFormatExit ();
	   }
	 else if (Result == -1)
	    Err_WrongSyllabusFormatExit ();
	}

   /***** Close the file with the syllabus *****/
   Syl_CloseXMLFile (&XML);

   /***** Initialize other fields in the list *****/
   if (Syl_LstItemsSyllabus.NumItems)
     {
      for (NumItem = 0;
	   NumItem < Syl_LstItemsSyllabus.NumItems - 1;
	   NumItem++)
	 if (Syl_LstItemsSyllabus.Lst[NumItem].Level < Syl_LstItemsSyllabus.Lst[NumItem + 1].Level)
	   {
	    Syl_LstItemsSyllabus.Lst[NumItem].HasChildren = true;
	    NumItemsWithChildren++;
	   }
	 else
	    Syl_LstItemsSyllabus.Lst[NumItem].HasChildren = false;
      Syl_LstItemsSyllabus.Lst[Syl_LstItemsSyllabus.NumItems - 1].HasChildren = false;
     }
   Syl_LstItemsSyllabus.NumItemsWithChildren = NumItemsWithChildren;
  }

/*****************************************************************************/
/*********************** Free list of items of a syllabus ********************/
/*****************************************************************************/

void Syl_FreeListItemsSyllabus (void)
  {
   if (Syl_LstItemsSyllabus.Lst)
     {
      free (Syl_LstItemsSyllabus.Lst);
      Syl_LstItemsSyllabus.Lst = NULL;
      Syl_LstItemsSyllabus.NumItems = 0;
     }
  }

/*****************************************************************************/
/************* Read the level of the current item in a syllabus **************/
/*****************************************************************************/
// XML file with the syllabus must be positioned after <item
// XML with the syllabus becomes positioned after <item nivel="x">

int Syl_ReadLevelItemSyllabus (FILE *XML)
  {
   int Level;
   char StrlLevel[11 + 1];

   if (!Str_FindStrInFile (XML,"nivel=\"",Str_NO_SKIP_HTML_COMMENTS))
      Err_WrongSyllabusFormatExit ();
   if (Str_ReadFileUntilBoundaryStr (XML,StrlLevel,"\"",1,
   	                             (unsigned long long) (11 + 1)) != 1)
      Err_WrongSyllabusFormatExit ();
   if (sscanf (StrlLevel,"%d",&Level) != 1)
      Err_WrongSyllabusFormatExit ();
   Str_FindStrInFile (XML,">",Str_NO_SKIP_HTML_COMMENTS);
   if (Level < 1)
      Level = 1;
   else if (Level > Syl_MAX_LEVELS_SYLLABUS)
      Level = Syl_MAX_LEVELS_SYLLABUS;
   return Level;
  }

/*****************************************************************************/
/***************** Show a syllabus of lectures or practicals *****************/
/*****************************************************************************/

static void Syl_ShowSyllabus (struct Syl_Syllabus *Syllabus)
  {
   extern const char *Hlp_COURSE_Syllabus_edit;
   extern const char *Txt_INFO_TITLE[Inf_NUM_TYPES];
   extern const char *Txt_Done;
   unsigned NumItem;
   int Col;
   static int NumButtons[Vie_NUM_VIEW_TYPES] =
     {
      [Vie_VIEW] = 0,
      [Vie_EDIT] = 5,
     };
   static Act_Action_t Inf_Actions[Inf_NUM_TYPES] =
     {
      [Inf_INFORMATION   ] = ActSeeCrsInf,
      [Inf_TEACHING_GUIDE] = ActSeeTchGui,
      [Inf_LECTURES      ] = ActSeeSyl,
      [Inf_PRACTICALS    ] = ActSeeSyl,
      [Inf_BIBLIOGRAPHY  ] = ActSeeBib,
      [Inf_FAQ           ] = ActSeeFAQ,
      [Inf_LINKS         ] = ActSeeCrsLnk,
      [Inf_ASSESSMENT    ] = ActSeeAss,
     };
   bool ShowRowInsertNewItem = (Gbl.Action.Act == ActInsIteSyl ||
                                Gbl.Action.Act == ActModIteSyl ||
				Gbl.Action.Act == ActRgtIteSyl ||
                                Gbl.Action.Act == ActLftIteSyl);

   /***** Begin table *****/
   HTM_TABLE_BeginWide ();

      /***** Set width of columns of the table *****/
      HTM_Txt ("<colgroup>");
	 for (Col = 0;
	      Col < NumButtons[Syllabus->ViewType];
	      Col++)
	    HTM_Txt ("<col width=\"12\" />");
	 for (Col  = 1;
	      Col <= Syl_LstItemsSyllabus.NumLevels;
	      Col++)
	    HTM_TxtF ("<col width=\"%d\" />",Col * Syl_WIDTH_NUM_SYLLABUS);
	 HTM_Txt ("<col width=\"*\" />");
      HTM_Txt ("</colgroup>");

      if (Syl_LstItemsSyllabus.NumItems)
	 /***** Loop writing all items of the syllabus *****/
	 for (NumItem = 0;
	      NumItem < Syl_LstItemsSyllabus.NumItems;
	      NumItem++)
	   {
	    Syl_ShowRowSyllabus (Syllabus,NumItem,
				 Syl_LstItemsSyllabus.Lst[NumItem].Level,
				 Syl_LstItemsSyllabus.Lst[NumItem].CodItem,
				 Syl_LstItemsSyllabus.Lst[NumItem].Text,false);
	    if (ShowRowInsertNewItem && NumItem == Syllabus->NumItem)
	       // Mostrar a new row where se puede insert a new item
	       Syl_ShowRowSyllabus (Syllabus,NumItem + 1,
				    Syl_LstItemsSyllabus.Lst[NumItem].Level,NULL,
				    "",true);
	   }
      else if (Syllabus->ViewType == Vie_EDIT)
	 /***** If the syllabus is empty ==>
		show form to add a iten to the end *****/
	 Syl_ShowRowSyllabus (Syllabus,0,
			      1,Syl_LstItemsSyllabus.Lst[0].CodItem,"",true);

   /***** End table *****/
   HTM_TABLE_End ();

   /***** Button to view *****/
   if (Syllabus->ViewType == Vie_EDIT)
     {
      Frm_BeginForm (Inf_Actions[Gbl.Crs.Info.Type]);
	 Syl_PutParWhichSyllabus (&Syllabus->WhichSyllabus);
	 Btn_PutConfirmButton (Txt_Done);
      Frm_EndForm ();
     }
  }

/*****************************************************************************/
/******** Write a row (item) of a syllabus of lectures or practicals *********/
/*****************************************************************************/

static void Syl_ShowRowSyllabus (struct Syl_Syllabus *Syllabus,unsigned NumItem,
                                 int Level,int *CodItem,const char *Text,bool NewItem)
  {
   extern const char *Txt_Movement_not_allowed;
   static int LastLevel = 0;
   char StrItemCod[Syl_MAX_LEVELS_SYLLABUS * (10 + 1)];
   struct MoveSubtrees Subtree;

   Subtree.ToGetUp.Ini   = Subtree.ToGetUp.End   = 0;
   Subtree.ToGetDown.Ini = Subtree.ToGetDown.End = 0;
   Subtree.MovAllowed = false;

   Syllabus->ParNumItem = NumItem;	// Used as parameter in forms

   if (!NewItem)	// If the item is new (not stored in file), it has no number
      Syl_WriteNumItem (StrItemCod,NULL,Level,CodItem);

   /***** Begin the row *****/
   HTM_TR_Begin (NULL);

      switch (Syllabus->ViewType)
        {
         case Vie_VIEW:
	    /***** Indent depending on the level *****/
	    if (Level > 1)
	      {
	       HTM_TD_Begin ("colspan=\"%d\" class=\"%s\"",
			     Level - 1,The_GetColorRows ());
	       HTM_TD_End ();
	      }

	    /***** Code of the item *****/
	    HTM_TD_Begin ("class=\"RT %s_%s %s\" style=\"width:%dpx;\"",
			  ClassSyllabus[Level],The_GetSuffix (),
			  The_GetColorRows (),Level * Syl_WIDTH_NUM_SYLLABUS);
	       if (Level == 1)
		  HTM_NBSP ();
	       HTM_TxtF ("%s&nbsp;",StrItemCod);
	    HTM_TD_End ();

	    /***** Text of the item *****/
	    HTM_TD_Begin ("colspan=\"%d\" class=\"LT %s_%s %s\"",
			  Syl_LstItemsSyllabus.NumLevels - Level + 1,
			  ClassSyllabus[Level],The_GetSuffix (),
			  The_GetColorRows ());
	       HTM_Txt (Text);
	    HTM_TD_End ();
            break;
         case Vie_EDIT:
	    if (NewItem)
	      {
	       HTM_TD_Begin ("colspan=\"5\" class=\"%s\"",
			     The_GetColorRows ());
	       HTM_TD_End ();
	      }
	    else
	      {
	       /***** Icon to remove the row *****/
	       HTM_TD_Begin ("class=\"BM %s\"",The_GetColorRows ());
		  if (Syl_LstItemsSyllabus.Lst[NumItem].HasChildren)
		     Ico_PutIconRemovalNotAllowed ();
		  else
		     Ico_PutContextualIconToRemove (ActDelItmSyl,NULL,
						    Syl_PutParsSyllabus,Syllabus);
	       HTM_TD_End ();

	       /***** Icon to get up an item *****/
	       Syl_CalculateUpSubtreeSyllabus (&Subtree,NumItem);
	       HTM_TD_Begin ("class=\"BM %s\"",The_GetColorRows ());
		  if (Subtree.MovAllowed)
		     Lay_PutContextualLinkOnlyIcon (ActUp_IteSyl,NULL,
						    Syl_PutParsSyllabus,Syllabus,
						    "arrow-up.svg",Ico_BLACK);
		  else
		     Ico_PutIconOff ("arrow-up.svg",Ico_BLACK,
				     Txt_Movement_not_allowed);
	       HTM_TD_End ();

	       /***** Icon to get down item *****/
	       Syl_CalculateDownSubtreeSyllabus (&Subtree,NumItem);
	       HTM_TD_Begin ("class=\"BM %s\"",The_GetColorRows ());
		  if (Subtree.MovAllowed)
		     Lay_PutContextualLinkOnlyIcon (ActDwnIteSyl,NULL,
						    Syl_PutParsSyllabus,Syllabus,
						    "arrow-down.svg",Ico_BLACK);
		  else
		     Ico_PutIconOff ("arrow-down.svg",Ico_BLACK,
				     Txt_Movement_not_allowed);
	       HTM_TD_End ();

	       /***** Icon to increase the level of an item *****/
	       HTM_TD_Begin ("class=\"BM %s\"",The_GetColorRows ());
		  if (Level > 1)
		     Lay_PutContextualLinkOnlyIcon (ActRgtIteSyl,NULL,
						    Syl_PutParsSyllabus,Syllabus,
						    "arrow-left.svg",Ico_BLACK);
		  else
		     Ico_PutIconOff ("arrow-left.svg",Ico_BLACK,
				     Txt_Movement_not_allowed);
	       HTM_TD_End ();

	       /***** Icon to decrease level item *****/
	       HTM_TD_Begin ("class=\"BM %s\"",The_GetColorRows ());
		  if (Level < LastLevel + 1 &&
		      Level < Syl_MAX_LEVELS_SYLLABUS)
		     Lay_PutContextualLinkOnlyIcon (ActLftIteSyl,NULL,
						    Syl_PutParsSyllabus,Syllabus,
						    "arrow-right.svg",Ico_BLACK);
		  else
		     Ico_PutIconOff ("arrow-right.svg",Ico_BLACK,
				     Txt_Movement_not_allowed);
	       HTM_TD_End ();

	       LastLevel = Level;
	      }

	    Syl_PutFormItemSyllabus (Syllabus,NewItem,NumItem,Level,CodItem,Text);
            break;
	 default:
	    Err_WrongTypeExit ();
	    break;
        }

   /***** End of the row *****/
   HTM_TR_End ();

   The_ChangeRowColor ();
  }

/*****************************************************************************/
/************** Write the syllabus into a temporary HTML file ****************/