Página principal   Módulos   Lista de namespaces   Hierarquia de classes   Lista de componentes   Lista de ficheiros   Membros do namespace   Componentes   Declarações   Paginas relacionadas  

Referencia à classe Slang::Ecra

Esta classe é um solitão: a sua única instância representa o ecrã. Mais...

#include <Slang/ecra.H>

Mostrar lista completa dos membros

Membros públicos

 Ecra (Cor texto=branco, Cor fundo=preto, bool limita_cursor=false)
 Construtor da classe. Mais...

 ~Ecra ()
 Destrutor da classe. Mais...

Ecra const& operator>> (Troco &troco) const
 Operador de extracção de um troço do ecrã. Mais...

Ecra& operator<< (Fundo const &)
Ecra& operator<< (Parado const &)
Ecra& operator<< (Justificacao const &)
Ecra& operator<< (Largura const &)
Ecra& operator<< (Linha const &)
Ecra& operator<< (Refresca const &)
Ecra& operator<< (RefrescaTudo const &)
Ecra& operator<< (Apaga const &)
Ecra& operator<< (ApagaFimDaLinha const &)
Ecra& operator<< (ApagaFimDoEcra const &)
Ecra& operator<< (Campainha const &)
Inspectores
Dimensao dimensao () const
 Devolve a dimensão corrente do ecrã. Mais...

Posicao cursor () const
 Devolve a posição do cursor. Mais...

bool redimensionado () const
 Indica se o ecrã foi redimensionado ou não. Mais...

Modificadores
void atributos (Cor texto, Cor fundo)
 Modifica a cor por omissão, i.e., a cor das células que constituem o fundo do ecrã. Mais...

void cursor (Posicao const &posicao)
 Modifica a posição do cursor. Mais...

void cima ()
 Desloca cursor uma linha para cima. Mais...

void baixo ()
 Desloca cursor uma linha para baixo. Mais...

void esquerda ()
 Desloca cursor uma coluna para a esquerda. Mais...

void direita ()
 Desloca cursor uma coluna para a direita. Mais...

void desloca (Tecla const &tecla)
 Desloca cursor na direcção indicada pela tecla. Mais...

Métodos para cópia e cola de troços de ecrã
Troco copia (Caixa const &caixa) const
 Devolve uma cópia de um troço do ecrã. Mais...

Troco copia () const
 Devolve uma cópia do ecrã inteiro. Mais...

Troco copia (Dimensao const &dimensao) const
 Devolve uma cópia do troço de ecrã com um dada dimensão e com origem na posição corrente do cursor. Mais...

void cola (Troco const &troco, Posicao const &origem=Posicao())
 Cola no ecrã, na posição indicada, um troço de ecrã. Mais...

Métodos para desenhar no ecrã
void campainha () const
 Toca a "campaínha" (normalmente o ecrã pisca). Mais...

void apagaFimDaLinha ()
 Apaga (i.e., pinta com cor do fundo) até ao fim da linha do cursor. Mais...

void apagaFimDoEcra ()
 Apaga (i.e., pinta com cor do fundo) até ao fim do ecrã a partir do cursor. Mais...

void apaga ()
 Apaga (i.e., pinta com cor do fundo) todo o ecrã. Mais...

void refresca () const
 Refresca o ecrã, ou seja, reflecte no ecrã real as últimas alterações realizadas no ecrã virtual. Mais...

void refrescaTudo () const
 Refresca totalmente o ecrã, ou seja, reflecte no ecrã real todo o ecrã virtual. Mais...

void desenhaCaixa (Caixa const &caixa)
 Desenha uma caixa no ecrã, sendo a borda desenhada com caracteres especiais. Mais...

Operadores de inserção no ecrã de tipos usuais
Ecra& operator<< (char c)
 Insere um caracter na posição do cursor. Mais...

Ecra& operator<< (int i)
 Insere um número inteiro na base 10 na posição do cursor. Mais...

Ecra& operator<< (string c)
 Insere uma cadeia de caracteres na posição do cursor. Mais...

Operadores de inserção de objectos especiais no ecrã
Ecra& operator<< (Caixa const &caixa)
 Desenha uma caixa no ecrã, sendo a borda desenhada com caracteres especiais. Mais...

Ecra& operator<< (Simbolo simbolo)
 Desenha um símbolo especial no ecra. Mais...

