Replace QObject, QWidget, QImage, QPair, QRgb, QColor, QChar, QString, QIODevice with TQ* version

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>

1 files changed, 20 insertions, 20 deletions

diff --git a/tde-i18n-pt/docs/tdevelop/kde_app_devel/index.docbook b/tde-i18n-pt/docs/tdevelop/kde_app_devel/index.docbook
index ec09cd92b61..647f8662dba 100644
--- a/tde-i18n-pt/docs/tdevelop/kde_app_devel/index.docbook
+++ b/tde-i18n-pt/docs/tdevelop/kde_app_devel/index.docbook
@@ -160,15 +160,15 @@ return a.exec();
 </orderedlist> 
 </para>
 <para>O segundo objecto do nosso programa é o botão, uma instância da classe <classname>QPushButton</classname>. A partir dos dois construtores fornecidos para criar uma instância, nós optámos pelo segundo: este aceita um texto, o qual é o conteúdo do texto do botão; neste caso, é o texto "Olá mundo!". Aí, chamou-se o método <methodname>resize()</methodname> para alterar as dimensões do botão de acordo com o seu conteúdo - o botão tem de ser maior para tornar o texto completamente visível. </para>
-<para>Mas e o método <methodname>show()</methodname>? Agora, você verá que, como a maioria dos outros itens, a classe <classname>QPushButton</classname> baseia-se numa herança simples ou, como diz a documentação, herda de <classname>QButton</classname>. Siga a referência à classe <classname>QButton</classname>. Isto mostra-lhe que bastantes outros itens herdados pela <classname>QPushButton</classname>, os quais iremos usar posteriormente para explicar o mecanismo de 'signals'/'slots' De qualquer forma, o método <methodname>show()</methodname> não aparece, como tal, deverá ser um método que é fornecido por herança, da mesma forma. A classe que a <classname>QButton</classname> herda é a <classname>QWidget</classname>. Siga de novo a ligação e você irá ver um conjunto enorme de classes que a <classname>QWidget</classname> oferece, incluindo o método <methodname>show()</methodname>. Agora dá para perceber o que foi feito no exemplo com o botão: <orderedlist>
+<para>Mas e o método <methodname>show()</methodname>? Agora, você verá que, como a maioria dos outros itens, a classe <classname>QPushButton</classname> baseia-se numa herança simples ou, como diz a documentação, herda de <classname>QButton</classname>. Siga a referência à classe <classname>QButton</classname>. Isto mostra-lhe que bastantes outros itens herdados pela <classname>QPushButton</classname>, os quais iremos usar posteriormente para explicar o mecanismo de 'signals'/'slots' De qualquer forma, o método <methodname>show()</methodname> não aparece, como tal, deverá ser um método que é fornecido por herança, da mesma forma. A classe que a <classname>QButton</classname> herda é a <classname>TQWidget</classname>. Siga de novo a ligação e você irá ver um conjunto enorme de classes que a <classname>TQWidget</classname> oferece, incluindo o método <methodname>show()</methodname>. Agora dá para perceber o que foi feito no exemplo com o botão: <orderedlist>
 <listitem><para>Cria uma instância de <classname>QPushButton</classname>, utiliza o segundo construtor para configurar o texto do botão</para></listitem>
 <listitem><para>Muda o tamanho do 'widget' de acordo com o seu conteúdo</para></listitem>
 <listitem><para>Escolhe o 'widget' como o 'widget' principal da instância do <classname>QApplication</classname> como</para></listitem>
-<listitem><para>Diz ao 'widget' para se mostrar no ecrã chamando <methodname>show()</methodname>, um método herdado de <classname>QWidget</classname></para></listitem>
+<listitem><para>Diz ao 'widget' para se mostrar no ecrã chamando <methodname>show()</methodname>, um método herdado de <classname>TQWidget</classname></para></listitem>
 </orderedlist>
 </para>
 <para>Depois de invocar o método <methodname>exec()</methodname>, a aplicação fica visível para o utilizador, mostrando uma janela com o botão a dizer "Olá mundo!". Nota: os programas gráficos comportam-se de forma ligeiramente diferente da das aplicações procedimentais. A questão principal aqui é que a aplicação entra num estado chamado de "ciclo de eventos principal". Isto significa que o programa tem de esperar pelas acções do utilizador e então reagir a elas e que, numa aplicação do Qt, o programa terá de entrar no ciclo de eventos principal para conseguir começar a tratá-los. A próxima secção diz-lhe em resumo o que isto significa para o programador e o que é que o Qt oferece para processar os eventos do utilizador. </para>
