<?xml version="1.0" encoding="UTF-8"?>
<!--
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
 -->
<document>

	<properties>
		<title>Edit Templates</title>
		<author email="sebawagner@apache.org">
			OpenMeetings Team
		</author>
	</properties>

	<body>

		<section name="Changing Labels and text strings">
			<p>
				All language string should be localized and stored in the language
				section. You have a full featured language editor with every
				installation of OpenMeetings, check out the
				<a href="LanguageEditor.html">LanguageEditor</a>
				.
			</p>
			<p>
				To lookup the labelids in the GUI you can simply run OpenMeetings
				client with the debug enabled. That way every text-string has the
				labelid in brackets additionally in the textfield. To start the
				client in debug mode just add the param ?swf=maindebug.swf8.swf to
				the URL. Example:
				<a href="http://localhost:5080/openmeetings/?swf=maindebug.swf8.swf"
					rel="nofollow">http://localhost:5080/openmeetings/?swf=maindebug.swf8.swf</a>
			</p>
		</section>

		<section name="Changing layout, adding footers in emails">

			<p>If you would like to change the standard email layout or add for
				example some footer in every email you have to change the email
				templates.
			</p>
			<p>To do that: Stop the Red5/OpenMeetings-Service Goto:
				$Red5_HOME/webapps/openmeetings/WEB-INF/lib/openmeetings-templates.jar
				Unzip: openmeetings-templates.jar (this is a usual ZIP file, you can
				rename it to openmeetings-templates.zip unzip, edit the files, zip
				it again and rename it to openmeetings-templates.jar)
			</p>
			<p>
				In openmeetings-templates.jar there are all template files. They
				have the file extension .vm (VM stands for velocity-template). After
				you have done your changes you need to (re)start the
				Red5/OpenMeetings
				-Service so that changes are online.
			</p>

		</section>

	</body>

</document>