Ecra& operator<< (Troco const &troco)
 Cola no ecrã, na posição do cursor, um troço de ecrã. Mais...

Ecra& operator<< (Posicao const &posicao)
 Altera a posição do cursor para a posição dada. Mais...

Ecra& operator<< (ObjectoCor const &objecto_cor)
 Altera o objecto cor das próximas operações de escrita no ecrã (com excepção das colagens!). Mais...

Descrição detalhada

Esta classe é um solitão: a sua única instância representa o ecrã.

Note-se que o ecrã é virtual. As alterações nele feitas só têm efeito no ecrã real depois de uma operação de refrescamento!

O ecrã permite várias operações:

  1. inspeccionar a dimensão do ecrã e a posição do cursor;
  2. verificar se o ecrã foi redimensionado;
  3. modificar a posição do cursor (de várias formas diferentes);
  4. copiar ({copy}) ou colar ({paste}) um troço de/para uma posição do ecrã;
  5. apagar várias partes do ecrã;
  6. refrescar o ecrã;
  7. desenhar uma caixa no ecrã;
  8. enviar para o ecrã um caractere, um inteiro, uma cadeia de caracteres, uma caixa, um troço ou um dos manipuladores definidos;
  9. etc.

Exemplo 

        // Cria uma caixa de dimensão 10×10 com origem na posição (0,0): 
        Caixa caixa(Posicao(0, 0), Dimensao(10, 10));  
        
        // Copia o troço de ecrã que se encontra sob a caixa:
        Ecra::Troco troco = ecra.copia(caixa); 

        // Cria um novo ObjectoCor:
        Ecra::ObjectoCor cor(vermelho, verde);
        // Move o cursor para a posição (30,30), cola o troço copiado acima
        // nessa posição, muda a cor activa e refresca o ecrã de modo a que
        // estas modificações se tornem visíveis:
        ecra << cursor(30, 30) << troco << cor  << refresca;

Atenção

As alterações só são visíveis depois de chamada uma das funções de refrescamento do ecrã. Quando há um redimensionamento do ecrã deve ser chamado o procedimento refrescaTudo(). Quando são feitas pequenas alterações deve ser chamado o procedimento refresca(). Também podem ser usados os manipuladores refresca e refresca_tudo para obter o mesmo efeito.

Exemplo de utilização

Este programa escreve no ecrã todas as letras do alfabeto (maiúsculas e minúsculas) e depois, a cada pressão de uma tecla, escreve os números de zero a nove com outra cor e com largura proporcional ao número escrito. 

        #include <Slang/slang.H> 
        
        using namespace Slang; 
        
        extern "C" {
        #include <unistd.h>  // para sleep()
        }
        
        int main () 
        { 
            for(char c = 'a'; c != 'z' + 1; ++c) { 
                ecra << c << refresca; 
                sleep(1);
            } 
        
            teclado.tecla(); 
        
            Ecra::ObjectoCor cor(amarelo, azul); 
        
            ecra << cor << cursor(0, 0); 
            for (int c = 0; c != 10; ++c) { 
                ecra.baixo(); 
                ecra << parado << largura(c) << char('0' + c) << refresca; 
                teclado.tecla();
            } 
        }

Definido na linha 540 do ficheiro ecra.H.

Documentação do Construtor & Destrutor

Slang::Ecra::Ecra ( Cor texto = branco,
Cor fundo = preto,
bool limita_cursor = false ) [explicit]
 

Construtor da classe.

Tal como a biblioteca se encontra definida, este construtor não pode ser usado directamente! No entanto, numa versão futura, onde não exista variável global para representar o ecrã, o programador utilizador pode vir a usá-lo. Encarrega-se de inicializar o "screen management" Slang. Se se construir com limita_cursor true, o ecrã garantirá que o cursor se encontra dentro dos seus limites em cada instante. Por omissão essa verificação não é feita.

Parâmetros:
texto   Cor do texto das chamadas células de fundo, para as quais não foi indicado qualquer objecto cor (cor por omissão).
fundo   Cor do fundo das chamadas células de fundo, para as quais não foi indicado qualquer objecto cor (cor por omissão).
limita_cursor   Indica se a posição do cursor deve ser limitada à dimensão do ecrã.

Slang::Ecra::~Ecra ( ) [inline]
 

Destrutor da classe.

Encarrega-se de finalizar o "screen management" Slang.