-<note><para>Para os utilizadores já avançados: O botão não tem nenhuma janela-mãe declarada no construtor, o que significa que é um item gráfico de topo por si só e corre num ciclo de eventos local que não precisa de esperar pelo ciclo de eventos principal. Veja a documentação da classe QWidget e o Guia de Referência da Biblioteca do KDE</para>
+<note><para>Para os utilizadores já avançados: O botão não tem nenhuma janela-mãe declarada no construtor, o que significa que é um item gráfico de topo por si só e corre num ciclo de eventos local que não precisa de esperar pelo ciclo de eventos principal. Veja a documentação da classe TQWidget e o Guia de Referência da Biblioteca do KDE</para>
 </note> 
 
 </sect3>
@@ -183,7 +183,7 @@ return a.exec();
 </itemizedlist> 
 </para>
 <para>Agora vamos dar "vida" à aplicação, processando os eventos do utilizador. De um modo geral, o utilizador tem duas formas de interagir com um programa: o rato e o teclado. Para ambas as formas, uma interface gráfica tem de fornecer métodos que detectem as acções e métodos que façam algo em reacção a estas acções. </para> 
-<para>O sistema de janelas envia deste modo todos os eventos de interacção para a aplicação respectiva. A <classname>QApplication</classname> envia-os então para a janela activa como um <classname>QEvent</classname> e os próprios itens terão de decidir o que fazer com eles. Um item recebe o evento e processa o <methodname>QWidget::event(QEvent*)</methodname>, que decide então qual o evento que foi executado e como reagir; o <methodname>event()</methodname> é deste modo o tratador de eventos principal. Aí, o método <methodname>event()</methodname> passa o evento para os denominados de filtros de eventos que determinam o que se passou e o que fazer com o evento. Se nenhum filtro responder como responsável pelo evento, os tratadores de eventos especializados são invocados. Deste modo, pode-se optar entre: <itemizedlist>
+<para>O sistema de janelas envia deste modo todos os eventos de interacção para a aplicação respectiva. A <classname>QApplication</classname> envia-os então para a janela activa como um <classname>QEvent</classname> e os próprios itens terão de decidir o que fazer com eles. Um item recebe o evento e processa o <methodname>TQWidget::event(QEvent*)</methodname>, que decide então qual o evento que foi executado e como reagir; o <methodname>event()</methodname> é deste modo o tratador de eventos principal. Aí, o método <methodname>event()</methodname> passa o evento para os denominados de filtros de eventos que determinam o que se passou e o que fazer com o evento. Se nenhum filtro responder como responsável pelo evento, os tratadores de eventos especializados são invocados. Deste modo, pode-se optar entre: <itemizedlist>
 <listitem><para>Eventos de teclados -- teclas TAB e Shift-TAB:</para>
 <itemizedlist>
 <listitem><para><methodname>virtual void focusInEvent(QFocusEvent *)</methodname></para></listitem>
@@ -224,12 +224,12 @@ return a.exec();
 
 </itemizedlist>
 </para>
-<para>Lembre-se que todas as funções de eventos são virtuais e protegidas; como tal, você poderá reimplementar os eventos que necessitar nos seus próprios itens gráficos e indicar como é que o seu item terá de reagir. O <classname>QWidget</classname> contém também outros métodos virtuais que poderão ser úteis nos seus programas; de qualquer forma, é suficiente conhecer o <classname>QWidget</classname> bastante bem. </para>
+<para>Lembre-se que todas as funções de eventos são virtuais e protegidas; como tal, você poderá reimplementar os eventos que necessitar nos seus próprios itens gráficos e indicar como é que o seu item terá de reagir. O <classname>TQWidget</classname> contém também outros métodos virtuais que poderão ser úteis nos seus programas; de qualquer forma, é suficiente conhecer o <classname>TQWidget</classname> bastante bem. </para>
 </sect2>
 <sect2 id="c1s2s4">
 <title>Interacção de Objectos através de 'Signals' e 'Slots'</title>
 <para>Agora chegámos às vantagens mais óbvias da plataforma do Qt: o mecanismo de 'signals'/'slots'. Isto oferece uma solução bastante útil e fácil de os objectos interagirem entre si, o que normalmente é resolvido por funções de resposta ('callback') pelas bibliotecas do X-Window. Dado que esta documentação necessita de uma programação restrita e normalmente torna a criação de interface do utilizador muito complicada (como é referido pela documentação do Qt e é explicado no texto 'Programming with Qt' de K.Dalheimer), a Troll Tech inventou um novo sistema onde os objectos podem emitir sinais ('signals') que podem estar associados a métodos denominados por 'slots'. Para a parte de C++ do programador, ele só terá de conhecer algumas coisas sobre este mecanismo: <itemizedlist>
