Marown/swad-core
Marown
/
swad-core
mirror of https://github.com/acanas/swad-core.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Version19.173

This commit is contained in:
acanas 2020-04-11 12:47:27 +02:00
parent 3f72d4a829
commit e2d5383755
5 changed files with 242 additions and 221 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
swad_changelog.h
View File

@ -497,7 +497,7 @@ enscript -2 --landscape --color --file-align=2 --highlight --line-numbers -o - *
En OpenSWAD: En OpenSWAD:
ps2pdf source.ps destination.pdf ps2pdf source.ps destination.pdf
*/ */
#define Log_PLATFORM_VERSION "SWAD 19.172.1 (2020-04-11)" #define Log_PLATFORM_VERSION "SWAD 19.173 (2020-04-11)"
#define CSS_FILE "swad19.146.css" #define CSS_FILE "swad19.146.css"
#define JS_FILE "swad19.172.1.js" #define JS_FILE "swad19.172.1.js"
/* /*
@ -548,7 +548,8 @@ Funci
// TODO: Oresti Baños: cambiar ojos por candados en descriptores para prohibir/permitir y dejar los ojos para poder elegir descriptores // TODO: Oresti Baños: cambiar ojos por candados en descriptores para prohibir/permitir y dejar los ojos para poder elegir descriptores
// TODO: Integrar pull requests con traducciones del alemán del usuario eruedin en GitHub // TODO: Integrar pull requests con traducciones del alemán del usuario eruedin en GitHub
Version 19.172.1: Apr 11, 2020 Fix bug in MathJax. (? lines) Version 19.173: Apr 11, 2020 Code refactoring in timeline. (285165 lines)
Version 19.172.1: Apr 11, 2020 Fix bug in MathJax. (285144 lines)
Version 19.172: Apr 11, 2020 Code refactoring in timeline. (285139 lines) Version 19.172: Apr 11, 2020 Code refactoring in timeline. (285139 lines)
Version 19.171: Apr 10, 2020 Code refactoring in surveys. (285010 lines) Version 19.171: Apr 10, 2020 Code refactoring in surveys. (285010 lines)
Version 19.170: Apr 09, 2020 Code refactoring in projects. (284941 lines) Version 19.170: Apr 09, 2020 Code refactoring in projects. (284941 lines)

1
swad_global.h
View File

@ -507,7 +507,6 @@ struct Globals
} ZIP; } ZIP;
} FileBrowser; // Struct used for a file browser } FileBrowser; // Struct used for a file browser
struct Msg_Messages Msg; struct Msg_Messages Msg;
struct TT_Timetable Timetable;
struct struct
{ {
struct DateTime DateIni; // TODO: Remove in future versions struct DateTime DateIni; // TODO: Remove in future versions

14
swad_record.c
View File

@ -1256,6 +1256,7 @@ static void Rec_ShowRecordOneTchCrs (void)
{ {
extern const char *Hlp_USERS_Teachers_timetable; extern const char *Hlp_USERS_Teachers_timetable;
extern const char *Txt_TIMETABLE_TYPES[TT_NUM_TIMETABLE_TYPES]; extern const char *Txt_TIMETABLE_TYPES[TT_NUM_TIMETABLE_TYPES];
struct TT_Timetable Timetable;
char Width[Cns_MAX_DECIMAL_DIGITS_UINT + 2 + 1]; char Width[Cns_MAX_DECIMAL_DIGITS_UINT + 2 + 1];
bool ShowOfficeHours; bool ShowOfficeHours;
@ -1304,11 +1305,11 @@ static void Rec_ShowRecordOneTchCrs (void)
if (ShowOfficeHours) if (ShowOfficeHours)
{ {
HTM_DIV_Begin ("class=\"REC_RIGHT\""); HTM_DIV_Begin ("class=\"REC_RIGHT\"");
Gbl.Timetable.Type = TT_TUTORING_TIMETABLE; Timetable.Type = TT_TUTORING_TIMETABLE;
Box_BoxBegin (Width,Txt_TIMETABLE_TYPES[Gbl.Timetable.Type], Box_BoxBegin (Width,Txt_TIMETABLE_TYPES[Timetable.Type],
NULL,NULL, NULL,NULL,
Hlp_USERS_Teachers_timetable,Box_NOT_CLOSABLE); Hlp_USERS_Teachers_timetable,Box_NOT_CLOSABLE);
TT_ShowTimeTable (Gbl.Usrs.Other.UsrDat.UsrCod); TT_ShowTimeTable (&Timetable,Gbl.Usrs.Other.UsrDat.UsrCod);
Box_BoxEnd (); Box_BoxEnd ();
HTM_DIV_End (); HTM_DIV_End ();
} }
@ -1337,6 +1338,7 @@ static void Rec_ListRecordsTchs (Rec_SharedRecordViewType_t TypeOfView)
{ {
extern const char *Hlp_USERS_Teachers_timetable; extern const char *Hlp_USERS_Teachers_timetable;
extern const char *Txt_TIMETABLE_TYPES[TT_NUM_TIMETABLE_TYPES]; extern const char *Txt_TIMETABLE_TYPES[TT_NUM_TIMETABLE_TYPES];
struct TT_Timetable Timetable;
unsigned NumUsr = 0; unsigned NumUsr = 0;
const char *Ptr; const char *Ptr;
struct UsrData UsrDat; struct UsrData UsrDat;
@ -1426,11 +1428,11 @@ static void Rec_ListRecordsTchs (Rec_SharedRecordViewType_t TypeOfView)
if (ShowOfficeHours) if (ShowOfficeHours)
{ {
HTM_DIV_Begin ("class=\"REC_RIGHT\""); HTM_DIV_Begin ("class=\"REC_RIGHT\"");
Gbl.Timetable.Type = TT_TUTORING_TIMETABLE; Timetable.Type = TT_TUTORING_TIMETABLE;
Box_BoxBegin (Width,Txt_TIMETABLE_TYPES[Gbl.Timetable.Type], Box_BoxBegin (Width,Txt_TIMETABLE_TYPES[Timetable.Type],
NULL,NULL, NULL,NULL,
Hlp_USERS_Teachers_timetable,Box_NOT_CLOSABLE); Hlp_USERS_Teachers_timetable,Box_NOT_CLOSABLE);
TT_ShowTimeTable (UsrDat.UsrCod); TT_ShowTimeTable (&Timetable,UsrDat.UsrCod);
Box_BoxEnd (); Box_BoxEnd ();
HTM_DIV_End (); HTM_DIV_End ();
} }

441
swad_timetable.c
View File

@ -124,34 +124,39 @@ static const unsigned TT_MinutesPerInterval[TT_NUM_RESOLUTIONS] =
/***************************** Private prototypes ***************************/ /***************************** Private prototypes ***************************/
/*****************************************************************************/ /*****************************************************************************/
static void TT_TimeTableConfigureIntervalsAndAllocateTimeTable (void); static void TT_TimeTableConfigureIntervalsAndAllocateTimeTable (struct TT_Timetable *Timetable);
static void TT_FreeTimeTable (void); static void TT_FreeTimeTable (void);
static void TT_ShowTimeTableGrpsSelected (void); static void TT_ShowTimeTableGrpsSelected (void);
static void TT_GetParamsTimeTable (void); static void TT_GetParamsTimeTable (struct TT_Timetable *Timetable);
static void TT_PutContextualIcons (void *Timetable); static void TT_PutContextualIcons (void *Timetable);
static void TT_PutFormToSelectWhichGroupsToShow (void); static void TT_PutFormToSelectWhichGroupsToShow (const struct TT_Timetable *Timetable);
static void TT_PutIconToViewCrsTT (__attribute__((unused)) void *Args); static void TT_PutIconToViewCrsTT (__attribute__((unused)) void *Args);
static void TT_PutIconToViewMyTT (__attribute__((unused)) void *Args); static void TT_PutIconToViewMyTT (__attribute__((unused)) void *Args);
static void TT_WriteCrsTimeTableIntoDB (long CrsCod); static void TT_WriteCrsTimeTableIntoDB (const struct TT_Timetable *Timetable,
static void TT_WriteTutTimeTableIntoDB (long UsrCod); long CrsCod);
static void TT_FillTimeTableFromDB (long UsrCod); static void TT_WriteTutTimeTableIntoDB (const struct TT_Timetable *Timetable,
long UsrCod);
static void TT_FillTimeTableFromDB (struct TT_Timetable *Timetable,
long UsrCod);
static void TT_CalculateRangeCell (unsigned StartTimeSeconds, static void TT_CalculateRangeCell (unsigned StartTimeSeconds,
unsigned EndTimeSeconds, unsigned EndTimeSeconds,
struct TT_Range *Range); struct TT_Range *Range);
static unsigned TT_CalculateMinutesPerInterval (unsigned Seconds); static unsigned TT_CalculateMinutesPerInterval (unsigned Seconds);
static void TT_ModifTimeTable (void); static void TT_ModifTimeTable (struct TT_Timetable *Timetable);
static void TT_DrawTimeTable (void); static void TT_DrawTimeTable (const struct TT_Timetable *Timetable);
static void TT_TimeTableDrawAdjustRow (void); static void TT_TimeTableDrawAdjustRow (void);
static void TT_TimeTableDrawDaysCells (void); static void TT_TimeTableDrawDaysCells (void);
static void TT_TimeTableDrawHourCell (unsigned Hour,unsigned Min,const char *Align); static void TT_TimeTableDrawHourCell (unsigned Hour,unsigned Min,const char *Align);
static unsigned TT_CalculateColsToDrawInCell (bool TopCall, static unsigned TT_CalculateColsToDrawInCell (const struct TT_Timetable *Timetable,
bool TopCall,
unsigned Weekday,unsigned Interval); unsigned Weekday,unsigned Interval);
static void TT_DrawCellAlignTimeTable (void); static void TT_DrawCellAlignTimeTable (void);
static void TT_TimeTableDrawCell (unsigned Weekday,unsigned Interval,unsigned Column,unsigned ColSpan, static void TT_TimeTableDrawCell (const struct TT_Timetable *Timetable,
unsigned Weekday,unsigned Interval,unsigned Column,unsigned ColSpan,
long CrsCod,TT_IntervalType_t IntervalType,TT_ClassType_t ClassType, long CrsCod,TT_IntervalType_t IntervalType,TT_ClassType_t ClassType,
unsigned DurationNumIntervals,long GrpCod,const char *Info); unsigned DurationNumIntervals,long GrpCod,const char *Info);
@ -159,42 +164,42 @@ static void TT_TimeTableDrawCell (unsigned Weekday,unsigned Interval,unsigned Co
/******************** Create internal timetable in memory ********************/ /******************** Create internal timetable in memory ********************/
/*****************************************************************************/ /*****************************************************************************/
static void TT_TimeTableConfigureIntervalsAndAllocateTimeTable (void) static void TT_TimeTableConfigureIntervalsAndAllocateTimeTable (struct TT_Timetable *Timetable)
{ {
unsigned Weekday; unsigned Weekday;
if (Gbl.Timetable.Config.Range.Hours.End > if (Timetable->Config.Range.Hours.End >
Gbl.Timetable.Config.Range.Hours.Start) Timetable->Config.Range.Hours.Start)
{ {
/***** Configuration of timetable depending on hours and resolution *****/ /***** Configuration of timetable depending on hours and resolution *****/
Gbl.Timetable.Config.HoursPerDay = Gbl.Timetable.Config.Range.Hours.End - Timetable->Config.HoursPerDay = Timetable->Config.Range.Hours.End -
Gbl.Timetable.Config.Range.Hours.Start; // From start hour to end hour Timetable->Config.Range.Hours.Start; // From start hour to end hour
Gbl.Timetable.Config.SecondsPerInterval = Gbl.Timetable.Config.Range.MinutesPerInterval * Timetable->Config.SecondsPerInterval = Timetable->Config.Range.MinutesPerInterval *
TT_SECONDS_PER_MINUTE; TT_SECONDS_PER_MINUTE;
Gbl.Timetable.Config.IntervalsPerHour = TT_MINUTES_PER_HOUR / Timetable->Config.IntervalsPerHour = TT_MINUTES_PER_HOUR /
Gbl.Timetable.Config.Range.MinutesPerInterval; Timetable->Config.Range.MinutesPerInterval;
Gbl.Timetable.Config.IntervalsPerDay = Gbl.Timetable.Config.IntervalsPerHour * Timetable->Config.IntervalsPerDay = Timetable->Config.IntervalsPerHour *
Gbl.Timetable.Config.HoursPerDay; Timetable->Config.HoursPerDay;
Gbl.Timetable.Config.IntervalsBeforeStartHour = Gbl.Timetable.Config.IntervalsPerHour * Timetable->Config.IntervalsBeforeStartHour = Timetable->Config.IntervalsPerHour *
Gbl.Timetable.Config.Range.Hours.Start; Timetable->Config.Range.Hours.Start;
/***** Allocate memory for timetable *****/ /***** Allocate memory for timetable *****/
for (Weekday = 0; for (Weekday = 0;
Weekday < TT_DAYS_PER_WEEK; Weekday < TT_DAYS_PER_WEEK;
Weekday++) Weekday++)
if ((TT_TimeTable[Weekday] = (struct TT_Cell *) if ((TT_TimeTable[Weekday] = (struct TT_Cell *)
malloc (Gbl.Timetable.Config.IntervalsPerDay * malloc (Timetable->Config.IntervalsPerDay *
sizeof (struct TT_Cell))) == NULL) sizeof (struct TT_Cell))) == NULL)
Lay_ShowErrorAndExit ("Error allocating memory for timetable."); Lay_ShowErrorAndExit ("Error allocating memory for timetable.");
} }
else else
{ {
/***** Table is empty *****/ /***** Table is empty *****/
Gbl.Timetable.Config.HoursPerDay = 0; Timetable->Config.HoursPerDay = 0;
Gbl.Timetable.Config.SecondsPerInterval = 0; Timetable->Config.SecondsPerInterval = 0;
Gbl.Timetable.Config.IntervalsPerHour = 0; Timetable->Config.IntervalsPerHour = 0;
Gbl.Timetable.Config.IntervalsPerDay = 0; Timetable->Config.IntervalsPerDay = 0;
Gbl.Timetable.Config.IntervalsBeforeStartHour = 0; Timetable->Config.IntervalsBeforeStartHour = 0;
/***** Clear timetable in order to not try to free it *****/ /***** Clear timetable in order to not try to free it *****/
for (Weekday = 0; for (Weekday = 0;
@ -249,7 +254,7 @@ static void TT_ShowTimeTableGrpsSelected (void)
/******************** Get paramaters for timetable editing *******************/ /******************** Get paramaters for timetable editing *******************/
/*****************************************************************************/ /*****************************************************************************/
static void TT_GetParamsTimeTable (void) static void TT_GetParamsTimeTable (struct TT_Timetable *Timetable)
{ {
char StrClassType[TT_MAX_BYTES_STR_CLASS_TYPE + 1]; char StrClassType[TT_MAX_BYTES_STR_CLASS_TYPE + 1];
char StrDuration[TT_MAX_BYTES_STR_DURATION + 1]; char StrDuration[TT_MAX_BYTES_STR_DURATION + 1];
@ -257,48 +262,48 @@ static void TT_GetParamsTimeTable (void)
unsigned Minutes; unsigned Minutes;
/***** Get day (0: monday, 1: tuesday,..., 6: sunday *****/ /***** Get day (0: monday, 1: tuesday,..., 6: sunday *****/
Gbl.Timetable.Weekday = (unsigned) Timetable->Weekday = (unsigned)
Par_GetParToUnsignedLong ("TTDay", Par_GetParToUnsignedLong ("TTDay",
0, 0,
TT_DAYS_PER_WEEK - 1, TT_DAYS_PER_WEEK - 1,
0); 0);
/***** Get hour *****/ /***** Get hour *****/
Gbl.Timetable.Interval = (unsigned) Timetable->Interval = (unsigned)
Par_GetParToUnsignedLong ("TTInt", Par_GetParToUnsignedLong ("TTInt",
0, 0,
Gbl.Timetable.Config.IntervalsPerDay - 1, Timetable->Config.IntervalsPerDay - 1,
0); 0);
/***** Get number of column *****/ /***** Get number of column *****/
Gbl.Timetable.Column = (unsigned) Timetable->Column = (unsigned)
Par_GetParToUnsignedLong ("TTCol", Par_GetParToUnsignedLong ("TTCol",
0, 0,
TT_MAX_COLUMNS_PER_CELL - 1, TT_MAX_COLUMNS_PER_CELL - 1,
0); 0);
/***** Get class type *****/ /***** Get class type *****/
Par_GetParToText ("TTTyp",StrClassType,TT_MAX_BYTES_STR_CLASS_TYPE); Par_GetParToText ("TTTyp",StrClassType,TT_MAX_BYTES_STR_CLASS_TYPE);
for (Gbl.Timetable.ClassType = (TT_ClassType_t) 0; for (Timetable->ClassType = (TT_ClassType_t) 0;
Gbl.Timetable.ClassType <= (TT_ClassType_t) (TT_NUM_CLASS_TYPES - 1); Timetable->ClassType <= (TT_ClassType_t) (TT_NUM_CLASS_TYPES - 1);
Gbl.Timetable.ClassType++) Timetable->ClassType++)
if (!strcmp (StrClassType,TT_ClassTypeDB[Gbl.Timetable.ClassType])) if (!strcmp (StrClassType,TT_ClassTypeDB[Timetable->ClassType]))
break; break;
if (Gbl.Timetable.ClassType > (TT_ClassType_t) (TT_NUM_CLASS_TYPES - 1)) if (Timetable->ClassType > (TT_ClassType_t) (TT_NUM_CLASS_TYPES - 1))
Lay_ShowErrorAndExit ("Type of timetable cell is missing."); Lay_ShowErrorAndExit ("Type of timetable cell is missing.");
/***** Get class duration *****/ /***** Get class duration *****/
Par_GetParToText ("TTDur",StrDuration,TT_MAX_BYTES_STR_DURATION); Par_GetParToText ("TTDur",StrDuration,TT_MAX_BYTES_STR_DURATION);
if (sscanf (StrDuration,"%u:%u",&Hours,&Minutes) != 2) if (sscanf (StrDuration,"%u:%u",&Hours,&Minutes) != 2)
Lay_ShowErrorAndExit ("Duration is missing."); Lay_ShowErrorAndExit ("Duration is missing.");
Gbl.Timetable.DurationIntervals = Hours * Gbl.Timetable.Config.IntervalsPerHour + Timetable->DurationIntervals = Hours * Timetable->Config.IntervalsPerHour +
Minutes / Gbl.Timetable.Config.Range.MinutesPerInterval; Minutes / Timetable->Config.Range.MinutesPerInterval;
/***** Get group code *****/ /***** Get group code *****/
Gbl.Timetable.GrpCod = Par_GetParToLong ("TTGrp"); Timetable->GrpCod = Par_GetParToLong ("TTGrp");
/***** Get info *****/ /***** Get info *****/
Par_GetParToText ("TTInf",Gbl.Timetable.Info,TT_MAX_BYTES_INFO); Par_GetParToText ("TTInf",Timetable->Info,TT_MAX_BYTES_INFO);
} }
/*****************************************************************************/ /*****************************************************************************/
@ -322,6 +327,7 @@ void TT_ShowClassTimeTable (void)
[TT_MY_TIMETABLE ] = ActChgMyTT1stDay, [TT_MY_TIMETABLE ] = ActChgMyTT1stDay,
[TT_TUTORING_TIMETABLE] = ActUnk, [TT_TUTORING_TIMETABLE] = ActUnk,
}; };
struct TT_Timetable Timetable;
bool PrintView = (Gbl.Action.Act == ActPrnCrsTT || bool PrintView = (Gbl.Action.Act == ActPrnCrsTT ||
Gbl.Action.Act == ActPrnMyTT);; Gbl.Action.Act == ActPrnMyTT);;
Grp_WhichGroups_t WhichGroups; Grp_WhichGroups_t WhichGroups;
@ -332,42 +338,42 @@ void TT_ShowClassTimeTable (void)
case ActSeeCrsTT: case ActSeeCrsTT:
case ActPrnCrsTT: case ActPrnCrsTT:
case ActChgCrsTT1stDay: case ActChgCrsTT1stDay:
Gbl.Timetable.Type = TT_COURSE_TIMETABLE; Timetable.Type = TT_COURSE_TIMETABLE;
break; break;
case ActSeeMyTT: case ActSeeMyTT:
case ActPrnMyTT: case ActPrnMyTT:
case ActChgMyTT1stDay: case ActChgMyTT1stDay:
Gbl.Timetable.Type = TT_MY_TIMETABLE; Timetable.Type = TT_MY_TIMETABLE;
break; break;
default: default:
Lay_ShowErrorAndExit ("Wrong action."); Lay_ShowErrorAndExit ("Wrong action.");
} }
Gbl.Timetable.ContextualIcons.PutIconEditCrsTT = (Gbl.Timetable.Type == TT_COURSE_TIMETABLE && Timetable.ContextualIcons.PutIconEditCrsTT = (Timetable.Type == TT_COURSE_TIMETABLE &&
!PrintView && !PrintView &&
Gbl.Usrs.Me.Role.Logged >= Rol_TCH); Gbl.Usrs.Me.Role.Logged >= Rol_TCH);
Gbl.Timetable.ContextualIcons.PutIconEditOfficeHours = (Gbl.Timetable.Type == TT_MY_TIMETABLE && Timetable.ContextualIcons.PutIconEditOfficeHours = (Timetable.Type == TT_MY_TIMETABLE &&
!PrintView && !PrintView &&
(Gbl.Usrs.Me.Role.Available & (1 << Rol_TCH))); (Gbl.Usrs.Me.Role.Available & (1 << Rol_TCH)));
Gbl.Timetable.ContextualIcons.PutIconPrint = !PrintView; Timetable.ContextualIcons.PutIconPrint = !PrintView;
/***** Get whether to show only my groups or all groups *****/ /***** Get whether to show only my groups or all groups *****/
Grp_GetParamWhichGroups (); Grp_GetParamWhichGroups ();
/***** Begin box *****/ /***** Begin box *****/
if (Gbl.Timetable.ContextualIcons.PutIconEditCrsTT || if (Timetable.ContextualIcons.PutIconEditCrsTT ||
Gbl.Timetable.ContextualIcons.PutIconEditOfficeHours || Timetable.ContextualIcons.PutIconEditOfficeHours ||
Gbl.Timetable.ContextualIcons.PutIconPrint) Timetable.ContextualIcons.PutIconPrint)
Box_BoxBegin ("100%",Txt_TIMETABLE_TYPES[Gbl.Timetable.Type], Box_BoxBegin ("100%",Txt_TIMETABLE_TYPES[Timetable.Type],
TT_PutContextualIcons,&Gbl.Timetable, TT_PutContextualIcons,&Timetable,
Help[Gbl.Timetable.Type],Box_NOT_CLOSABLE); Help[Timetable.Type],Box_NOT_CLOSABLE);
else else
Box_BoxBegin ("100%",Txt_TIMETABLE_TYPES[Gbl.Timetable.Type], Box_BoxBegin ("100%",Txt_TIMETABLE_TYPES[Timetable.Type],
NULL,NULL, NULL,NULL,
Help[Gbl.Timetable.Type],Box_NOT_CLOSABLE); Help[Timetable.Type],Box_NOT_CLOSABLE);
/***** Start time table drawing *****/ /***** Start time table drawing *****/
if (Gbl.Timetable.Type == TT_COURSE_TIMETABLE) if (Timetable.Type == TT_COURSE_TIMETABLE)
Lay_WriteHeaderClassPhoto (PrintView,false, Lay_WriteHeaderClassPhoto (PrintView,false,
Gbl.Hierarchy.Ins.InsCod,Gbl.Hierarchy.Deg.DegCod,Gbl.Hierarchy.Crs.CrsCod); Gbl.Hierarchy.Ins.InsCod,Gbl.Hierarchy.Deg.DegCod,Gbl.Hierarchy.Crs.CrsCod);
@ -380,21 +386,21 @@ void TT_ShowClassTimeTable (void)
Set_StartSettingsHead (); Set_StartSettingsHead ();
/* Select whether show only my groups or all groups */ /* Select whether show only my groups or all groups */
if ( Gbl.Timetable.Type == TT_MY_TIMETABLE || if ( Timetable.Type == TT_MY_TIMETABLE ||
(Gbl.Timetable.Type == TT_COURSE_TIMETABLE && (Timetable.Type == TT_COURSE_TIMETABLE &&
Gbl.Crs.Grps.NumGrps)) Gbl.Crs.Grps.NumGrps))
TT_PutFormToSelectWhichGroupsToShow (); TT_PutFormToSelectWhichGroupsToShow (&Timetable);
/* Show form to change first day of week */ /* Show form to change first day of week */
WhichGroups = Grp_GetParamWhichGroups (); WhichGroups = Grp_GetParamWhichGroups ();
Cal_ShowFormToSelFirstDayOfWeek (ActChgTT1stDay[Gbl.Timetable.Type], Cal_ShowFormToSelFirstDayOfWeek (ActChgTT1stDay[Timetable.Type],
Grp_PutParamWhichGroups,&WhichGroups); Grp_PutParamWhichGroups,&WhichGroups);
Set_EndSettingsHead (); Set_EndSettingsHead ();
} }
/***** Show the time table *****/ /***** Show the time table *****/
TT_ShowTimeTable (Gbl.Usrs.Me.UsrDat.UsrCod); TT_ShowTimeTable (&Timetable,Gbl.Usrs.Me.UsrDat.UsrCod);
/***** End box *****/ /***** End box *****/
Box_BoxEnd (); Box_BoxEnd ();
@ -431,7 +437,7 @@ static void TT_PutContextualIcons (void *Timetable)
/***************** Put form to select which groups to show *******************/ /***************** Put form to select which groups to show *******************/
/*****************************************************************************/ /*****************************************************************************/
static void TT_PutFormToSelectWhichGroupsToShow (void) static void TT_PutFormToSelectWhichGroupsToShow (const struct TT_Timetable *Timetable)
{ {
static const Act_Action_t ActSeeTT[TT_NUM_TIMETABLE_TYPES] = static const Act_Action_t ActSeeTT[TT_NUM_TIMETABLE_TYPES] =
{ {
@ -440,7 +446,7 @@ static void TT_PutFormToSelectWhichGroupsToShow (void)
[TT_TUTORING_TIMETABLE] = ActUnk, [TT_TUTORING_TIMETABLE] = ActUnk,
}; };
Grp_ShowFormToSelWhichGrps (ActSeeTT[Gbl.Timetable.Type], Grp_ShowFormToSelWhichGrps (ActSeeTT[Timetable->Type],
NULL,NULL); NULL,NULL);
} }
@ -452,13 +458,14 @@ void TT_EditCrsTimeTable (void)
{ {
extern const char *Hlp_COURSE_Timetable; extern const char *Hlp_COURSE_Timetable;
extern const char *Txt_TIMETABLE_TYPES[TT_NUM_TIMETABLE_TYPES]; extern const char *Txt_TIMETABLE_TYPES[TT_NUM_TIMETABLE_TYPES];
struct TT_Timetable Timetable;
/***** Editable time table *****/ /***** Editable time table *****/
Gbl.Timetable.Type = TT_COURSE_TIMETABLE; Timetable.Type = TT_COURSE_TIMETABLE;
Box_BoxBegin ("100%",Txt_TIMETABLE_TYPES[Gbl.Timetable.Type], Box_BoxBegin ("100%",Txt_TIMETABLE_TYPES[Timetable.Type],
TT_PutIconToViewCrsTT,NULL, TT_PutIconToViewCrsTT,NULL,
Hlp_COURSE_Timetable,Box_NOT_CLOSABLE); Hlp_COURSE_Timetable,Box_NOT_CLOSABLE);
TT_ShowTimeTable (Gbl.Usrs.Me.UsrDat.UsrCod); TT_ShowTimeTable (&Timetable,Gbl.Usrs.Me.UsrDat.UsrCod);
Box_BoxEnd (); Box_BoxEnd ();
} }
@ -470,13 +477,14 @@ void TT_EditMyTutTimeTable (void)
{ {
extern const char *Hlp_PROFILE_Timetable; extern const char *Hlp_PROFILE_Timetable;
extern const char *Txt_TIMETABLE_TYPES[TT_NUM_TIMETABLE_TYPES]; extern const char *Txt_TIMETABLE_TYPES[TT_NUM_TIMETABLE_TYPES];
struct TT_Timetable Timetable;
/***** Time table *****/ /***** Time table *****/
Gbl.Timetable.Type = TT_TUTORING_TIMETABLE; Timetable.Type = TT_TUTORING_TIMETABLE;
Box_BoxBegin ("100%",Txt_TIMETABLE_TYPES[Gbl.Timetable.Type], Box_BoxBegin ("100%",Txt_TIMETABLE_TYPES[Timetable.Type],
TT_PutIconToViewMyTT,NULL, TT_PutIconToViewMyTT,NULL,
Hlp_PROFILE_Timetable,Box_NOT_CLOSABLE); Hlp_PROFILE_Timetable,Box_NOT_CLOSABLE);
TT_ShowTimeTable (Gbl.Usrs.Me.UsrDat.UsrCod); TT_ShowTimeTable (&Timetable,Gbl.Usrs.Me.UsrDat.UsrCod);
Box_BoxEnd (); Box_BoxEnd ();
} }
@ -504,74 +512,74 @@ static void TT_PutIconToViewMyTT (__attribute__((unused)) void *Args)
/*********** Show course timetable or tutor timetable of a teacher ***********/ /*********** Show course timetable or tutor timetable of a teacher ***********/
/*****************************************************************************/ /*****************************************************************************/
void TT_ShowTimeTable (long UsrCod) void TT_ShowTimeTable (struct TT_Timetable *Timetable,long UsrCod)
{ {
extern const char *Txt_The_timetable_is_empty; extern const char *Txt_The_timetable_is_empty;
/***** Set type of view depending on current action *****/ /***** Set type of view depending on current action *****/
Gbl.Timetable.View = TT_CRS_VIEW; Timetable->View = TT_CRS_VIEW;
switch (Gbl.Action.Act) switch (Gbl.Action.Act)
{ {
case ActSeeCrsTT: case ActPrnCrsTT: case ActChgCrsTT1stDay: case ActSeeCrsTT: case ActPrnCrsTT: case ActChgCrsTT1stDay:
case ActSeeMyTT: case ActPrnMyTT: case ActChgMyTT1stDay: case ActSeeMyTT: case ActPrnMyTT: case ActChgMyTT1stDay:
Gbl.Timetable.View = TT_CRS_VIEW; Timetable->View = TT_CRS_VIEW;
break; break;
case ActSeeRecOneTch: case ActSeeRecSevTch: case ActSeeRecOneTch: case ActSeeRecSevTch:
Gbl.Timetable.View = TT_TUT_VIEW; Timetable->View = TT_TUT_VIEW;
break; break;
case ActEdiCrsTT: case ActChgCrsTT: case ActEdiCrsTT: case ActChgCrsTT:
Gbl.Timetable.View = TT_CRS_EDIT; Timetable->View = TT_CRS_EDIT;
break; break;
case ActEdiTut: case ActChgTut: case ActEdiTut: case ActChgTut:
Gbl.Timetable.View = TT_TUT_EDIT; Timetable->View = TT_TUT_EDIT;
break; break;
} }
/***** If editing ==> configure and allocate timetable *****/ /***** If editing ==> configure and allocate timetable *****/
if (Gbl.Timetable.View == TT_CRS_EDIT || if (Timetable->View == TT_CRS_EDIT ||
Gbl.Timetable.View == TT_TUT_EDIT) Timetable->View == TT_TUT_EDIT)
{ {
Gbl.Timetable.Config.Range.Hours.Start = TT_START_HOUR; // Day starts at this hour Timetable->Config.Range.Hours.Start = TT_START_HOUR; // Day starts at this hour
Gbl.Timetable.Config.Range.Hours.End = TT_END_HOUR; // Day ends at this hour Timetable->Config.Range.Hours.End = TT_END_HOUR; // Day ends at this hour
Gbl.Timetable.Config.Range.MinutesPerInterval = TT_MinutesPerInterval[0]; // The smallest interval Timetable->Config.Range.MinutesPerInterval = TT_MinutesPerInterval[0]; // The smallest interval
TT_TimeTableConfigureIntervalsAndAllocateTimeTable (); TT_TimeTableConfigureIntervalsAndAllocateTimeTable (Timetable);
} }
/* If viewing (not editing) ==> /* If viewing (not editing) ==>
configure and allocate memory when table is read from database */ configure and allocate memory when table is read from database */
/***** Fill internal timetable with the timetable from database *****/ /***** Fill internal timetable with the timetable from database *****/
TT_FillTimeTableFromDB (UsrCod); TT_FillTimeTableFromDB (Timetable,UsrCod);
/***** If timetable must be modified... *****/ /***** If timetable must be modified... *****/
if (Gbl.Action.Act == ActChgCrsTT || if (Gbl.Action.Act == ActChgCrsTT ||
Gbl.Action.Act == ActChgTut) Gbl.Action.Act == ActChgTut)
{ {
/* Get parameters for time table editing */ /* Get parameters for time table editing */
TT_GetParamsTimeTable (); TT_GetParamsTimeTable (Timetable);
/* Modify timetable in memory */ /* Modify timetable in memory */
TT_ModifTimeTable (); TT_ModifTimeTable (Timetable);
/* Write a new timetable in database */ /* Write a new timetable in database */
switch (Gbl.Timetable.Type) switch (Timetable->Type)
{ {
case TT_COURSE_TIMETABLE: case TT_COURSE_TIMETABLE:
TT_WriteCrsTimeTableIntoDB (Gbl.Hierarchy.Crs.CrsCod); TT_WriteCrsTimeTableIntoDB (Timetable,Gbl.Hierarchy.Crs.CrsCod);
break; break;
case TT_TUTORING_TIMETABLE: case TT_TUTORING_TIMETABLE:
TT_WriteTutTimeTableIntoDB (UsrCod); TT_WriteTutTimeTableIntoDB (Timetable,UsrCod);
break; break;
default: default:
break; break;
} }
/* Get a new table from database */ /* Get a new table from database */
TT_FillTimeTableFromDB (UsrCod); TT_FillTimeTableFromDB (Timetable,UsrCod);
} }
/***** Draw timetable *****/ /***** Draw timetable *****/
if (Gbl.Timetable.Config.HoursPerDay) if (Timetable->Config.HoursPerDay)
TT_DrawTimeTable (); TT_DrawTimeTable (Timetable);
else else
Ale_ShowAlert (Ale_INFO,Txt_The_timetable_is_empty); Ale_ShowAlert (Ale_INFO,Txt_The_timetable_is_empty);
@ -583,7 +591,8 @@ void TT_ShowTimeTable (long UsrCod)
/******************* Write course timetable into database ********************/ /******************* Write course timetable into database ********************/
/*****************************************************************************/ /*****************************************************************************/
static void TT_WriteCrsTimeTableIntoDB (long CrsCod) static void TT_WriteCrsTimeTableIntoDB (const struct TT_Timetable *Timetable,
long CrsCod)
{ {
unsigned Weekday; unsigned Weekday;
unsigned Interval; unsigned Interval;
@ -600,11 +609,11 @@ static void TT_WriteCrsTimeTableIntoDB (long CrsCod)
for (Weekday = 0; for (Weekday = 0;
Weekday < TT_DAYS_PER_WEEK; Weekday < TT_DAYS_PER_WEEK;
Weekday++) Weekday++)
for (Interval = 0, Hour = Gbl.Timetable.Config.Range.Hours.Start, Min = 0; for (Interval = 0, Hour = Timetable->Config.Range.Hours.Start, Min = 0;
Interval < Gbl.Timetable.Config.IntervalsPerDay; Interval < Timetable->Config.IntervalsPerDay;
Interval++, Interval++,
Hour += (Min + Gbl.Timetable.Config.Range.MinutesPerInterval) / TT_SECONDS_PER_MINUTE, Hour += (Min + Timetable->Config.Range.MinutesPerInterval) / TT_SECONDS_PER_MINUTE,
Min = (Min + Gbl.Timetable.Config.Range.MinutesPerInterval) % TT_SECONDS_PER_MINUTE) Min = (Min + Timetable->Config.Range.MinutesPerInterval) % TT_SECONDS_PER_MINUTE)
for (Column = 0; for (Column = 0;
Column < TT_MAX_COLUMNS_PER_CELL; Column < TT_MAX_COLUMNS_PER_CELL;
Column++) Column++)
@ -622,7 +631,7 @@ static void TT_WriteCrsTimeTableIntoDB (long CrsCod)
Weekday, Weekday,
Hour,Min, Hour,Min,
TT_TimeTable[Weekday][Interval].Columns[Column].DurationIntervals * TT_TimeTable[Weekday][Interval].Columns[Column].DurationIntervals *
Gbl.Timetable.Config.SecondsPerInterval, Timetable->Config.SecondsPerInterval,
TT_ClassTypeDB[TT_TimeTable[Weekday][Interval].Columns[Column].ClassType], TT_ClassTypeDB[TT_TimeTable[Weekday][Interval].Columns[Column].ClassType],
TT_TimeTable[Weekday][Interval].Columns[Column].Info); TT_TimeTable[Weekday][Interval].Columns[Column].Info);
} }
@ -631,7 +640,8 @@ static void TT_WriteCrsTimeTableIntoDB (long CrsCod)
/********************* Write tutor timetable into database *******************/ /********************* Write tutor timetable into database *******************/
/*****************************************************************************/ /*****************************************************************************/
static void TT_WriteTutTimeTableIntoDB (long UsrCod) static void TT_WriteTutTimeTableIntoDB (const struct TT_Timetable *Timetable,
long UsrCod)
{ {
unsigned Weekday; unsigned Weekday;
unsigned Interval; unsigned Interval;
@ -648,11 +658,11 @@ static void TT_WriteTutTimeTableIntoDB (long UsrCod)
for (Weekday = 0; for (Weekday = 0;
Weekday < TT_DAYS_PER_WEEK; Weekday < TT_DAYS_PER_WEEK;
Weekday++) Weekday++)
for (Interval = 0, Hour = Gbl.Timetable.Config.Range.Hours.Start, Min = 0; for (Interval = 0, Hour = Timetable->Config.Range.Hours.Start, Min = 0;
Interval < Gbl.Timetable.Config.IntervalsPerDay; Interval < Timetable->Config.IntervalsPerDay;
Interval++, Interval++,
Hour += (Min + Gbl.Timetable.Config.Range.MinutesPerInterval) / TT_SECONDS_PER_MINUTE, Hour += (Min + Timetable->Config.Range.MinutesPerInterval) / TT_SECONDS_PER_MINUTE,
Min = (Min + Gbl.Timetable.Config.Range.MinutesPerInterval) % TT_SECONDS_PER_MINUTE) Min = (Min + Timetable->Config.Range.MinutesPerInterval) % TT_SECONDS_PER_MINUTE)
for (Column = 0; for (Column = 0;
Column < TT_MAX_COLUMNS_PER_CELL; Column < TT_MAX_COLUMNS_PER_CELL;
Column++) Column++)
@ -667,7 +677,7 @@ static void TT_WriteTutTimeTableIntoDB (long UsrCod)
Weekday, Weekday,
Hour,Min, Hour,Min,
TT_TimeTable[Weekday][Interval].Columns[Column].DurationIntervals * TT_TimeTable[Weekday][Interval].Columns[Column].DurationIntervals *
Gbl.Timetable.Config.SecondsPerInterval, Timetable->Config.SecondsPerInterval,
TT_TimeTable[Weekday][Interval].Columns[Column].Info); TT_TimeTable[Weekday][Interval].Columns[Column].Info);
} }
@ -675,7 +685,8 @@ static void TT_WriteTutTimeTableIntoDB (long UsrCod)
/********** Create an internal table with timetable from database ************/ /********** Create an internal table with timetable from database ************/
/*****************************************************************************/ /*****************************************************************************/
static void TT_FillTimeTableFromDB (long UsrCod) static void TT_FillTimeTableFromDB (struct TT_Timetable *Timetable,
long UsrCod)
{ {
extern const char *Txt_Incomplete_timetable_for_lack_of_space; extern const char *Txt_Incomplete_timetable_for_lack_of_space;
MYSQL_RES *mysql_res; MYSQL_RES *mysql_res;
@ -698,7 +709,7 @@ static void TT_FillTimeTableFromDB (long UsrCod)
bool Found; bool Found;
/***** Get timetable from database *****/ /***** Get timetable from database *****/
switch (Gbl.Timetable.Type) switch (Timetable->Type)
{ {
case TT_MY_TIMETABLE: case TT_MY_TIMETABLE:
switch (Gbl.Crs.Grps.WhichGrps) switch (Gbl.Crs.Grps.WhichGrps)
@ -828,13 +839,13 @@ static void TT_FillTimeTableFromDB (long UsrCod)
/***** If viewing (not editing) ==> /***** If viewing (not editing) ==>
calculate range of hours and resolution *****/ calculate range of hours and resolution *****/
if (Gbl.Timetable.View == TT_CRS_VIEW || if (Timetable->View == TT_CRS_VIEW ||
Gbl.Timetable.View == TT_TUT_VIEW) Timetable->View == TT_TUT_VIEW)
{ {
/* Initialize hours and resolution for timetable */ /* Initialize hours and resolution for timetable */
Gbl.Timetable.Config.Range.Hours.Start = TT_END_HOUR; // Initialized to maximum hour Timetable->Config.Range.Hours.Start = TT_END_HOUR; // Initialized to maximum hour
Gbl.Timetable.Config.Range.Hours.End = TT_START_HOUR; // Initialized to minimum hour Timetable->Config.Range.Hours.End = TT_START_HOUR; // Initialized to minimum hour
Gbl.Timetable.Config.Range.MinutesPerInterval = TT_MinutesPerInterval[TT_NUM_RESOLUTIONS - 1]; // The longest interval Timetable->Config.Range.MinutesPerInterval = TT_MinutesPerInterval[TT_NUM_RESOLUTIONS - 1]; // The longest interval
for (NumRow = 0; for (NumRow = 0;
NumRow < NumRows; NumRow < NumRows;
@ -853,29 +864,29 @@ static void TT_FillTimeTableFromDB (long UsrCod)
/* Compute hours and resolution */ /* Compute hours and resolution */
TT_CalculateRangeCell (StartTimeSeconds,EndTimeSeconds,&RangeCell); TT_CalculateRangeCell (StartTimeSeconds,EndTimeSeconds,&RangeCell);
if (RangeCell.Hours.Start < Gbl.Timetable.Config.Range.Hours.Start) if (RangeCell.Hours.Start < Timetable->Config.Range.Hours.Start)
Gbl.Timetable.Config.Range.Hours.Start = RangeCell.Hours.Start; Timetable->Config.Range.Hours.Start = RangeCell.Hours.Start;
if (RangeCell.Hours.End > Gbl.Timetable.Config.Range.Hours.End) if (RangeCell.Hours.End > Timetable->Config.Range.Hours.End)
Gbl.Timetable.Config.Range.Hours.End = RangeCell.Hours.End; Timetable->Config.Range.Hours.End = RangeCell.Hours.End;
if (RangeCell.MinutesPerInterval < Gbl.Timetable.Config.Range.MinutesPerInterval) if (RangeCell.MinutesPerInterval < Timetable->Config.Range.MinutesPerInterval)
Gbl.Timetable.Config.Range.MinutesPerInterval = RangeCell.MinutesPerInterval; Timetable->Config.Range.MinutesPerInterval = RangeCell.MinutesPerInterval;
} }
mysql_data_seek (mysql_res,0); mysql_data_seek (mysql_res,0);
/***** Configure and allocate timetable *****/ /***** Configure and allocate timetable *****/
TT_TimeTableConfigureIntervalsAndAllocateTimeTable (); TT_TimeTableConfigureIntervalsAndAllocateTimeTable (Timetable);
} }
/***** Build the table by filling it from database *****/ /***** Build the table by filling it from database *****/
if (Gbl.Timetable.Config.HoursPerDay) if (Timetable->Config.HoursPerDay)
{ {
/***** Initialize timetable to all free *****/ /***** Initialize timetable to all free *****/
for (Weekday = 0; for (Weekday = 0;
Weekday < TT_DAYS_PER_WEEK; Weekday < TT_DAYS_PER_WEEK;
Weekday++) Weekday++)
for (Interval = 0; for (Interval = 0;
Interval < Gbl.Timetable.Config.IntervalsPerDay; Interval < Timetable->Config.IntervalsPerDay;
Interval++) Interval++)
{ {
TT_TimeTable[Weekday][Interval].NumColumns = 0; TT_TimeTable[Weekday][Interval].NumColumns = 0;
@ -910,20 +921,20 @@ static void TT_FillTimeTableFromDB (long UsrCod)
if (sscanf (row[1],"%u",&StartTimeSeconds) != 1) if (sscanf (row[1],"%u",&StartTimeSeconds) != 1)
Lay_ShowErrorAndExit ("Wrong start time in timetable."); Lay_ShowErrorAndExit ("Wrong start time in timetable.");
Interval = StartTimeSeconds / Interval = StartTimeSeconds /
Gbl.Timetable.Config.SecondsPerInterval; Timetable->Config.SecondsPerInterval;
if (Interval < Gbl.Timetable.Config.IntervalsBeforeStartHour) if (Interval < Timetable->Config.IntervalsBeforeStartHour)
Lay_ShowErrorAndExit ("Wrong start time in timetable."); Lay_ShowErrorAndExit ("Wrong start time in timetable.");
Interval -= Gbl.Timetable.Config.IntervalsBeforeStartHour; Interval -= Timetable->Config.IntervalsBeforeStartHour;
/* Duration formatted as seconds (row[2]) /* Duration formatted as seconds (row[2])
--> Duration in number of intervals */ --> Duration in number of intervals */
if (sscanf (row[2],"%u",&DurationSeconds) != 1) if (sscanf (row[2],"%u",&DurationSeconds) != 1)
Lay_ShowErrorAndExit ("Wrong duration in timetable."); Lay_ShowErrorAndExit ("Wrong duration in timetable.");
DurationNumIntervals = DurationSeconds / DurationNumIntervals = DurationSeconds /
Gbl.Timetable.Config.SecondsPerInterval; Timetable->Config.SecondsPerInterval;
/* Type of class (row[4]) */ /* Type of class (row[4]) */
switch (Gbl.Timetable.Type) switch (Timetable->Type)
{ {
case TT_COURSE_TIMETABLE: case TT_COURSE_TIMETABLE:
case TT_MY_TIMETABLE: case TT_MY_TIMETABLE:
@ -965,7 +976,7 @@ static void TT_FillTimeTableFromDB (long UsrCod)
TimeTableHasSpaceForThisClass = true; TimeTableHasSpaceForThisClass = true;
for (i = Interval + 1; for (i = Interval + 1;
i < Interval + DurationNumIntervals && i < Interval + DurationNumIntervals &&
i < Gbl.Timetable.Config.IntervalsPerDay; i < Timetable->Config.IntervalsPerDay;
i++) i++)
if (TT_TimeTable[Weekday][i].Columns[FirstFreeColumn].IntervalType != TT_FREE_INTERVAL) if (TT_TimeTable[Weekday][i].Columns[FirstFreeColumn].IntervalType != TT_FREE_INTERVAL)
{ {
@ -980,7 +991,7 @@ static void TT_FillTimeTableFromDB (long UsrCod)
TT_TimeTable[Weekday][Interval].Columns[FirstFreeColumn].IntervalType = TT_FIRST_INTERVAL; TT_TimeTable[Weekday][Interval].Columns[FirstFreeColumn].IntervalType = TT_FIRST_INTERVAL;
for (i = Interval + 1; for (i = Interval + 1;
i < Interval + DurationNumIntervals && i < Interval + DurationNumIntervals &&
i < Gbl.Timetable.Config.IntervalsPerDay; i < Timetable->Config.IntervalsPerDay;
i++) i++)
{ {
TT_TimeTable[Weekday][i].Columns[FirstFreeColumn].IntervalType = TT_NEXT_INTERVAL; TT_TimeTable[Weekday][i].Columns[FirstFreeColumn].IntervalType = TT_NEXT_INTERVAL;
@ -988,19 +999,19 @@ static void TT_FillTimeTableFromDB (long UsrCod)
} }
/* Course (row[6]) and info (row[3])*/ /* Course (row[6]) and info (row[3])*/
switch (Gbl.Timetable.Type) switch (Timetable->Type)
{ {
case TT_MY_TIMETABLE: case TT_MY_TIMETABLE:
case TT_COURSE_TIMETABLE: case TT_COURSE_TIMETABLE:
/* Group code (row[5]) */ /* Group code (row[5]) */
if (Gbl.Timetable.Type == TT_MY_TIMETABLE || if (Timetable->Type == TT_MY_TIMETABLE ||
Gbl.Timetable.Type == TT_COURSE_TIMETABLE) Timetable->Type == TT_COURSE_TIMETABLE)
if (sscanf (row[5],"%ld",&TT_TimeTable[Weekday][Interval].Columns[FirstFreeColumn].GrpCod) != 1) if (sscanf (row[5],"%ld",&TT_TimeTable[Weekday][Interval].Columns[FirstFreeColumn].GrpCod) != 1)
TT_TimeTable[Weekday][Interval].Columns[FirstFreeColumn].GrpCod = -1; TT_TimeTable[Weekday][Interval].Columns[FirstFreeColumn].GrpCod = -1;
/* Course code (row[6]) */ /* Course code (row[6]) */
TT_TimeTable[Weekday][Interval].Columns[FirstFreeColumn].CrsCod = TT_TimeTable[Weekday][Interval].Columns[FirstFreeColumn].CrsCod =
(Gbl.Timetable.Type == TT_MY_TIMETABLE ? Str_ConvertStrCodToLongCod (row[6]) : (Timetable->Type == TT_MY_TIMETABLE ? Str_ConvertStrCodToLongCod (row[6]) :
Gbl.Hierarchy.Crs.CrsCod); Gbl.Hierarchy.Crs.CrsCod);
/* falls through */ /* falls through */
/* no break */ /* no break */
@ -1100,31 +1111,31 @@ static unsigned TT_CalculateMinutesPerInterval (unsigned Seconds)
/*********************** Modify a class in timetable *************************/ /*********************** Modify a class in timetable *************************/
/*****************************************************************************/ /*****************************************************************************/
static void TT_ModifTimeTable (void) static void TT_ModifTimeTable (struct TT_Timetable *Timetable)
{ {
if (TT_TimeTable[Gbl.Timetable.Weekday][Gbl.Timetable.Interval].Columns[Gbl.Timetable.Column].IntervalType == TT_FIRST_INTERVAL) if (TT_TimeTable[Timetable->Weekday][Timetable->Interval].Columns[Timetable->Column].IntervalType == TT_FIRST_INTERVAL)
{ {
/***** Free this cell *****/ /***** Free this cell *****/
TT_TimeTable[Gbl.Timetable.Weekday][Gbl.Timetable.Interval].Columns[Gbl.Timetable.Column].GrpCod = -1L; TT_TimeTable[Timetable->Weekday][Timetable->Interval].Columns[Timetable->Column].GrpCod = -1L;
TT_TimeTable[Gbl.Timetable.Weekday][Gbl.Timetable.Interval].Columns[Gbl.Timetable.Column].IntervalType = TT_FREE_INTERVAL; TT_TimeTable[Timetable->Weekday][Timetable->Interval].Columns[Timetable->Column].IntervalType = TT_FREE_INTERVAL;
TT_TimeTable[Gbl.Timetable.Weekday][Gbl.Timetable.Interval].Columns[Gbl.Timetable.Column].ClassType = TT_FREE; TT_TimeTable[Timetable->Weekday][Timetable->Interval].Columns[Timetable->Column].ClassType = TT_FREE;
TT_TimeTable[Gbl.Timetable.Weekday][Gbl.Timetable.Interval].Columns[Gbl.Timetable.Column].DurationIntervals = 0; TT_TimeTable[Timetable->Weekday][Timetable->Interval].Columns[Timetable->Column].DurationIntervals = 0;
TT_TimeTable[Gbl.Timetable.Weekday][Gbl.Timetable.Interval].Columns[Gbl.Timetable.Column].Info[0] = '\0'; TT_TimeTable[Timetable->Weekday][Timetable->Interval].Columns[Timetable->Column].Info[0] = '\0';
TT_TimeTable[Gbl.Timetable.Weekday][Gbl.Timetable.Interval].NumColumns--; TT_TimeTable[Timetable->Weekday][Timetable->Interval].NumColumns--;
} }
if (Gbl.Timetable.ClassType != TT_FREE && if (Timetable->ClassType != TT_FREE &&
Gbl.Timetable.DurationIntervals > 0 && Timetable->DurationIntervals > 0 &&
TT_TimeTable[Gbl.Timetable.Weekday][Gbl.Timetable.Interval].NumColumns < TT_MAX_COLUMNS_PER_CELL) TT_TimeTable[Timetable->Weekday][Timetable->Interval].NumColumns < TT_MAX_COLUMNS_PER_CELL)
{ {
/***** Change this cell *****/ /***** Change this cell *****/
TT_TimeTable[Gbl.Timetable.Weekday][Gbl.Timetable.Interval].NumColumns++; TT_TimeTable[Timetable->Weekday][Timetable->Interval].NumColumns++;
TT_TimeTable[Gbl.Timetable.Weekday][Gbl.Timetable.Interval].Columns[Gbl.Timetable.Column].GrpCod = Gbl.Timetable.GrpCod; TT_TimeTable[Timetable->Weekday][Timetable->Interval].Columns[Timetable->Column].GrpCod = Timetable->GrpCod;
TT_TimeTable[Gbl.Timetable.Weekday][Gbl.Timetable.Interval].Columns[Gbl.Timetable.Column].IntervalType = TT_FIRST_INTERVAL; TT_TimeTable[Timetable->Weekday][Timetable->Interval].Columns[Timetable->Column].IntervalType = TT_FIRST_INTERVAL;
TT_TimeTable[Gbl.Timetable.Weekday][Gbl.Timetable.Interval].Columns[Gbl.Timetable.Column].ClassType = Gbl.Timetable.ClassType; TT_TimeTable[Timetable->Weekday][Timetable->Interval].Columns[Timetable->Column].ClassType = Timetable->ClassType;
TT_TimeTable[Gbl.Timetable.Weekday][Gbl.Timetable.Interval].Columns[Gbl.Timetable.Column].DurationIntervals = Gbl.Timetable.DurationIntervals; TT_TimeTable[Timetable->Weekday][Timetable->Interval].Columns[Timetable->Column].DurationIntervals = Timetable->DurationIntervals;
Str_Copy (TT_TimeTable[Gbl.Timetable.Weekday][Gbl.Timetable.Interval].Columns[Gbl.Timetable.Column].Info, Str_Copy (TT_TimeTable[Timetable->Weekday][Timetable->Interval].Columns[Timetable->Column].Info,
Gbl.Timetable.Info, Timetable->Info,
TT_MAX_BYTES_INFO); TT_MAX_BYTES_INFO);
} }
} }
@ -1133,7 +1144,7 @@ static void TT_ModifTimeTable (void)
/********************* Draw timetable using internal table *******************/ /********************* Draw timetable using internal table *******************/
/*****************************************************************************/ /*****************************************************************************/
static void TT_DrawTimeTable (void) static void TT_DrawTimeTable (const struct TT_Timetable *Timetable)
{ {
unsigned DayColumn; // Column from left (0) to right (6) unsigned DayColumn; // Column from left (0) to right (6)
unsigned Weekday; // Day of week unsigned Weekday; // Day of week
@ -1155,7 +1166,7 @@ static void TT_DrawTimeTable (void)
HTM_TD_Begin ("rowspan=\"2\" class=\"TT_HOUR_BIG RM\" style=\"width:%u%%;\"", HTM_TD_Begin ("rowspan=\"2\" class=\"TT_HOUR_BIG RM\" style=\"width:%u%%;\"",
TT_PERCENT_WIDTH_OF_AN_HOUR_COLUMN); TT_PERCENT_WIDTH_OF_AN_HOUR_COLUMN);
HTM_TxtF ("%02u:00",Gbl.Timetable.Config.Range.Hours.Start); HTM_TxtF ("%02u:00",Timetable->Config.Range.Hours.Start);
HTM_TD_End (); HTM_TD_End ();
TT_DrawCellAlignTimeTable (); TT_DrawCellAlignTimeTable ();
@ -1164,7 +1175,7 @@ static void TT_DrawTimeTable (void)
HTM_TD_Begin ("rowspan=\"2\" class=\"TT_HOUR_BIG LM\" style=\"width:%u%%;\"", HTM_TD_Begin ("rowspan=\"2\" class=\"TT_HOUR_BIG LM\" style=\"width:%u%%;\"",
TT_PERCENT_WIDTH_OF_AN_HOUR_COLUMN); TT_PERCENT_WIDTH_OF_AN_HOUR_COLUMN);
HTM_TxtF ("%02u:00",Gbl.Timetable.Config.Range.Hours.Start); HTM_TxtF ("%02u:00",Timetable->Config.Range.Hours.Start);
HTM_TD_End (); HTM_TD_End ();
HTM_TR_End (); HTM_TR_End ();
@ -1175,18 +1186,18 @@ static void TT_DrawTimeTable (void)
Grp_GetListGrpTypesAndGrpsInThisCrs (Grp_ONLY_GROUP_TYPES_WITH_GROUPS); Grp_GetListGrpTypesAndGrpsInThisCrs (Grp_ONLY_GROUP_TYPES_WITH_GROUPS);
/***** Write the table row by row *****/ /***** Write the table row by row *****/
for (Interval = 0, Min = Gbl.Timetable.Config.Range.MinutesPerInterval; for (Interval = 0, Min = Timetable->Config.Range.MinutesPerInterval;
Interval < Gbl.Timetable.Config.IntervalsPerDay; Interval < Timetable->Config.IntervalsPerDay;
Interval++, Interval++,
Min = (Min + Gbl.Timetable.Config.Range.MinutesPerInterval) % Min = (Min + Timetable->Config.Range.MinutesPerInterval) %
TT_SECONDS_PER_MINUTE) TT_SECONDS_PER_MINUTE)
{ {
HTM_TR_Begin (NULL); HTM_TR_Begin (NULL);
/* Left hour:minutes cell */ /* Left hour:minutes cell */
if (Interval % 2) if (Interval % 2)
TT_TimeTableDrawHourCell (Gbl.Timetable.Config.Range.Hours.Start + TT_TimeTableDrawHourCell (Timetable->Config.Range.Hours.Start +
(Interval + 2) / Gbl.Timetable.Config.IntervalsPerHour, (Interval + 2) / Timetable->Config.IntervalsPerHour,
Min, Min,
"RM"); "RM");
@ -1206,18 +1217,19 @@ static void TT_DrawTimeTable (void)
/* Check how many colums are needed. /* Check how many colums are needed.
For each item (class) in this hour from left to right, For each item (class) in this hour from left to right,
we must check the maximum of columns */ we must check the maximum of columns */
ColumnsToDraw = TT_CalculateColsToDrawInCell (true, // Top call, non recursive ColumnsToDraw = TT_CalculateColsToDrawInCell (Timetable,
true, // Top call, non recursive
Weekday,Interval); Weekday,Interval);
if (ColumnsToDraw == 0 && if (ColumnsToDraw == 0 &&
(Gbl.Timetable.View == TT_CRS_VIEW || (Timetable->View == TT_CRS_VIEW ||
Gbl.Timetable.View == TT_TUT_VIEW)) Timetable->View == TT_TUT_VIEW))
ColumnsToDraw = 1; ColumnsToDraw = 1;
// If editing and there's place for more columns, // If editing and there's place for more columns,
// a potential new column is added at the end of each day // a potential new column is added at the end of each day
ColumnsToDrawIncludingExtraColumn = ColumnsToDraw; ColumnsToDrawIncludingExtraColumn = ColumnsToDraw;
if (ColumnsToDraw < TT_MAX_COLUMNS_PER_CELL && if (ColumnsToDraw < TT_MAX_COLUMNS_PER_CELL &&
(Gbl.Timetable.View == TT_CRS_EDIT || (Timetable->View == TT_CRS_EDIT ||
Gbl.Timetable.View == TT_TUT_EDIT)) Timetable->View == TT_TUT_EDIT))
ColumnsToDrawIncludingExtraColumn++; ColumnsToDrawIncludingExtraColumn++;
/* Draw cells */ /* Draw cells */
@ -1231,11 +1243,13 @@ static void TT_DrawTimeTable (void)
{ {
if (ContinuousFreeMinicolumns) if (ContinuousFreeMinicolumns)
{ {
TT_TimeTableDrawCell (Weekday,Interval,Column - 1,ContinuousFreeMinicolumns, TT_TimeTableDrawCell (Timetable,
Weekday,Interval,Column - 1,ContinuousFreeMinicolumns,
-1L,TT_FREE_INTERVAL,TT_FREE,0,-1L,NULL); -1L,TT_FREE_INTERVAL,TT_FREE,0,-1L,NULL);
ContinuousFreeMinicolumns = 0; ContinuousFreeMinicolumns = 0;
} }
TT_TimeTableDrawCell (Weekday,Interval,Column, TT_TimeTableDrawCell (Timetable,
Weekday,Interval,Column,
TT_NUM_MINICOLUMNS_PER_DAY / TT_NUM_MINICOLUMNS_PER_DAY /
ColumnsToDrawIncludingExtraColumn, ColumnsToDrawIncludingExtraColumn,
TT_TimeTable[Weekday][Interval].Columns[Column].CrsCod, TT_TimeTable[Weekday][Interval].Columns[Column].CrsCod,
@ -1246,7 +1260,8 @@ static void TT_DrawTimeTable (void)
TT_TimeTable[Weekday][Interval].Columns[Column].Info); TT_TimeTable[Weekday][Interval].Columns[Column].Info);
} }
if (ContinuousFreeMinicolumns) if (ContinuousFreeMinicolumns)
TT_TimeTableDrawCell (Weekday,Interval,Column - 1,ContinuousFreeMinicolumns, TT_TimeTableDrawCell (Timetable,
Weekday,Interval,Column - 1,ContinuousFreeMinicolumns,
-1L,TT_FREE_INTERVAL,TT_FREE,0,-1L,NULL); -1L,TT_FREE_INTERVAL,TT_FREE,0,-1L,NULL);
} }
@ -1255,8 +1270,8 @@ static void TT_DrawTimeTable (void)
/* Right hour:minutes cell */ /* Right hour:minutes cell */
if (Interval % 2) if (Interval % 2)
TT_TimeTableDrawHourCell (Gbl.Timetable.Config.Range.Hours.Start + TT_TimeTableDrawHourCell (Timetable->Config.Range.Hours.Start +
(Interval + 2) / Gbl.Timetable.Config.IntervalsPerHour, (Interval + 2) / Timetable->Config.IntervalsPerHour,
Min, Min,
"LM"); "LM");
@ -1358,7 +1373,8 @@ static void TT_TimeTableDrawHourCell (unsigned Hour,unsigned Min,const char *Ali
/**** Calculate recursively number of columns to draw for a day and hour *****/ /**** Calculate recursively number of columns to draw for a day and hour *****/
/*****************************************************************************/ /*****************************************************************************/
static unsigned TT_CalculateColsToDrawInCell (bool TopCall, static unsigned TT_CalculateColsToDrawInCell (const struct TT_Timetable *Timetable,
bool TopCall,
unsigned Weekday,unsigned Interval) unsigned Weekday,unsigned Interval)
{ {
unsigned ColumnsToDraw; unsigned ColumnsToDraw;
@ -1371,7 +1387,7 @@ static unsigned TT_CalculateColsToDrawInCell (bool TopCall,
if (TopCall) // Top call, non recursive call if (TopCall) // Top call, non recursive call
/****** Allocate space to store list of intervals already checked /****** Allocate space to store list of intervals already checked
and initialize to false by using calloc *****/ and initialize to false by using calloc *****/
if ((TT_IntervalsChecked = (bool *) calloc (Gbl.Timetable.Config.IntervalsPerDay, if ((TT_IntervalsChecked = (bool *) calloc (Timetable->Config.IntervalsPerDay,
sizeof (bool))) == NULL) sizeof (bool))) == NULL)
Lay_ShowErrorAndExit ("Error allocating memory for timetable."); Lay_ShowErrorAndExit ("Error allocating memory for timetable.");
@ -1395,7 +1411,8 @@ static unsigned TT_CalculateColsToDrawInCell (bool TopCall,
i++) i++)
if (!TT_IntervalsChecked[i]) if (!TT_IntervalsChecked[i])
{ {
Cols = TT_CalculateColsToDrawInCell (false, // Recursive call Cols = TT_CalculateColsToDrawInCell (Timetable,
false, // Recursive call
Weekday,i); Weekday,i);
if (Cols > ColumnsToDraw) if (Cols > ColumnsToDraw)
ColumnsToDraw = Cols; ColumnsToDraw = Cols;
@ -1414,7 +1431,8 @@ static unsigned TT_CalculateColsToDrawInCell (bool TopCall,
i++) i++)
if (!TT_IntervalsChecked[i]) if (!TT_IntervalsChecked[i])
{ {
Cols = TT_CalculateColsToDrawInCell (false, // Recursive call Cols = TT_CalculateColsToDrawInCell (Timetable,
false, // Recursive call
Weekday,i); Weekday,i);
if (Cols > ColumnsToDraw) if (Cols > ColumnsToDraw)
ColumnsToDraw = Cols; ColumnsToDraw = Cols;
@ -1444,7 +1462,8 @@ static void TT_DrawCellAlignTimeTable (void)
/*************************** Write a timetable cell **************************/ /*************************** Write a timetable cell **************************/
/*****************************************************************************/ /*****************************************************************************/
static void TT_TimeTableDrawCell (unsigned Weekday,unsigned Interval,unsigned Column,unsigned ColSpan, static void TT_TimeTableDrawCell (const struct TT_Timetable *Timetable,
unsigned Weekday,unsigned Interval,unsigned Column,unsigned ColSpan,
long CrsCod,TT_IntervalType_t IntervalType,TT_ClassType_t ClassType, long CrsCod,TT_IntervalType_t IntervalType,TT_ClassType_t ClassType,
unsigned DurationNumIntervals,long GrpCod,const char *Info) unsigned DurationNumIntervals,long GrpCod,const char *Info)
{ {
@ -1497,8 +1516,8 @@ static void TT_TimeTableDrawCell (unsigned Weekday,unsigned Interval,unsigned Co
/***** If group code > 0, a group is selected ==> get group data *****/ /***** If group code > 0, a group is selected ==> get group data *****/
if (IntervalType == TT_FIRST_INTERVAL && if (IntervalType == TT_FIRST_INTERVAL &&
(Gbl.Timetable.View == TT_CRS_VIEW || (Timetable->View == TT_CRS_VIEW ||
Gbl.Timetable.View == TT_CRS_EDIT) && Timetable->View == TT_CRS_EDIT) &&
GrpCod > 0) GrpCod > 0)
{ {
/* Get group data */ /* Get group data */
@ -1548,13 +1567,13 @@ static void TT_TimeTableDrawCell (unsigned Weekday,unsigned Interval,unsigned Co
free (ClassStr); free (ClassStr);
/***** Form to modify this cell *****/ /***** Form to modify this cell *****/
if (Gbl.Timetable.View == TT_CRS_EDIT) if (Timetable->View == TT_CRS_EDIT)
Frm_StartForm (ActChgCrsTT); Frm_StartForm (ActChgCrsTT);
else if (Gbl.Timetable.View == TT_TUT_EDIT) else if (Timetable->View == TT_TUT_EDIT)
Frm_StartForm (ActChgTut); Frm_StartForm (ActChgTut);
/***** Draw cell depending on type of view *****/ /***** Draw cell depending on type of view *****/
switch (Gbl.Timetable.View) switch (Timetable->View)
{ {
case TT_CRS_VIEW: // View course timetable case TT_CRS_VIEW: // View course timetable
case TT_TUT_VIEW: // View tutoring timetable case TT_TUT_VIEW: // View tutoring timetable
@ -1564,7 +1583,7 @@ static void TT_TimeTableDrawCell (unsigned Weekday,unsigned Interval,unsigned Co
HTM_DIV_Begin ("class=\"TT_CELL TT_TXT\""); HTM_DIV_Begin ("class=\"TT_CELL TT_TXT\"");
/***** Course name *****/ /***** Course name *****/
if (Gbl.Timetable.Type == TT_MY_TIMETABLE) if (Timetable->Type == TT_MY_TIMETABLE)
{ {
Crs.CrsCod = CrsCod; Crs.CrsCod = CrsCod;
Crs_GetDataOfCourseByCod (&Crs); Crs_GetDataOfCourseByCod (&Crs);
@ -1580,12 +1599,12 @@ static void TT_TimeTableDrawCell (unsigned Weekday,unsigned Interval,unsigned Co
/***** Type of class and duration *****/ /***** Type of class and duration *****/
HTM_TxtF ("%s (%u:%02u)", HTM_TxtF ("%s (%u:%02u)",
Txt_TIMETABLE_CLASS_TYPES[ClassType], Txt_TIMETABLE_CLASS_TYPES[ClassType],
(DurationNumIntervals / Gbl.Timetable.Config.IntervalsPerHour), // Hours (DurationNumIntervals / Timetable->Config.IntervalsPerHour), // Hours
(DurationNumIntervals % Gbl.Timetable.Config.IntervalsPerHour) * (DurationNumIntervals % Timetable->Config.IntervalsPerHour) *
Gbl.Timetable.Config.Range.MinutesPerInterval); // Minutes Timetable->Config.Range.MinutesPerInterval); // Minutes
/***** Group *****/ /***** Group *****/
if (Gbl.Timetable.View == TT_CRS_VIEW && if (Timetable->View == TT_CRS_VIEW &&
GrpCod > 0) GrpCod > 0)
{ {
HTM_BR (); HTM_BR ();
@ -1630,8 +1649,8 @@ static void TT_TimeTableDrawCell (unsigned Weekday,unsigned Interval,unsigned Co
CT <= (TT_ClassType_t) (TT_NUM_CLASS_TYPES - 1); CT <= (TT_ClassType_t) (TT_NUM_CLASS_TYPES - 1);
CT++) CT++)
if ((CT == TT_FREE) || if ((CT == TT_FREE) ||
((Gbl.Timetable.View == TT_CRS_EDIT) && (CT == TT_LECTURE || CT == TT_PRACTICAL)) || ((Timetable->View == TT_CRS_EDIT) && (CT == TT_LECTURE || CT == TT_PRACTICAL)) ||
((Gbl.Timetable.View == TT_TUT_EDIT) && (CT == TT_TUTORING))) ((Timetable->View == TT_TUT_EDIT) && (CT == TT_TUTORING)))
HTM_OPTION (HTM_Type_STRING,TT_ClassTypeDB[CT], HTM_OPTION (HTM_Type_STRING,TT_ClassTypeDB[CT],
CT == ClassType,false, CT == ClassType,false,
"%s",Txt_TIMETABLE_CLASS_TYPES[CT]); "%s",Txt_TIMETABLE_CLASS_TYPES[CT]);
@ -1640,17 +1659,17 @@ static void TT_TimeTableDrawCell (unsigned Weekday,unsigned Interval,unsigned Co
if (IntervalType == TT_FREE_INTERVAL) if (IntervalType == TT_FREE_INTERVAL)
{ {
for (i = Interval + 1; for (i = Interval + 1;
i < Gbl.Timetable.Config.IntervalsPerDay; i < Timetable->Config.IntervalsPerDay;
i++) i++)
if (TT_TimeTable[Weekday][i].NumColumns == TT_MAX_COLUMNS_PER_CELL) if (TT_TimeTable[Weekday][i].NumColumns == TT_MAX_COLUMNS_PER_CELL)
break; break;
MaxDuration = i - Interval; MaxDuration = i - Interval;
Dur = (MaxDuration >= Gbl.Timetable.Config.IntervalsPerHour) ? Gbl.Timetable.Config.IntervalsPerHour : // MaxDuration >= 1h ==> Dur = 1h Dur = (MaxDuration >= Timetable->Config.IntervalsPerHour) ? Timetable->Config.IntervalsPerHour : // MaxDuration >= 1h ==> Dur = 1h
MaxDuration; // MaxDuration < 1h ==> Dur = MaxDuration MaxDuration; // MaxDuration < 1h ==> Dur = MaxDuration
if (asprintf (&TTDur,"%u:%02u", if (asprintf (&TTDur,"%u:%02u",
(Dur / Gbl.Timetable.Config.IntervalsPerHour), // Hours (Dur / Timetable->Config.IntervalsPerHour), // Hours
(Dur % Gbl.Timetable.Config.IntervalsPerHour) * (Dur % Timetable->Config.IntervalsPerHour) *
Gbl.Timetable.Config.Range.MinutesPerInterval) < 0) // Minutes Timetable->Config.Range.MinutesPerInterval) < 0) // Minutes
Lay_NotEnoughMemoryExit (); Lay_NotEnoughMemoryExit ();
Par_PutHiddenParamString (NULL,"TTDur",TTDur); Par_PutHiddenParamString (NULL,"TTDur",TTDur);
free (TTDur); free (TTDur);
@ -1661,7 +1680,7 @@ static void TT_TimeTableDrawCell (unsigned Weekday,unsigned Interval,unsigned Co
HTM_SELECT_Begin (true, HTM_SELECT_Begin (true,
"name=\"TTDur\" class=\"TT_DUR\""); "name=\"TTDur\" class=\"TT_DUR\"");
for (i = Interval + TT_TimeTable[Weekday][Interval].Columns[Column].DurationIntervals; for (i = Interval + TT_TimeTable[Weekday][Interval].Columns[Column].DurationIntervals;
i < Gbl.Timetable.Config.IntervalsPerDay; i < Timetable->Config.IntervalsPerDay;
i++) i++)
if (TT_TimeTable[Weekday][i].NumColumns == TT_MAX_COLUMNS_PER_CELL) if (TT_TimeTable[Weekday][i].NumColumns == TT_MAX_COLUMNS_PER_CELL)
break; break;
@ -1673,9 +1692,9 @@ static void TT_TimeTableDrawCell (unsigned Weekday,unsigned Interval,unsigned Co
Dur++) Dur++)
{ {
if (asprintf (&TTDur,"%u:%02u", if (asprintf (&TTDur,"%u:%02u",
(Dur / Gbl.Timetable.Config.IntervalsPerHour), // Hours (Dur / Timetable->Config.IntervalsPerHour), // Hours
(Dur % Gbl.Timetable.Config.IntervalsPerHour) * (Dur % Timetable->Config.IntervalsPerHour) *
Gbl.Timetable.Config.Range.MinutesPerInterval) < 0) // Minutes Timetable->Config.Range.MinutesPerInterval) < 0) // Minutes
Lay_NotEnoughMemoryExit (); Lay_NotEnoughMemoryExit ();
HTM_OPTION (HTM_Type_STRING,TTDur, HTM_OPTION (HTM_Type_STRING,TTDur,
Dur == DurationNumIntervals,false, Dur == DurationNumIntervals,false,
@ -1684,7 +1703,7 @@ static void TT_TimeTableDrawCell (unsigned Weekday,unsigned Interval,unsigned Co
} }
HTM_SELECT_End (); HTM_SELECT_End ();
if (Gbl.Timetable.View == TT_CRS_EDIT) if (Timetable->View == TT_CRS_EDIT)
{ {
/***** Group *****/ /***** Group *****/
HTM_BR (); HTM_BR ();
@ -1757,8 +1776,8 @@ static void TT_TimeTableDrawCell (unsigned Weekday,unsigned Interval,unsigned Co
} }
/***** End form *****/ /***** End form *****/
if (Gbl.Timetable.View == TT_CRS_EDIT || if (Timetable->View == TT_CRS_EDIT ||
Gbl.Timetable.View == TT_TUT_EDIT) Timetable->View == TT_TUT_EDIT)
Frm_EndForm (); Frm_EndForm ();
/***** End cell *****/ /***** End cell *****/

2
swad_timetable.h
View File

@ -113,6 +113,6 @@ struct TT_Timetable
void TT_ShowClassTimeTable (void); void TT_ShowClassTimeTable (void);
void TT_EditCrsTimeTable (void); void TT_EditCrsTimeTable (void);
void TT_EditMyTutTimeTable (void); void TT_EditMyTutTimeTable (void);
void TT_ShowTimeTable (long UsrCod); void TT_ShowTimeTable (struct TT_Timetable *Timetable,long UsrCod);
#endif #endif