Definido na linha 294 do ficheiro ecra_impl.H.

00294                         {
00295     // Terminação do slang:
00296     SLsmg_reset_smg();
00297 }

Documentação dos métodos

void Slang::Ecra::apaga ( ) [inline]
 

Apaga (i.e., pinta com cor do fundo) todo o ecrã.

Definido na linha 411 do ficheiro ecra_impl.H.

Referenciado por operator<<().

00411                              {
00412     verificaTamanho();
00413     SLsmg_cls();
00414 }

void Slang::Ecra::apagaFimDaLinha ( ) [inline]
 

Apaga (i.e., pinta com cor do fundo) até ao fim da linha do cursor.

Definido na linha 401 do ficheiro ecra_impl.H.

Referenciado por operator<<().

00401                                        {
00402     verificaTamanho();
00403     SLsmg_erase_eol();
00404 }

void Slang::Ecra::apagaFimDoEcra ( ) [inline]
 

Apaga (i.e., pinta com cor do fundo) até ao fim do ecrã a partir do cursor.

Definido na linha 406 do ficheiro ecra_impl.H.

Referenciado por operator<<().

00406                                       {
00407     verificaTamanho();
00408     SLsmg_erase_eos();
00409 }

void Slang::Ecra::atributos ( Cor texto,
Cor fundo ) [inline]
 

Modifica a cor por omissão, i.e., a cor das células que constituem o fundo do ecrã.

Parâmetros:
texto   Nova cor do texto para as células do fundo do ecrã.
fundo   Nova cor do fundo para as células do fundo do ecrã.

Definido na linha 303 do ficheiro ecra_impl.H.

00303                                                      {
00304     SLtt_set_color(0, 0, nome_de_cor[texto], nome_de_cor[fundo]);
00305 }

void Slang::Ecra::baixo ( ) [inline]
 

Desloca cursor uma linha para baixo.

Definido na linha 365 do ficheiro ecra_impl.H.

Referenciado por desloca().

00365                              {
00366     cursor(Posicao(cursor().linha() + 1, cursor().coluna()));
00367 }

void Slang::Ecra::campainha ( ) const [inline]
 

Toca a "campaínha" (normalmente o ecrã pisca).

Definido na linha 396 do ficheiro ecra_impl.H.

Referenciado por operator<<().

00396                                        {
00397     verificaTamanho();
00398     SLtt_beep();
00399 }

void Slang::Ecra::cima ( ) [inline]
 

Desloca cursor uma linha para cima.

Definido na linha 361 do ficheiro ecra_impl.H.

Referenciado por desloca().

00361                             {
00362     cursor(Posicao(cursor().linha() - 1, cursor().coluna()));
00363 }

void Slang::Ecra::cola ( Troco const & troco,
Posicao const & origem = Posicao() )
 

Cola no ecrã, na posição indicada, um troço de ecrã.

O cursor é deslocado para a posição imediatamente após a última coluna da última linha onde o troço foi colocado, a não ser que se tenha pedido para manter o cursor parado. Atenção! O objecto cor que estava a ser usado antes da colagem é perdido! As próximas escritas são feitas usando a cor do fundo.

Parâmetros:
troco   Troço a colar.
origem   Posição onde o troço deve ser colado (por omissão cola no canto superior esquerdo do ecrã).
Veja também:
parado

Referenciado por operator<<().

Slang::Ecra::Troco Slang::Ecra::copia ( Dimensao const & dimensao ) const [inline]
 

Devolve uma cópia do troço de ecrã com um dada dimensão e com origem na posição corrente do cursor.

Parâmetros:
dimensao   A dimensão do troço.

Definido na linha 325 do ficheiro ecra_impl.H.

00325                                                                      {
00326     return copia(Caixa(cursor(), dimensao));
00327 }

Slang::Ecra::Troco Slang::Ecra::copia ( ) const [inline]
 

Devolve uma cópia do ecrã inteiro.

Definido na linha 329 do ficheiro ecra_impl.H.

Referenciado por copia().

00329                                              {
00330     return copia(Caixa(Posicao(0, 0), dimensao()));
00331 }

Troco Slang::Ecra::copia ( Caixa const & caixa ) const
 

Devolve uma cópia de um troço do ecrã.

Parâmetros:
caixa   O troço do ecrã é o que se encontra sob esta caixa.

void Slang::Ecra::cursor ( Posicao const & posicao ) [inline]
 