-<listitem><para>a declaração de uma classe que utilize 'signals'/'slots' tem que ter a macro TQ_OBJECT no início (sem ponto e vírgula); e tem que ser derivada da classe <classname>QObject</classname> </para></listitem>
+<listitem><para>a declaração de uma classe que utilize 'signals'/'slots' tem que ter a macro TQ_OBJECT no início (sem ponto e vírgula); e tem que ser derivada da classe <classname>TQObject</classname> </para></listitem>
 <listitem><para>um 'signal' pode ser emitido através da palavra chave 'emit', por exemplo, emit signal(parâmetros);, de qualquer método membro de uma classe que permite 'signals'/'slots' </para></listitem>
 
 <listitem><para>todos os 'signals' utilizados pelas classes que não são herdados tem que ser adicionados à declaração da classe numa secção 'signals' </para></listitem>
@@ -237,9 +237,9 @@ return a.exec();
 <listitem><para>o compilador de meta-objectos 'moc' tem de correr sobre o ficheiro de inclusão para expandir as macros e para produzir a implementação (que é necessário conhecer). Os ficheiros de resultado do 'moc' são compilados também pelo compilador de C++. </para></listitem>
 </itemizedlist>
 </para>
-<para>Outra forma de usar os 'signals' sem derivar da classe <classname>QObject</classname> é usar a classe <classname>QSignal</classname> - veja a documentação de referência para mais informações e para um exemplo de utilização. No seguinte, assume-se que você vai derivar de <classname>QObject</classname>. </para>
+<para>Outra forma de usar os 'signals' sem derivar da classe <classname>TQObject</classname> é usar a classe <classname>QSignal</classname> - veja a documentação de referência para mais informações e para um exemplo de utilização. No seguinte, assume-se que você vai derivar de <classname>TQObject</classname>. </para>
 <para>Desta forma, a sua classe é capaz de enviar 'signals' para todo o lado e consegue fornecer 'slots' aos quais os 'signals' se possam ligar. Usando os 'signals', você não terá de se preocupar com que os recebe - só tem de emitir os 'signals' e qual o 'slot' que lhe deseja ligar para reagir à emissão. Os 'slots' também podem ser usados como métodos normais durante a implementação. </para>
-<para>Agora, para ligar um 'signal' a um 'slot', você terá de usar os métodos <methodname>connect()</methodname> que são fornecidos pelo <classname>QObject</classname> ou, quando for possível, os métodos especiais que os objectos fornecem para definir a ligação a um dado 'signal'. </para>
+<para>Agora, para ligar um 'signal' a um 'slot', você terá de usar os métodos <methodname>connect()</methodname> que são fornecidos pelo <classname>TQObject</classname> ou, quando for possível, os métodos especiais que os objectos fornecem para definir a ligação a um dado 'signal'. </para>
 
 <sect3 id="c1s2s4s1">
 <title>Exemplo de Utilização</title>
@@ -262,9 +262,9 @@ return a.exec();
 }
 </programlisting>
 </para>
