FET (c) 2002-2009 Liviu Lalescu


Program description:

	FET is free timetabling software.
	This program aims to automatically generate the timetable of a school, high-school
	or university, by a heuristic algorithm. 
	FET can mean "Free Educational Timetabling".


Requirements:

	FET is created in the following environment: openSUSE 11.1 GNU/Linux distribution,
	Midnight Commander 4.6.2-pre1, Qt 4.4.3, gcc 4.3.2, Linux 2.6.27, KDiff3 0.9.92, other great free tools.
	FET can be run on any platform supported by the free software Qt (GNU/Linux, Windows, Mac OS X).

	GNU/Linux, Mac OS X and similar OS's:
	Software:
		make (GNU make command)
		gcc 4.3.2 or similar (3.x.x and 4.1.x are fine, gcc 4.2.x does NOT work) (you might though sometimes
				find that you can compile with gcc 4.2.x - if FET compiles completely then everything is OK. The gcc 4.2.3
				crashed on my computer when compiling the file rules.cpp because of lack of memory. If you have
				a newer like 4.2.4 or above gcc or more memory, you might try with it)
		gcc-c++ (or g++, the name may vary)
		Qt 4.4.3 or compatible (4.3.x is fine, Qt 4.2.x does NOT work) (Qt 4.2.x makes some buttons inactive,
				so you cannot work with FET - for instance you cannot add groups or rooms).
	
	Microsoft Windows:
	For running, you need only the archive of FET compiled for Windows (which contains the MinGW and Qt dlls).
	For compiling, you need Qt and a compatible C++ compiler (MinGW probably an easy option) (do NOT use Qt 4.2.x or gcc 4.2.x).
	
	Important note about virtual memory: on Windows you might get the error message
	"The paging file is too small for this operation to complete" when trying to run fet.exe .
	Maybe on other systems you can get a similar problem.
	It seems that FET won't run without a decent amount of virtual memory.
	This is because FET allocates a large amount of static data (600MB), of which only about 50 MB are normally used.
	So the operating system must have virtual memory reserved (which will not be used normally,
	but that does not matter). So, if you disabled virtual memory, please enable it and/or increse maximum size
	if FET does not run.


Download:

	You can download the latest version from http://www.lalescu.ro/liviu/fet/ (for now).
	Older versions: you will have to contact the author if you are interested.


Getting - compiling - installing GNU tools: make, gcc and gcc-g++ (or g++):

	GNU/Linux, Mac OS X: Most probably, your platform has these installed by default or available on the internet
	as precompiled packages. If you don't have them, please install them using YaST (on openSUSE), Adept Manager
	(on Ubuntu or Kubuntu) or other package manager.
	To verify that you have the correct packages, write "make --version", "gcc --version" and
	"g++ --version".
	
	Windows: you need a Qt compatible C++ compiler
	(maybe the easiest option the MinGW compiler, which is installed automatically by Qt) (see below)


Getting - compiling - installing Qt by Nokia (formerly by Trolltech):

	You will need Qt 4.4.3 or compatible (4.3.x works, 4.2.x does NOT work) to compile FET.
	You can get the corresponding version of Qt with your package manager or
	from http://www.qtsoftware.com/ (you can get the opensource version of Qt
	or other variants if you want).
	
	GNU/Linux: It is possible to use YaST (or Adept Manager) or other package managers to get
	your version of Qt, pre-compiled. Please DO NOT use Qt 4.2.x, FET does not work with it.
	Or you can download, compile and install Qt from http://www.qtsoftware.com/ .
	On my OpenSUSE GNU/Linux, which has pre-compiled packages on the internet, I need to install
	libqt4 and libqt4-devel packages (libqt4 is installed by default, I think) - to compile+run FET.
	Additionally, to modify FET, you will need the qt3, qt3-devel and qt3-devel-tools packages
	(qt3 is installed by default, I think).
	
	Windows - Download latest Qt (maybe open source version for MinGW is the easiest option,
	but you can try also other variants) from http://www.qtsoftware.com/
	For MinGW version: Install and let Qt download and install MinGW.
	Please make sure, after installing Qt and MinGW, that you have
	an environment variable named "QTDIR" which is C:\Qt\4.4.3"
	and you have in the PATH environmental variable the contents
	QTDIR and C:\MinGW\bin.
	
	Mac OS X: 
	Maybe you can get pre-compiled packages for Mac. If not, get Qt from http://www.qtsoftware.com/ (maybe open source
	version is the easiest option).