Modifica a posição do cursor.

Parâmetros:
posicao   Nova posição do cursor: limitada ou não à dimensão do ecrã consoante o modo de construção do ecrã (por omissão não há limitação).

Definido na linha 333 do ficheiro ecra_impl.H.

00333                                                     {
00334     verificaTamanho();
00335     int linha = posicao.linha();
00336     int coluna = posicao.coluna();
00337     if(limita_cursor) {
00338         if(linha >= dimensao().linhas()) linha = dimensao().linhas() - 1;
00339         else if(linha < 0) linha = 0;
00340         
00341         if(coluna >= dimensao().colunas()) coluna = dimensao().colunas() - 1;
00342         else if(coluna < 0) coluna = 0;
00343     }
00344     SLsmg_gotorc(linha, coluna);
00345 }

Slang::Posicao Slang::Ecra::cursor ( ) const [inline]
 

Devolve a posição do cursor.

Definido na linha 312 do ficheiro ecra_impl.H.

Referenciado por baixo(), cima(), copia(), desenhaCaixa(), direita(), esquerda(), e operator<<().

00312                                             {
00313     return Posicao(SLsmg_get_row(), SLsmg_get_column());
00314 }

void Slang::Ecra::desenhaCaixa ( Caixa const & caixa ) [inline]
 

Desenha uma caixa no ecrã, sendo a borda desenhada com caracteres especiais.

Parâmetros:
caixa   Caixa a desenhar.

Definido na linha 428 do ficheiro ecra_impl.H.

Referenciado por operator<<().

00429 {
00430     verificaTamanho();
00431     // Guardar cursor inicial:
00432     Posicao posicao_original_do_cursor;
00433     if(para_no_proximo)
00434         posicao_original_do_cursor = cursor();
00435 
00436     SLsmg_draw_box(caixa.origem().linha(), caixa.origem().coluna(), 
00437                    caixa.dimensao().linhas(), caixa.dimensao().colunas());
00438 
00439     // Regressar ao cursor inicial:
00440     if(para_no_proximo) {
00441         cursor(posicao_original_do_cursor);
00442         para_no_proximo = false;
00443     }
00444 }

void Slang::Ecra::desloca ( Slang::Tecla const & tecla ) [inline]
 

Desloca cursor na direcção indicada pela tecla.

Parâmetros:
tecla   A tecla. Se for uma seta, o cursor é deslocado. Se não for, o cursor mantém-se.

Definido na linha 377 do ficheiro ecra_impl.H.

00377                                                       {
00378     switch(tecla) {
00379       case Tecla::cima:
00380         cima();
00381         break;
00382       case Tecla::baixo:
00383         baixo();
00384         break;
00385       case Tecla::esquerda:
00386         esquerda();
00387         break;
00388       case Tecla::direita:
00389         direita();
00390         break;
00391       default:
00392         break;
00393     }
00394 }

Slang::Dimensao Slang::Ecra::dimensao ( ) const [inline]
 

Devolve a dimensão corrente do ecrã.

Definido na linha 307 do ficheiro ecra_impl.H.

Referenciado por copia(), cursor(), e refrescaTudo().

00307                                                {
00308     verificaTamanho();
00309     return Dimensao(SLtt_Screen_Rows, SLtt_Screen_Cols);
00310 }

void Slang::Ecra::direita ( ) [inline]
 

Desloca cursor uma coluna para a direita.

Definido na linha 373 do ficheiro ecra_impl.H.

Referenciado por desloca().

00373                                {
00374     cursor(Posicao(cursor().linha(), cursor().coluna() + 1));
00375 }

void Slang::Ecra::esquerda ( ) [inline]
 

Desloca cursor uma coluna para a esquerda.

Definido na linha 369 do ficheiro ecra_impl.H.

Referenciado por desloca().

00369                                 {
00370     cursor(Posicao(cursor().linha(), cursor().coluna() - 1));
00371 }

Slang::Ecra & Slang::Ecra::operator<< ( Campainha const & ) [inline]
 

Definido na linha 539 do ficheiro ecra_impl.H.

00539                                                           {
00540     campainha();
00541     return *this;
00542 }

Slang::Ecra & Slang::Ecra::operator<< ( ApagaFimDoEcra const & ) [inline]
 

Definido na linha 534 do ficheiro ecra_impl.H.