-<para>Como vê, a única adição para dar ao botão mais interacção é usar um método <methodname>connect() </methodname>: o <methodname>connect(&amp;ola, SIGNAL( clicked() ), &amp;a, SLOT( quit() ))</methodname>; é tudo o que você tem para adicionar. Qual é o significado? A declaração da classe do QObject fala sobre o método <methodname>connect()</methodname>: </para>
-<para><methodname>bool connect ( const QObject * emissor, const char * signal, const QObject * receptor, const char * membro ) </methodname></para>
-<para>Isto significa que você terá de indicar um ponteiro para uma instância de um <classname>QObject</classname> que é o emissor do 'signal', o que significa que ele poderá emitir este 'signal' como primeiro parâmetro; depois, terá de indicar o 'signal' a que se deseja ligar. Os últimos dois parâmetros são o objecto receptor que contém um 'slot' seguido da função-membro que é, de facto, o 'slot' que será executado devido à emissão do 'signal'. </para>
+<para>Como vê, a única adição para dar ao botão mais interacção é usar um método <methodname>connect() </methodname>: o <methodname>connect(&amp;ola, SIGNAL( clicked() ), &amp;a, SLOT( quit() ))</methodname>; é tudo o que você tem para adicionar. Qual é o significado? A declaração da classe do TQObject fala sobre o método <methodname>connect()</methodname>: </para>
+<para><methodname>bool connect ( const TQObject * emissor, const char * signal, const TQObject * receptor, const char * membro ) </methodname></para>
+<para>Isto significa que você terá de indicar um ponteiro para uma instância de um <classname>TQObject</classname> que é o emissor do 'signal', o que significa que ele poderá emitir este 'signal' como primeiro parâmetro; depois, terá de indicar o 'signal' a que se deseja ligar. Os últimos dois parâmetros são o objecto receptor que contém um 'slot' seguido da função-membro que é, de facto, o 'slot' que será executado devido à emissão do 'signal'. </para>
 <para>Usando os 'signals' e 'slots', os objectos do seu programa podem interagir uns com os outros facilmente sem terem de explicitamente depender do tipo do objecto receptor. Você irá aprender mais sobre a utilização deste mecanismo para uma utilização produtiva posteriormente neste manual. Se quiser saber mais informações sobre o mecanismo de 'signals'/'slots' poderá ir ao <ulink url="developer.kde.org/documentation/library/libraryref.html">Guia de Referência da Biblioteca do KDE</ulink> e à <ulink url="doc.trolltech.com">referência 'online' do Qt</ulink>. </para>
 </sect3>
 </sect2>
@@ -313,7 +313,7 @@ return a.exec();
 </para> 
 <para>Você irá constatar que, primeiro, mudámos da <classname>QApplication</classname> para a <classname>TDEApplication </classname>. Para além disso, tivemos de mudar o método <methodname>setMainWidget()</methodname> para <methodname>setTopWidget</methodname>, o qual a classe <classname>TDEApplication</classname> usa para indicar qual o item principal. É tudo! A sua primeira aplicação do KDE está pronta - você só terá de indicar ao compilador a localização dos ficheiros de inclusão e ao editor de ligações para compilar com a biblioteca 'tdecore', através da opção'-ltdecore'. </para>
 <para>Dado que já sabe o que, pelo menos, a função <function>main()</function> necessita geralmente e como é que uma aplicação fica visível e permite a interacção com o utilizador e com os objectos, iremos agora para o próximo capítulo, onde a nossa primeira aplicação será criada com o &tdevelop;. Aí, você também poderá testar tudo o que foi mencionado antes e ver os efeitos. </para>
-<para>O que você deverá ter olhado adicionalmente até agora é a documentação de referência do Qt, especialmente a as classes <classname>QApplication</classname>, <classname>QWidget</classname> e <classname>QObject </classname>, assim como a documentação da biblioteca 'tdecore' para a classe <classname>TDEApplication</classname>. O <ulink url="developer.kde.org/documentation/library/libraryref.html">Manual de Referência da Biblioteca do KDE</ulink> também cobre uma descrição completa da invocação dos construtores da <classname>QApplication</classname> e da <classname>TDEApplication</classname>, incluindo o processamento dos argumentos da linha de comandos. </para>
+<para>O que você deverá ter olhado adicionalmente até agora é a documentação de referência do Qt, especialmente a as classes <classname>QApplication</classname>, <classname>TQWidget</classname> e <classname>TQObject </classname>, assim como a documentação da biblioteca 'tdecore' para a classe <classname>TDEApplication</classname>. O <ulink url="developer.kde.org/documentation/library/libraryref.html">Manual de Referência da Biblioteca do KDE</ulink> também cobre uma descrição completa da invocação dos construtores da <classname>QApplication</classname> e da <classname>TDEApplication</classname>, incluindo o processamento dos argumentos da linha de comandos. </para>
 </sect2>
 </sect1>
 
