<?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>Changing Dashboard</title>
		<author email="sebawagner@apache.org">
			OpenMeetings Team
		</author>
	</properties>

	<body>

		<section name="Changing Dashboard">

			<p>You can configure the tabs that are visible by default at bottom
				of the dashboard. To edit the settings, login as admin and goto
				Administration &gt; Configuration </p>
			<p></p>
			<table>
				<tr>
					<th style="border: 1px solid rgb(204, 204, 204); padding: 5px;"> Config-key </th>
					<th style="border: 1px solid rgb(204, 204, 204); padding: 5px;"> Values </th>
					<th style="border: 1px solid rgb(204, 204, 204); padding: 5px;"> Meaning </th>
				</tr>
				<tr>
					<td style="border: 1px solid rgb(204, 204, 204); padding: 5px;"> default.dashboard.tab </td>
					<td style="border: 1px solid rgb(204, 204, 204); padding: 5px;"> 0,1,2 </td>
					<td style="border: 1px solid rgb(204, 204, 204); padding: 5px;"> Which tab should be shown by default, counting
						starts with 0
					</td>
				</tr>
				<tr>
					<td style="border: 1px solid rgb(204, 204, 204); padding: 5px;"> dashboard.show.myrooms </td>
					<td style="border: 1px solid rgb(204, 204, 204); padding: 5px;"> 0 or 1 </td>
					<td style="border: 1px solid rgb(204, 204, 204); padding: 5px;"> If the MyRooms tab should be visible or not </td>
				</tr>
				<tr>
					<td style="border: 1px solid rgb(204, 204, 204); padding: 5px;"> dashboard.show.chat </td>
					<td style="border: 1px solid rgb(204, 204, 204); padding: 5px;"> 0 or 1 </td>
					<td style="border: 1px solid rgb(204, 204, 204); padding: 5px;"> If the Chat tab should be visible or not </td>
				</tr>
				<tr>
					<td style="border: 1px solid rgb(204, 204, 204); padding: 5px;"> dashboard.show.rssfeed </td>
					<td style="border: 1px solid rgb(204, 204, 204); padding: 5px;"> 0 or 1 </td>
					<td style="border: 1px solid rgb(204, 204, 204); padding: 5px;"> If the RSS-Feed tab should be visible or not </td>
				</tr>
				<tr>
					<td style="border: 1px solid rgb(204, 204, 204); padding: 5px;"> rss_feed1 </td>
					<td style="border: 1px solid rgb(204, 204, 204); padding: 5px;"> http-URL </td>
					<td style="border: 1px solid rgb(204, 204, 204); padding: 5px;"> ATOM-Feed URL for the dashboard RSS Tab </td>
				</tr>
				<tr>
					<td style="border: 1px solid rgb(204, 204, 204); padding: 5px;"> rss_feed2 </td>
					<td style="border: 1px solid rgb(204, 204, 204); padding: 5px;"> http-URL </td>
					<td style="border: 1px solid rgb(204, 204, 204); padding: 5px;"> ATOM-Feed URL for the dashboard RSS Tab </td>
				</tr>
			</table>
			<p></p>
			<p>Changes are immediately online, no need to restart anything. </p>
		</section>

	</body>

</document>