00534                                                                {
00535     apagaFimDoEcra();
00536     return *this;
00537 }

Slang::Ecra & Slang::Ecra::operator<< ( ApagaFimDaLinha const & ) [inline]
 

Definido na linha 529 do ficheiro ecra_impl.H.

00529                                                                 {
00530     apagaFimDaLinha();
00531     return *this;
00532 }

Slang::Ecra & Slang::Ecra::operator<< ( Apaga const & ) [inline]
 

Definido na linha 524 do ficheiro ecra_impl.H.

00524                                                       {
00525     apaga();
00526     return *this;
00527 }

Slang::Ecra & Slang::Ecra::operator<< ( RefrescaTudo const & ) [inline]
 

Definido na linha 519 do ficheiro ecra_impl.H.

00519                                                              {
00520     refrescaTudo();
00521     return *this;
00522 }

Slang::Ecra & Slang::Ecra::operator<< ( Refresca const & ) [inline]
 

Definido na linha 514 do ficheiro ecra_impl.H.

00514                                                          {
00515     refresca();
00516     return *this;
00517 }

Slang::Ecra & Slang::Ecra::operator<< ( Linha const & linha ) [inline]
 

Definido na linha 505 do ficheiro ecra_impl.H.

00505                                                             {
00506     verificaTamanho();
00507     if(linha.horizontal)
00508         SLsmg_draw_hline(linha.dimensao);
00509     else
00510         SLsmg_draw_vline(linha.dimensao);
00511     return *this;
00512 }

Slang::Ecra & Slang::Ecra::operator<< ( Largura const & l ) [inline]
 

Definido na linha 499 do ficheiro ecra_impl.H.

00499                                                           {
00500     verificaTamanho();
00501     largura_do_proximo = l.largura;
00502     return *this;
00503 }

Slang::Ecra & Slang::Ecra::operator<< ( Justificacao const & j ) [inline]
 

Definido na linha 493 do ficheiro ecra_impl.H.

00493                                                                {
00494     verificaTamanho();
00495     justificacao = j;
00496     return *this;
00497 }

Slang::Ecra & Slang::Ecra::operator<< ( Parado const & ) [inline]
 

Definido na linha 487 do ficheiro ecra_impl.H.

00487                                                        {
00488     verificaTamanho();
00489     para_no_proximo = true;
00490     return *this;
00491 }

Slang::Ecra & Slang::Ecra::operator<< ( Fundo const & ) [inline]
 

Definido na linha 481 do ficheiro ecra_impl.H.

00481                                                       {
00482     verificaTamanho();
00483     SLsmg_set_color(0);
00484     return *this;
00485 }

Slang::Ecra & Slang::Ecra::operator<< ( ObjectoCor const & o ) [inline]
 

Altera o objecto cor das próximas operações de escrita no ecrã (com excepção das colagens!).

Parâmetros:
objecto_cor   Objecto cor a usar nas próximas escritas no ecrã.
Veja também:
cola

Definido na linha 475 do ficheiro ecra_impl.H.

00475                                                              {
00476     verificaTamanho();
00477     SLsmg_set_color(o.objecto);
00478     return *this;
00479 }

Slang::Ecra & Slang::Ecra::operator<< ( Posicao const & posicao ) [inline]
 

Altera a posição do cursor para a posição dada.

Parâmetros:
posicao   Nova posição do cursor.
Veja também:
cursor

Definido na linha 469 do ficheiro ecra_impl.H.

00469                                                                 {
00470     verificaTamanho();
00471     cursor(posicao);
00472     return *this;
00473 }

Slang::Ecra & Slang::Ecra::operator<< ( Troco const & troco ) [inline]
 

Cola no ecrã, na posição do cursor, um troço de ecrã.

O cursor é deslocado para a posição imediatamente após a última coluna da última linha onde o troço foi colocado, a não ser que se tenha pedido para manter o cursor parado.

Parâmetros:
troco   Troço a colar.
Veja também:
parado , cola

Definido na linha 464 do ficheiro ecra_impl.H.

00464                                                             {
00465     cola(troco, cursor());
00466     return *this;
00467 }

Ecra & Slang::Ecra::operator<< ( Simbolo simbolo )
 

Desenha um símbolo especial no ecra.

Parâmetros:
simbolo   Símbolo a desenhar.
Veja também:
Simbolo

Slang::Ecra & Slang::Ecra::operator<< ( Caixa const & caixa ) [inline]
 