@@ -549,10 +549,10 @@ return a.exec();
 16     statusBar()->show();
 17 
 18     // permitir à vista mudar a barra de estado e o título
-19     connect(m_view, SIGNAL(signalChangeStatusbar(const QString&amp;)),
-20             this,   SLOT(changeStatusbar(const QString&amp;)));
-21     connect(m_view, SIGNAL(signalChangeCaption(const QString&amp;)),
-22             this,   SLOT(changeCaption(const QString&amp;)));
+19     connect(m_view, SIGNAL(signalChangeStatusbar(const TQString&amp;)),
+20             this,   SLOT(changeStatusbar(const TQString&amp;)));
+21     connect(m_view, SIGNAL(signalChangeCaption(const TQString&amp;)),
+22             this,   SLOT(changeCaption(const TQString&amp;)));
 23
 24  }
 </programlisting>
@@ -584,7 +584,7 @@ return a.exec();
 </itemizedlist>
 </para>
 <para>Escusado será dizer que a estabilidade é um grande objectivo de desenho. Ninguém poderá evitar os erros, mas poderemos obter um mínimo se tivermos objectivos de desenho inteligentes e um uso abrangente de desenho orientado por objectos. O C++ torna a programação uma alegria se você souber como explorar as suas capacidades - a herança, o isolamento de informação e a reutilização de código já existente. </para>
-<para>Ao criar um projecto do KDE ou do Qt, você terá de ter sempre uma vista que herde de QWidget, quer por herança directa, ou então porque o item da biblioteca que deseja usar herda do QWidget. Como tal, o Assistente de Aplicações já construiu uma vista que é uma instância de uma classe suaAplicacaoView, a qual já herda de QWidget. </para>
+<para>Ao criar um projecto do KDE ou do Qt, você terá de ter sempre uma vista que herde de TQWidget, quer por herança directa, ou então porque o item da biblioteca que deseja usar herda do TQWidget. Como tal, o Assistente de Aplicações já construiu uma vista que é uma instância de uma classe suaAplicacaoView, a qual já herda de TQWidget. </para>
 <para>Este capítulo descreve, deste modo, como usar os itens das bibliotecas para criar vistas das aplicações do KDE e do QT que sejam geradas com o &tdevelop;, e iremos depois olhar para os tipos de vistas que já são oferecidas. </para>
 </sect1>
 <sect1 id="c4s2">
@@ -601,7 +601,7 @@ return a.exec();
 <para>Olhando para a primeira página da documentação 'online' do Qt, você irá ver uma referência a "Widget Screenshots" (Imagens dos Elementos Gráficos), onde você poderá ver como é que o itens que o Qt contém irão ficar. Eles estão prontos a usar e podem ser combinados em conjunto para forma itens mais complexos, de modo a criar vistas de aplicações ou janelas. A seguir, iremos discutir alguns destes itens que são muito úteis para criar vistas de aplicações; tenha contudo em mente que as bibliotecas do KDE algumas vezes contêm outros itens para o mesmo fim; estes serão revistos na próxima secção. </para>
 <para>Aqui está um conjunto de sugestões sobre o fim para que você irá usar um determinado componente do Qt: <orderedlist>
 <listitem><para>Se a área da sua janela não for grande o suficiente para mostrar todos os seus dados, o utilizador irá precisar de se deslocar pelo documento através de barras à esquerda e em baixo na janela. Para isso, o Qt oferece a classe <classname>QScrollView</classname>, que oferece uma área-filha que poderá ser posicionável. Como foi dito, você poderá herdar o seu próprio item de <classname>QScrollView</classname> ou usar uma instância para gerir o item da vista do seu documento. </para></listitem> 