Compiling FET:
	Note: compilation takes long (maybe even 1 hour, if you are using an older computer). Also, the file
	rules.cpp takes long to compile, maybe even 5 minutes or more.
	
	Note2: under my openSUSE GNU/Linux, the intermediary files and the executable are very large, with default settings.
	(the fet executable is over 100 MB!). To avoid this, you need to modify the /usr/share/qt4/mkspecs/common/g++.conf
	line 10, remove the "-g" flag for the release version (root access needed to make this change)
	
	Currently FET can be compiled using Qt 4.4.3 or compatible (4.3.x OK, 4.2.x NOT OK).
	But the majority of interface files are Qt 3.3 forms and to modify them
	you will need Qt 3.3, which unfortunately has no free Windows version.
	
	Important note for all platforms: it seems that FET cannot be compiled with gcc 4.2.x.
	This is a bug of gcc, which was solved in gcc 4.3.x. So, you can compile FET with gcc 4.1.x or
	gcc 4.3.x or compatible (not 4.2.x), gcc 3.x.x should also work.
	(Note3: the reason is that it crashes compiling rules.cpp - but if you can compile all FET with 4.2.x,
	then everything is OK, maybe you have more memory or the bug was fixed in later 4.2.x versions)


	GNU/Linux and similar OS's:
	- You will need Qt 4.4.3 or compatible (NOT 4.2.x) to compile this program.
	- type "qmake fet.pro" or simply "qmake". You have to use qmake from Qt 4 series, which on some systems
	might be named qmake-qt4. So, "qmake-qt4 fet.pro" might sometimes be needed (this command is executed very fast,
	so don't worry if you get immediate return from it)
	- type "make" (this takes a long time, maybe even 1 hour)
	To remove the compiled objects/executable: "make clean" and/or "make distclean".
	
	Note (N1): if you get an error like: "uic: File generated with too recent version of Qt Designer (4.0 vs. 3.3.8b)",
	please make sure uic links to uic4. You can check this with "uic -version". Another possibility: you may need to
	remove the Makefiles (there are 3, in main dir, in src/ and in src/interface/) and type qmake-qt4 again,
	because when you initially typed qmake, it was used qmake3, which is not good. Or remove fet directory and
	unpack again the fet archive and run qmake-qt4.

	
	Mac OS X:
	2 Variants:
	
	1. First variant, if you use gcc compiler:
	- You will need Qt 4.4.3 or compatible to compile this program.
	- type "qmake fet.pro" or simply "qmake". You have to use qmake from Qt 4 series, which on some systems
	might be named qmake-qt4. So, "qmake-qt4 fet.pro" might sometimes be needed.
	(this command is executed very fast, so don't worry if you get immediate return from it)
	- IMPORTANT: you might need to write: "qmake -spec macx-g++ fet.pro", if "qmake fet.pro" 
	does not produce a correct makefile. Please see 
	http://lists.trolltech.com/qt-interest/2007-04/thread01126-0.html for details.
	- type "make" (this takes a long time, maybe even 1 hour)
	To remove the compiled objects/executable: "make clean" and/or "make distclean".
	
	2. Another variant:
	- Type "qmake fet.pro" and then "xcodebuild".
	
	If you encounter problems, please see:
	http://lists.trolltech.com/qt-interest/2007-04/thread01126-0.html

	
	Microsoft Windows: MinGW C++ compiler: you will have to download and install Qt with MinGW from http://www.qtsoftware.com/ .
	You might use other compilers if you want, please see the Qt web page http://www.qtsoftware.com/
	for other variants. Any C++ compiler that supports Qt is OK, as long as you can use it.
	You need to run "qmake fet.pro" or "qmake" (this command is executed very fast, so don't worry if you get
	immediate return from it) and then "make" (this takes a long time, maybe even 1 hour) 
	in a command line in the FET directory. 
	Then, you can remove directories "src" and "tmp", to save up space.
	For MinGW:
	If you want to obtain a version which can be run on other computers, 
	you have to copy these 7 files into the FET directory (in the same place as fet.exe):
	C:\Qt\4.4.3\bin\mingwm10.dll,
	C:\Qt\4.4.3\bin\Qt3Support4.dll, C:\Qt\4.4.3\bin\QtCore4.dll, C:\Qt\4.4.3\bin\QtGui4.dll,
	C:\Qt\4.4.3\bin\QtNetwork4.dll, C:\Qt\4.4.3\bin\QtSQl4.dll, C:\Qt\4.4.3\bin\QtXml4.dll.
	
	
Installing FET:

	GNU/Linux and similar OS's:	
	Please move the whole directory "fet-x.x.x" into the place where you like,
	for instance to the directory "/usr/local/".
	
	Microsoft Windows:
	Move the FET directory in a place of your choice.


Running FET:
	Note: The FET main form is empty, it just contains a menu with the items: File, Data, Advanced,
	Statistics, Timetable, Settings, Help. Everything is all right if you have that.

	GNU/Linux and similar OS's:
	Please chdir to the directory where fet executable is (for instance,
	"cd /home/liviu/fet-x.x.x/") and run "./fet". You may also run fet from
	another directory, but this is not thoroughly tested.
	
	Microsoft Windows:
	Run the executable fet.exe
	
	NOTE for MS Windows users: if you get the message "The paging file is too small for this operation to complete":
	If you disable virtual memory or have it low, it seems that the program won't start.
	The memory consumption of FET is maybe around 50 MB, but FET has defined approximately 600 MB of memory in internal
	variables (these are not used in normal cases). FET seems to need a good amount of virtual memory on Windows
	(maybe it is best to let Windows manage the virtual memory).
	
	COMMAND LINE: no GUI, just run "fet --inputfile=x [--timelimitseconds=y] [--htmllevel=z] [--language=t] [--printnotavailable=u] [--dividetimeaxisbydays=v]",
	where	x is the input file, for instance "inputfile.fet"
			y is integer (seconds) (default 2000000000, which is practically infinite)
			z is integer from 0 to 6 and represents the detail level for the generated html timetables
				(default 2, larger values have more details/facilities and larger file sizes)
			t is one of en_GB, ar, ca, de, el, es, fr, hu, id, it, lt, mk, ms, nl, pl, ro, tr (default en_GB)
			u is either "true" or "false" and represents if you want -x- (for true) or --- (for false) in the generated timetables for the
				not available slots (default true)
			v is either true or false, represents if you want html timetables with time-axis divided by days (default false).
	For the command line version, probably the most useful output to use internally in an application might be the activities_timetable.xml.
	You have of course also the xml timetables for students and teachers and the nicely formatted html timetables to present directly.
			
	On GNU/Linux and Mac OS X, you'll get a console output to help you with data.
	
	On Windows, only the file result.txt will guide you,
	I cannot make a console output on Windows (I could, but it would complicate the interface).


Languages (translations):
	
	FET will search for translations (fet_xx.qm files) in the following order: directory /usr/share/fet/translations
	(under Unix like or Mac), then directory "translations" in the directory where fet executable is,
	then directly in the directory where the fet executable is. 
	
	So, on Windows: if fet.exe is in C:\fet-x.x.x, fet will search for file fet_xx.qm in 
	C:\fet-x.x.x\translations and then in C:\fet-x.x.x\.
		On UNIX like: if fet executable is in /home/liviu/fet-x.x.x, fet will search for file fet_xx.qm in 
	/usr/share/fet/translations, then in /home/liviu/fet-x.x.x/translations and then in 
	/home/liviu/fet-x.x.x
	
	
Documentation:

	Some hints in the directory "/.../fet-x.x.x/doc/".
	Some other hints in Help menu.


Input files:

	You can open a few sample input files in "/.../fet-x.x.x/sample_inputs/" directory
	(maybe they can be found in /usr/share/doc/fet/, or /usr/share/fet/)
	
	You can create/modify a file from FET's user interface or you can modify it by
	hand, if you like.


Feed-back / help:
	- I would like to hear your oppinions/results about this program; any
	feed-back would be greatly appreciated.
	- Reporting bugs/wishes/patches: to forum, mailing list or author.
	
	This project is free software, so any sponsoring offer/donation would be great. You can 
	contact	the author for that.