Desenha uma caixa no ecrã, sendo a borda desenhada com caracteres especiais.

Parâmetros:
caixa   Caixa a desenhar.
Veja também:
desenhaCaixa

Definido na linha 459 do ficheiro ecra_impl.H.

00459                                                             {
00460     desenhaCaixa(caixa);
00461     return *this;
00462 }

Ecra & Slang::Ecra::operator<< ( string c )
 

Insere uma cadeia de caracteres na posição do cursor.

O cursor é deslocado para a posição à direita do último caractere escrito, a não ser que se tenha pedido para manter o cursor parado. Se se tiver especificado uma largura antes, são acrescentados espaços até perfazer a largura indicada. Se a cadeia for maior que a largura especificada, só são mostrados os primeiros caracteres.

Parâmetros:
c   A cadeia a inserir.
Veja também:
parado , largura
Tarefa:
Fazer template para escrita de tipos não previstos usando stringstream.

Slang::Ecra & Slang::Ecra::operator<< ( int i ) [inline]
 

Insere um número inteiro na base 10 na posição do cursor.

O cursor é deslocado para a posição à direita do último dígito escrito, a não ser que se tenha pedido para manter o cursor parado. Se se tiver especificado uma largura antes, são acrescentados espaços até perfazer a largura indicada. Se a largura for insuficiente para representar o inteiro, só são mostrados os primeiros dígitos.

Parâmetros:
i   O inteiro a inserir.
Veja também:
parado , largura

Definido na linha 452 do ficheiro ecra_impl.H.

00452                                                {
00453     // Afazer: usar stringstream (ainda não há em Linux).
00454     char mal_feito[30];
00455     std::sprintf(mal_feito, "%d", i);
00456     return *this << mal_feito;
00457 }

Slang::Ecra & Slang::Ecra::operator<< ( char c ) [inline]
 

Insere um caracter na posição do cursor.

O cursor é deslocado uma posição para a direita, a não ser que se tenha pedido para manter o cursor parado. Se se tiver especificado uma largura antes, são acrescentados espaços até perfazer a largura indicada.

Parâmetros:
c   O caractere a inserir.
Veja também:
parado , largura

Definido na linha 446 do ficheiro ecra_impl.H.

00446                                                 {
00447     string s;
00448     s += c;
00449     return *this << s;
00450 }

Ecra const & Slang::Ecra::operator>> ( Troco & troco ) const
 

Operador de extracção de um troço do ecrã.

Extrai um troço a partir da posição corrente do cursor.

Parâmetros:
troco   Troço a extrair (copiar).

bool Slang::Ecra::redimensionado ( ) const [inline]
 

Indica se o ecrã foi redimensionado ou não.

Isto é particularmente relevante se o programa estiver a correr numa consola dentro de um ambiente de janelas. Nessas circunstâncias o utilizador pode alterar a dimensão da janela, sendo com isso alterada a dimensão do ecrã. Se isso acontecer o programa deverá redesenhar e refrescar o ecrã.

Definido na linha 316 do ficheiro ecra_impl.H.

00316                                             {
00317     verificaTamanho();
00318     if(redimensionado_) {
00319         redimensionado_ = false;
00320         return true;
00321     }
00322     return false;
00323 }

void Slang::Ecra::refresca ( ) const [inline]
 

Refresca o ecrã, ou seja, reflecte no ecrã real as últimas alterações realizadas no ecrã virtual.

Definido na linha 423 do ficheiro ecra_impl.H.

Referenciado por operator<<(), e refrescaTudo().

00423                                       {
00424     verificaTamanho();
00425     SLsmg_refresh();
00426 }

void Slang::Ecra::refrescaTudo ( ) const [inline]
 

Refresca totalmente o ecrã, ou seja, reflecte no ecrã real todo o ecrã virtual.

Definido na linha 416 do ficheiro ecra_impl.H.

Referenciado por operator<<().

00416                                           {
00417     verificaTamanho();
00418     // Com isto o próximo refresh redesenhará todo o ecrã!
00419     SLsmg_touch_lines(0, dimensao().linhas());
00420     refresca();
00421 }

A documentação para esta classe foi gerada a partir dos seguintes ficheiros:
Gerado em Mon May 14 17:22:14 2001 para Slang++ por doxygen1.2.6 escrito por Dimitri van Heesch, © 1997-2001