-<listitem><para>Para criar você próprio uma ScrollView, herde o item da vista da classe <classname>QWidget</classname> e adicione <classname>QScrollBars </classname> verticais e horizontais. (Isto é feito pelo item TDEHTMLView do KDE). </para></listitem> 
+<listitem><para>Para criar você próprio uma ScrollView, herde o item da vista da classe <classname>TQWidget</classname> e adicione <classname>QScrollBars </classname> verticais e horizontais. (Isto é feito pelo item TDEHTMLView do KDE). </para></listitem> 
 <listitem><para>Para processar texto, use a <classname>QTextEdit</classname>. Esta classe fornece um elemento gráfico de edição de texto completo que já é capaz de cortar, copiar e colar texto e é gerido por uma vista posicionável. </para></listitem> 
 <listitem><para>Use a <classname>QTable</classname> para mostrar dados organizados numa tabela. Dado que a <classname>QTable</classname> usa também barras de posicionamento, é uma boa solução para aplicações de cálculos de tabelas. </para></listitem> 
 <listitem><para>Para mostrar dois itens diferentes ou duas janelas ao mesmo tempo, use o <classname>QSplitter </classname>. Isto permite pôr lado-a-lado as vistas com divisões horizontais ou verticais. O KMail é um bom exemplo do que isto iria parecer - a área principal é separada na vertical por uma divisória e a área do lado direito é, por sua vez, dividida de novo na horizontal. </para></listitem> 
@@ -653,7 +653,7 @@ return a.exec();
 <title>Configuração de Aceleradores de Teclado</title>
 <para>Uma coisa muito profissional que você deverá sempre adicionar à sua aplicação são os aceleradores de teclado. Estes são principalmente usados pelos utilizadores experientes que gostam de trabalhar depressa com as suas aplicações e que estão dispostos a aprender atalhos. Para isso, as bibliotecas do KDE fornecem a classe <classname> TDEAction</classname>, que fornece as teclas de atalho do teclado e o acesso aos aceleradores-padrão de teclado, configurados a nível global. </para>
 <para>Por omissão, as aplicações gráficas geradas pelo &tdevelop; só usam os aceleradores de teclado normais, como o F1 para aceder à ajuda 'online', o Ctrl+N para Novo Ficheiro, etc. </para>
-<para>Se a sua aplicação contiver um conjunto de aceleradores, você deverá torná-los configuráveis num menu de opções; tanto poderão estar em conjunto com outras configurações da aplicação numa QWidget como usados isoladamente. A biblioteca do KDE já fornece uma classe <classname>KKeyChooser</classname> para ser usada em páginas de uma janela, enquanto que a <classname>KKeyDialog</classname> fornece uma janela de configuração de teclas pronta a usar. </para>
+<para>Se a sua aplicação contiver um conjunto de aceleradores, você deverá torná-los configuráveis num menu de opções; tanto poderão estar em conjunto com outras configurações da aplicação numa TQWidget como usados isoladamente. A biblioteca do KDE já fornece uma classe <classname>KKeyChooser</classname> para ser usada em páginas de uma janela, enquanto que a <classname>KKeyDialog</classname> fornece uma janela de configuração de teclas pronta a usar. </para>
 
 </sect1>
 </chapter>
@@ -696,7 +696,7 @@ return a.exec();
 <sect1 id="c8s4">
 <title>O Botão <guibutton>O que é Isto...?</guibutton></title>
 <para>O botão <guibutton>O Que É Isto...?</guibutton> fornece janelas de ajuda com a intenção de que o utilizador quer obter ajuda sobre um determinado elemento na área de trabalho ou sobre um item da barra de ferramentas. É colocado na barra de ferramentas e é activado logo que o utilizador carregue no botão. O cursor muda para uma seta com um ponto de interrogação semelhante ao que o botão tem. O utilizador então poderá carregar num item visível para obter uma janela de ajuda. Como exercício, você poderá tentar este comportamento com o botão <guibutton>O que é isto...?</guibutton> no &tdevelop;. </para>
-<para>Para adicionar a ajuda 'O Que É Isto...?' a um dos seus itens gráficos, use o método estático <methodname>QWhatsThis::add(QWidget *item, const QString &amp;texto)</methodname> </para>
+<para>Para adicionar a ajuda 'O Que É Isto...?' a um dos seus itens gráficos, use o método estático <methodname>QWhatsThis::add(TQWidget *item, const TQString &amp;texto)</methodname> </para>
 </sect1>
 </chapter>