<?xml version="1.0" encoding="UTF-8" ?>
<!--
  Licensed to the Apache Software Foundation (ASF) under one
  or more contributor license agreements.  See the NOTICE file
  distributed with this work for additional information
  regarding copyright ownership.  The ASF licenses this file
  to you 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.
  
-->
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
	<entry key="install.wizard.install.header">Installation</entry>
	<entry key="install.wizard.welcome.panel"><![CDATA[
	<ol>
		<li>
			<h4>
				<a id="Recommendation_for_production_environment"></a>Recomenda&ccedil;&otilde;es 
				para o ambiente de produ&ccedil;&atilde;o<a target="_blank"
					href="#Recommendation_for_production_environment"
					class="section_anchor"></a>
			</h4>
		<blockquote>
			Por padr&atilde;o o {0} utiliza o banco de dados Apache Derby integrado ao sistema. 
			Para o ambiente de produ&ccedil;&atilde;o voc&ecirc; deve considerar o uso do <a target="_blank"
				href="http://openmeetings.apache.org/MySQLConfig.html">MySQL</a>, <a
				target="_blank"
				href="http://openmeetings.apache.org/PostgresConfig.html">Postgres</a>
			ou, por exemplo, <a target="_blank"
				href="http://openmeetings.apache.org/IBMDB2Config.html">IBM DB2</a>
			ou <a href="http://openmeetings.apache.org/OracleConfig.html"
				target="_blank">Oracle</a>.
		</blockquote>
		</li>
		<li><h4>
				<a id="Enabling_Image_Upload_and_import_to_whiteboard"></a>Habilitando envio e 
					importa&ccedil;&atilde;o de imagens para a lousa<a
					href="#Enabling_Image_Upload_and_import_to_whiteboard"
					class="section_anchor"></a>
			</h4>
			<ul>
				<li>Instale <strong>ImageMagick</strong> no servidor, voc&ecirc; pode
					obter maiores informa&ccedil;&otilde;es em <a target="_blank"
					href="http://www.imagemagick.org" rel="nofollow">http://www.imagemagick.org</a>, inclusive 
					sobre a instala&ccedil;&atilde;o. Instru&ccedil;&otilde;es sobre a instala&ccedil;&atilde;o
					também podem ser encontradas aqui <a target="_blank"
					href="http://www.imagemagick.org/script/binary-releases.php"
					rel="nofollow">http://www.imagemagick.org/script/binary-releases.php</a>,
					entretanto na maioria dos sistemas Linux voc&ecirc; poder&aacute; instal&aacute;-lo pelo seu 						gerenciador de pacotes favorito (ex.: apt-get).
				</li>
			</ul>
		</li>
		<li><h4>
				<a id="Enabling_import_of_PDFs_into_whiteboard"></a>Habilitando 
				importa&ccedil;&atilde;o de PDFs na lousa<a
					href="#Enabling_import_of_PDFs_into_whiteboard"
					class="section_anchor"></a>
			</h4>
			<ul>
				<li>Instale <strong>GhostScript</strong> no servidor, voc&ecirc; pode
					obter maiores informa&ccedil;&otilde;es em <a target="_blank"
					href="http://pages.cs.wisc.edu/%7Eghost/" rel="nofollow">http://pages.cs.wisc.edu/~ghost/</a>,
					inclusive sobre a instala&ccedil;&atilde;o. Instru&ccedil;&otilde;es sobre a 						instala&ccedil;&atilde;o podem ser encontradas neste mesmo link, entretanto na maioria dos 						sistemas Linux voc&ecirc; poder&aacute; instal&aacute;-lo pelo seu gerenciador 
					de pacotes favorito (ex.: apt-get).
				</li>
				<li>Instale <strong>SWFTools</strong> no servidor, voc&ecirc; pode
					obter maiores informa&ccedil;&otilde;es em <a target="_blank"
					href="http://www.swftools.org/" rel="nofollow">http://www.swftools.org/</a>, inclusive
					sobre a instala&ccedil;&atilde;o. Algumas distribui&ccedil;&otilde;es de Linux j&aacute; o 
					possui em seus gerenciadores de pacote, veja <a target="_blank"
					href="http://packages.debian.org/unstable/utils/swftools"
					rel="nofollow">http://packages.debian.org/unstable/utils/swftools</a>.
					A vers&atilde;o recomendada do <strong>SWFTools</strong> &eacute; a 0.9, pois a vers&atilde;o 
					anterior possui um bug que coloca o objeto na lousa com dimens&otilde;es incorretas.	
				</li>
		</ul>
		</li>
		<li><h4>
				<a
					id="Enabling_import_of_.doc,_.docx,_.ppt,_.pptx,_..._all_Office_Docu"></a>Habilitando
				importa&ccedil;&atilde;o de todos os documentos Office como .doc, .docx, .ppt, .pptx, (...) na lousa
				<a
					href="#Enabling_import_of_.doc,_.docx,_.ppt,_.pptx,_..._all_Office_Docu"
					class="section_anchor"></a>
			</h4>
			<ul>
				<li><strong>OpenOffice-Service</strong> iniciado e executando na 
					porta 8100, veja <a target="_blank"
					href="http://openmeetings.apache.org/OpenOfficeConverter.html">OpenOfficeConverter</a>
					para detalhes.</li>
			</ul>
		</li>
		<li><h4>
				<a
					id="Enabling_Recording_and_import_of_.avi,_.flv,_.mov_and_.mp4_into"></a>Habilitando
				grava&ccedil;&otilde;es e importa&ccedil;&atilde;o de arquivos .avi, .flv, .mov e .mp4 na lousa<a
					href="#Enabling_Recording_and_import_of_.avi,_.flv,_.mov_and_.mp4_into"
					class="section_anchor"></a>
			</h4>
			<ul>
				<li>Instale <strong>FFMpeg</strong>. Voc&ecirc; deve obter a vers&atilde;o mais atual do FFMPEG!
					Para Windows voc&ecirc; pode baixar a versão compilada, por exemplo, 
					de <a target="_blank" href="http://ffmpeg.arrozcru.org/builds/"
					rel="nofollow">http://ffmpeg.arrozcru.org/builds/</a>. Usu&aacute;rios Linux ou OSx
					dever&atilde;o utilizar uma das diversas instru&ccedil;&otilde;es de instala&ccedil;&atilde;o 
					existentes na Web. Voc&ecirc; precisa habilitar o libmp3lame!
				</li>
				<li>Instale <strong>SoX</strong> <a
					href="http://sox.sourceforge.net/" target="_BLANK">http://sox.sourceforge.net/</a>.
					Voc&ecirc; deve instalar a vers&atilde;o mais recente do SoX! 
					SoX 12.xx N&Atilde;O funcionar&aacute;!
				</li>
			</ul>
		</li>
	</ol>

	<br />
	<b> <span style="font-size: 1.2em">Se voc&ecirc; tiver outras d&uacute;vidas ou precisar de suporte para a 
		instala&ccedil;&atilde;o ou hospedagem:</span></b>
	<br />
	<br />

	<b><span style="font-size: 1.2em">Suporte da comunidade:</span></b>
	<br />
	<br />
	<span style="font-size: 1.1em"><a
		href="http://openmeetings.apache.org/mail-lists.html"
		target="_blank">Lista de discuss&atilde;o</a></span>
	<br />
        <br />
	
	<b> <span style="font-size: 1.4em">Existem algumas empresas que tamb&eacute;m oferecem suporte comercial para o Apache OpenMeetings:</span></b>
    <br />
    <br />
    <span style="font-size: 1.3em"><a
        href="http://openmeetings.apache.org/commercial-support.html"
        target="_blank">http://openmeetings.apache.org/commercial-support.html</a></span>
    <br />
	]]></entry>
	<entry key="install.wizard.params.step1.userdata"><![CDATA[Dados do usu&aacute;rio]]></entry>
	<entry key="install.wizard.params.step1.username"><![CDATA[Usu&aacute;rio]]></entry>
	<entry key="install.wizard.params.step1.username.title"><![CDATA[Digite um usu&aacute;rio]]></entry>
	<entry key="install.wizard.params.step1.password">Senha</entry>
	<entry key="install.wizard.params.step1.password.title">Digite uma senha</entry>
	<entry key="install.wizard.params.step1.email">E-Mail</entry>
	<entry key="install.wizard.params.step1.email.title">Digite um e-mail</entry>
	<entry key="install.wizard.params.step1.tz">Time Zone</entry>
	<entry key="install.wizard.params.step1.groupdata"><![CDATA[Organização (Dom&iacute;nios)]]></entry>
	<entry key="install.wizard.params.step1.group">Nome</entry>
	<entry key="install.wizard.params.step1.group.title"><![CDATA[Digite a Organiza&ccedil;&atilde;o padr&atilde;o]]></entry>

	<entry key="install.wizard.params.step2.configuration">Configuration</entry>
	<entry key="install.wizard.params.step2.allowFrontendRegister">Permitir auto-cadastro (allow_frontend_register)</entry>
	<entry key="install.wizard.params.step2.sendEmailAtRegister"><![CDATA[Enviar e-mail para novos Usu&aacute;rios cadastrados (sendEmailAtRegister)]]></entry>
	<entry key="install.wizard.params.step2.sendEmailWithVerficationCode"><![CDATA[Novos Usu&aacute;rios precisam validar seus e-mails (sendEmailWithVerficationCode)]]></entry>
	<entry key="install.wizard.params.step2.createDefaultRooms"><![CDATA[Todos os tipos de Salas padr&atilde;o ser&atilde;o criadas]]></entry>
	<entry key="install.wizard.params.step2.mailReferer">E-mail do sistema (system_email_addr)</entry>
	<entry key="install.wizard.params.step2.mailReferer.title">Digite um e-mail</entry>
	<entry key="install.wizard.params.step2.smtpServer">Servidor SMTP (smtp_server)</entry>
	<entry key="install.wizard.params.step2.smtpServer.title">Digite um servidor SMTP</entry>
	<entry key="install.wizard.params.step2.smtpPort"><![CDATA[Porta SMTP (a porta SMTP padr&atilde;o &eacute; 25) (smtp_port)]]></entry>
	<entry key="install.wizard.params.step2.smtpPort.title"><![CDATA[Digite a porta do servi&ccedil;o SMTP. Padr&atilde;o &eacute; normalmente a porta 25]]></entry>
	<entry key="install.wizard.params.step2.mailAuthName"><![CDATA[Usu&aacute;rio SMTP (email_username)]]></entry>
	<entry key="install.wizard.params.step2.mailAuthName.title"><![CDATA[Digite o usu&aacute;rio do e-mail]]></entry>
	<entry key="install.wizard.params.step2.mailAuthPass">Senha SMTP (email_userpass)</entry>
	<entry key="install.wizard.params.step2.mailAuthPass.title">Digite a senha do e-mail</entry>
	<entry key="install.wizard.params.step2.mailUseTls"><![CDATA[Habilitar TLS na autentica&ccedil;&atilde;o do e-mail]]></entry>
	<entry key="install.wizard.params.step2.replyToOrganizer"><![CDATA[Incluir endere&ccedil;o de e-mail do convidador no campo "Responder Para" do e-mail enviado ao convidado (inviter.email.as.replyto)]]></entry>
	<entry key="install.wizard.params.step2.defaultLangId"><![CDATA[Linguagem padr&atilde;o]]></entry>
	<entry key="install.wizard.params.step2.defaultExportFont"><![CDATA[Fonte padr&atilde;o para exporta&ccedil;&atilde;o [default_export_font]]]></entry>

	<entry key="install.wizard.params.step3.converters">Conversores</entry>
	<entry key="install.wizard.params.step3.seeAlso"> Veja mais em </entry>
	<entry key="install.wizard.params.step3.installation"><![CDATA[Instala&ccedil;&atilde;o]]></entry>
	<entry key="install.wizard.params.step3.swfZoom">SWFTools Zoom</entry>
	<entry key="install.wizard.params.step3.swfZoom.title"><![CDATA[Digite o dpi que o swftools usar&aacute; para a convers&atilde;o do PDF para SWF]]></entry>
	<entry key="install.wizard.params.step3.swfZoom.text"><![CDATA[
		Voc&ecirc; pode testar se o swftools está instalado no caminho do sistema
		abrindo o shell ou prompt de comando e digitando pdf2swf. Digite o dpi 
		que o swftools usar&aacute; para a convers&atilde;o do PDF para SWF. O padr&atilde;o 
		&eacute; 100 dpi.
	]]></entry>
	<entry key="install.wizard.params.step3.swfJpegQuality">Qualidade JPEG no SWFTools</entry>
	<entry key="install.wizard.params.step3.swfJpegQuality.title"><![CDATA[Digite a qualidade das imagens jpeg incorporadas. 0 &eacute; a pior (menor), 100 &eacute; a melhor (maior). (padr&atilde;o:85)]]></entry>
	<entry key="install.wizard.params.step3.swfJpegQuality.text"><![CDATA[
		Voc&ecirc; pode testar se o swftools está instalado no caminho do sistema
		abrindo o shell ou prompt de comando e digitando pdf2swf. Digite a qualidade das 
		imagens jpeg incorporadas. 0 &eacute; a pior (menor), 100 &eacute; a melhor (maior). 
		(padr&atilde;o:85).
	]]></entry>
	<entry key="install.wizard.params.step3.swfPath"><![CDATA[Diret&oacute;rio do SWFTools]]></entry>
	<entry key="install.wizard.params.step3.swfPath.title"><![CDATA[Digite o caminho do diret&oacute;rio para o swftools, por exemplo C:/swftools, ou deixe em branco se o swftools estiver localizado em um diret&oacute;rio contido no caminho do sistema (system path)]]></entry>
	<entry key="install.wizard.params.step3.swfPath.text"><![CDATA[
		Voc&ecirc; pode testar se o swftools está instalado no caminho do sistema
		abrindo o shell ou prompt de comando e digitando pdf2swf. Se isso mostrar 
		uma lista de op&ccedil;&otilde;es deixe este campo em branco, caso contr&aacute;rio 
		voc&ecirc; dever&aacute; especificar o diret&oacute;rio 
		do pdf2swf no seu sistema.
	]]></entry>
	<entry key="install.wizard.params.step3.imageMagicPath"><![CDATA[Diret&oacute;rio do ImageMagick]]></entry>
	<entry key="install.wizard.params.step3.imageMagicPath.title"><![CDATA[Digite o caminho do diret&oacute;rio para o ImageMagick, deixe em branco se o ImageMagick estiver localizado em um diret&oatilde;rio contido no caminho do sistema (system path)]]></entry>
	<entry key="install.wizard.params.step3.imageMagicPath.text"></entry>
	<entry key="install.wizard.params.step3.ffmpegPath"><![CDATA[Diret&oacute;rio do FFMPEG]]></entry>
	<entry key="install.wizard.params.step3.ffmpegPath.title"><![CDATA[Digite o caminho do diret&oacute;rio do para o FFMPEG, deixe em branco se o FFMPEG estiver localizado em um diret&oatilde;rio contido no caminho do sistema (system path)]]></entry>
	<entry key="install.wizard.params.step3.ffmpegPath.text"></entry>
	<entry key="install.wizard.params.step3.soxPath"><![CDATA[Diret&oacute;rio do SoX]]></entry>
	<entry key="install.wizard.params.step3.soxPath.title"><![CDATA[Digite o caminho do diret&oacute;rio do para o SoX, deixe em branco se o SoX estiver localizado em um diret&oatilde;rio contido no caminho do sistema (system path)]]></entry>
	<entry key="install.wizard.params.step3.soxPath.text"></entry>
	<entry key="install.wizard.params.step3.jodPath"><![CDATA[Diret&oacute;rio do JOD]]></entry>
	<entry key="install.wizard.params.step3.jodPath.title"><![CDATA[O diret&oacute;rio da biblioteca JOD (http://code.google.com/p/jodconverter), configure o mesmo para o ponto onde o diret&oacute;rio lib do JOD que também contenha o arquivo jodconverter-core-version.jar]]></entry>
	<entry key="install.wizard.params.step3.jodPath.text"></entry>
	<entry key="install.wizard.params.step3.officePath"><![CDATA[Diret&oacute;rio do OpenOffice/LibreOffice para jodconverter]]></entry>
	<entry key="install.wizard.params.step3.officePath.title"><![CDATA[O diret&oacute;rio do OpenOffice/LibreOffice (opcional). Por favor configure este com o caminho real caso o jodconverter não encontre a instala&ccedil;&atilde;o do OpenOffice/LibreOffice automaticamente.]]></entry>
	<entry key="install.wizard.params.step3.officePath.text"><![CDATA[
		O diret&oacute;rio do OpenOffice/LibreOffice (opcional). 
		Por favor configure este campo com o caminho real caso o jodconverter 
		não encontre a instala&ccedil;&atilde;o do OpenOffice/LibreOffice automaticamente.
	]]></entry>

	<entry key="install.wizard.params.step4.crypt">Crypt Type</entry>
	<entry key="install.wizard.params.step4.cryptClassName">Classe Crypt</entry>
	<entry key="install.wizard.params.step4.cryptClassName.title"><![CDATA[Digite o nome da Classe de Criptografia. N&Atilde;O ALTERE ISTO SE VOC&Ecirc; N&Atilde;O TIVER CERTEZA]]></entry>
	<entry key="install.wizard.params.step4.cryptClassName.text"><![CDATA[
		Voc&ecirc; pode usar este tipo padr&atilde;o de criptografia que &eacute; igual a 
		fun&ccedil;&atilde;o PHP-MD5 ou a criptografia BSD-Style 
		utilizando: <b>org.apache.openmeetings.utils.crypt.MD5CryptImplementation</b>. 
		Para maiores informa&ccedil;&otilde;es ou para escrever seu pr&oacute;prio Crypt-Style 
		veja: <a
		href="http://openmeetings.apache.org/CustomCryptMechanism.html"
		target="_blank">Mecanismo de Criptografia personalizado</a>
		Voc&ecirc; pode editar este valor mais tarde MAS Usu&aacute;rios e Sess&otilde;es 
		criados podem n&atilde;o mais estar acess&iacute;veis.
	]]></entry>
	<entry key="install.wizard.params.step4.red5SIP"><![CDATA[Configura&ccedil;&atilde;o red5SIP]]></entry>
	<entry key="install.wizard.params.step4.red5SipEnable">Habilitar SIP</entry>
	<entry key="install.wizard.params.step4.red5SipEnable.text"><![CDATA[Habilitar integra&ccedil;&atilde;o red5SIP]]></entry>
	<entry key="install.wizard.params.step4.red5SipRoomPrefix">Prefixo de salas SIP</entry>
	<entry key="install.wizard.params.step4.red5SipRoomPrefix.text"><![CDATA[Prefixo de n&uacute;mero de telefone das salas de conferencia]]></entry>
	<entry key="install.wizard.params.step4.red5SipExtenContext"><![CDATA[Contexto de extens&otilde;s SIP]]></entry>
	<entry key="install.wizard.params.step4.red5SipExtenContext.text"><![CDATA[Contexto de extens&otilde;es Asterisk]]></entry>

	<entry key="install.wizard.install.desc"><![CDATA[Por favor clique no botão "Finalizar" para inicar a instalação!]]></entry>
	<entry key="install.wizard.install.started">Por favor aguarde, instalação em progresso</entry>
	<entry key="install.wizard.install.failed">Instalação falhou</entry>

	<entry key="install.wizard.congrats.enter">Acesse o Aplicativo</entry>
	<entry key="install.wizard.congrats.port"><![CDATA[Se seu servidor Red5 &eacute; executado em uma porta ou dom&iacute;nio diferente]]></entry>
	<entry key="install.wizard.congrats.config"><![CDATA[altere os valores da configura&ccedil;&atilde;o do cliente]]></entry>
	<entry key="install.wizard.congrats.mail"><![CDATA[Listas de discuss&atilde;o]]></entry>
	<entry key="install.wizard.congrats.commercial"><![CDATA[Existem algumas empresas que tamb&eacute;m oferecem suporte comercial para o Apache OpenMeetings:]]></entry>
</properties>
