Página principal   Módulos   Lista de namespaces   Hierarquia de classes   Lista de componentes   Lista de ficheiros   Membros do namespace   Componentes membro   Ficheiros membro   Páginas relacionadas  

Referência à classe Slang::Ecra
[Ferramentas de ecrã]

Representa o ecrã. Mais...

#include <Slang++/ecra.H>

Mostrar lista completa dos membros

Membros públicos

Construtores
 Ecra (Cor cor_do_texto=branco, Cor cor_do_fundo=preto, bool limita_cursor_ao_ecra_real=false)
 Constrói um ecrã.

 ~Ecra ()
 Destrutor da classe.

Inspectores
Dimensao const dimensao () const
 Devolve a dimensão corrente do ecrã real.

Posicao const origem () const
 Devolve a posição da origem do ecrã real no ecrã virtual.

Posicao const extremo () const
 Devolve a posição do extremo do ecrã real no ecrã virtual.

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

Justificacao justificacaoActual () const
 Devolve a justificação actual das inserções no ecrã.

int larguraDaProximaOperacaoDeEscrita () const
 Devolve a largura a usar na próxima inserção no ecrã.

Predicados
bool foiRedimensionado () const
 Indica se o ecrã real foi redimensionado ou não.

bool cursorEstaVisivel () const
 Indica se o cursor está sobre o ecrã real, i.e., se o cursor é visível.

bool parteVisivelContem (Posicao const &posicao) const
 Indica se uma posição está sobre o ecrã real, i.e., se a parte visível do ecrã contém essa posição.

bool cursorEstaLimitadoAoEcraReal () const
 Indica se o cursor está limitado ao ecrã real, i.e., se o ecrã proíbe o cursor de se deslocar para fora da sua parte visível.

bool cursorImovelNaProximaOperacaoDeInsercao () const
 Indica se o cursor ficará imóvel na próxima operação de inserção.

Modificadores
void mudaJustificacaoPara (Justificacao const nova_justificacao)
 Muda a justificação do ecrã para a justificação dada.

void impoeImobilidadeDoCursorNaProximaInsercao ()
 Coloca o ecrã num estado tal que a próxima operação de inserção não tem efeito sobre a posição do cursor.

void mudaLarguraDaProximaOperacaoDeEscritaPara (int const largura_da_proxima_operacao_de_escrita)
 Coloca o ecrã num estado tal que a próxima operação de inserção será feita usando exactamente largura_da_proxima_operacao_de_escrita células do ecrã.

void mudaObjectoCorEmUsoPara (ObjectoCor const &objecto_cor)
 Muda o objecto cor em uso para objecto_cor.

void mudaObjectoCorEmUsoParaFundo ()
 Muda o objecto cor em uso para o objecto cor do fundo.

void mudaCoresDasCelulasDoFundoPara (Cor const cor_do_texto, Cor const cor_do_fundo)
 Modifica as cores das células do fundo.

void moveCursorPara (Posicao const &nova_posicao_do_cursor)
 Desloca o cursor para a posição dada.

void sobeCursor ()
 Sobe o cursor uma linha.

void baixaCursor ()
 Baixa o cursor uma linha.

void recuaCursor ()
 Recua o cursor uma coluna (para a esquerda).

void avancaCursor ()
 Avança o cursor uma coluna (para a direita).

void moveCursorDeAcordoCom (Tecla const &tecla)
 Desloca o cursor na direcção dada por uma tecla de deslocamento.

Operações para cópia e cola de troços de ecrã
Troco const trocoDe (Caixa const &caixa) const
 Devolve um troço do ecrã correspondente à caixa dada.

Troco const trocoDoEcraCompleto () const
 Devolve uma cópia integral do ecrã real.

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

void cola (Troco const &troco, Posicao const &em=Posicao())
 Cola no ecrã, na posição indicada (por omissão o canto superior esquerdo do ecrã), um troço de ecrã.

Operações para actualizar o ecrã
void tocaCampainha () const
 Toca a "campaínha" do ecrã.

void apagaDoCursorAteOFimDaLinha ()
 Apaga (i.e., pinta com cor do fundo) desde o cursor até ao fim da respectiva linha.

void apagaDoCursorAteOFim ()
 Apaga (i.e., pinta com cor do fundo) desde o cursor até ao fim do ecrã.

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

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

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

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

void desenhaSegmentoHorizontalCom (int const largura)
 Desenha um segmento de recta horizontal, com a largura dada, a partir da posição do cursor (para a direita).

void desenhaSegmentoVerticalCom (int const altura)
 Desenha um segmento de recta vertical, com a altura dada, a partir da posição do cursor (para baixo).

Operadores de inserção no ecrã de tipos usuais
Ecra & operator<< (std::string const &cadeia)
 Insere uma cadeia de caracteres na posição do cursor.

template<typename T> Ecra & operator<< (T const &valor)
 Insere um valor do tipo T genérico na posição do cursor.

Operadores de inserção e extracção de objectos especiais no
ecrã

Ecra & operator<< (Caixa const &caixa)
 Desenha uma caixa no ecrã.

Ecra & operator<< (Simbolo const simbolo)
 Desenha um símbolo especial no ecrã.

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

Operadores de extracção de objectos especiais do ecrã
Ecra const & operator>> (Troco &troco) const
 Extrai um troço do ecrã a partir da posição actual do cursor.

Operadores de inserção de manipuladores no ecrã
Veja-se a descrição dos correspondentes manipuladores, onde se explica o respectivo efeito.

Ecra & operator<< (Posicao const &nova_posicao_do_cursor)
 Altera a posição do cursor para a posição dada (mas limitada ao ecrã real se se optou por limitar o posicionamento do cursor).

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

Ecra & operator<< (Justificacao const nova_justificacao)
 Muda a justificação do ecrã para a justificação dada.

Ecra & operator<< (void manipulador(Ecra &ecra))
 "Gancho" para definir novos manipuladores do ecrã.


Amigos

class ObjectoCor

Descrição detalhada

Representa o ecrã.

Esta classe é um solitão, pois admite-se não haver senão um ecrã.

Por ecrã entende-se um conjunto de células cada uma das quais contém um caractere com uma dada cor de texto e uma dada cor de fundo. Conceptualmente o ecrã estende-se em ambas as direcções até ao infinito, que vertical quer horizontalmente. No entanto, só uma parte do ecrã é visível, dependendo da dimensão do dispositivo onde ocorrerá a sua visualização. Por exemplo, se o ecrã estiver a ser visualizado na janela de uma consola (e.g., xterm) com 24 linhas e 80 colunas, só serão visíveis as linhas 0 a 23 do ecrã e as colunas 0 a 79. chamar-se ecrã real ao dispositivo no qual o ecrã (virtual) é visualizado ou, pelo menos, à zona do ecrã virtual que é visível no ecrã real.

O ecrã é virtual. As alterações nele feitas só têm efeito no ecrã real depois de uma operação de refrescamento. Veja-se a operação refresca() ou o manipulador refresca.

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

  1. inspeccionar a dimensão do ecrã real e a posição do cursor no ecrã (virtual);
  2. verificar se o ecrã real foi redimensionado;
  3. modificar a posição do cursor (de várias formas diferentes);
  4. copiar ou colar um troço de/para uma posição do ecrã (um troço é um conjunto rectangular de células do ecrã);
  5. apagar várias partes do ecrã;
  6. refrescar o ecrã real (ou seja, mostrar ou ecrã virtual);
  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.

Refrescamento

As alterações só são visíveis depois de chamada uma das operações de refrescamento do ecrã. Quando há um redimensionamento do ecrã deve ser invocada a operação refrescaTudo() ou usado o manipulador refresca_tudo. Quando são feitas pequenas alterações deve ser invocada a operação refresca() ou usado o manipulador refresca.

Exemplo de utilização

O programa que se segue escreve no ecrã todas as letras do alfabeto (maiúsculas e minúsculas) e depois, a cada pressão de uma tecla, escreve os dígitos de zero a nove com outra cor, com largura proporcional ao dígito escrito e centrados. 

#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.leProximaTeclaDisponivel(); 
        
    Ecra::ObjectoCor cor(amarelo, azul); 
        
    ecra << cor << cursor(0, 0); 
    for(int c = 0; c != 10; ++c) { 
        ecra << baixaCursor << parado << largura(c) << ao_centro << c 
             << refresca; 

        teclado.leProximaTeclaDisponivel();
    } 
}

Para mais exemplos ver documentação das operações específicas e das classe auxiliares.

Definido na linha 1103 do ficheiro ecra.H.

Documentação dos Construtores & Destrutor

Slang::Ecra::Ecra (  Cor    cor_do_texto = branco,
Cor    cor_do_fundo = preto,
bool    limita_cursor_ao_ecra_real = false
)  [explicit]
 

Constrói um ecrã.

Encarrega-se de inicializar o "screen management" do S-Lang. Se se construir com limita_cursor_ao_ecra_real verdadeiro, o ecrã garantirá que o cursor se encontra dentro dos limites do ecrã real em cada instante. Por omissão essa verificação não é feita, ou seja, o cursor pode-se deslocar para fora do ecrã real. O construtor recebe também as cores do texto e do fundo das chamadas "células do fundo", para as quais não se explicita nenhuma cor.

Tal como a biblioteca se encontra definida, este construtor não pode ser usado directamente, pois a classe é um solitão e a biblioteca pré-define uma variável global deste tipo. 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.

Precondição:
V.
Poscondição:
Ecra é um ecrã pronto a utilizar.

Definido na linha 93 do ficheiro ecra.C.

Referências Slang::a_esquerda, Slang::Cor e mudaCoresDasCelulasDoFundoPara().

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

Destrutor da classe.

Encarrega-se de finalizar o "screen management" do S-Lang.

Precondição:
V.

Definido na linha 542 do ficheiro ecra_impl.H.

Documentação dos métodos

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

Devolve a dimensão corrente do ecrã real.

No programa abaixo vê-se uma utilização deste inspector para controlar a dimensão de uma caixa inserida no ecrã. 

#include <Slang++/slang.H>

using namespace Slang;

// Mostra uma caixa com 1/4 da área do ecrã (metade das suas dimensões
// horizontal e vertical) centrada no ecrã.
int main()
{
    Caixa uma_caixa(Posicao(ecra.dimensao().numeroDeLinhas() / 4,
                            ecra.dimensao().numeroDeColunas() / 4),
                    Dimensao(ecra.dimensao().numeroDeLinhas() / 2,
                             ecra.dimensao().numeroDeColunas() / 2));
    
    ecra << uma_caixa << refresca;

    teclado.leProximaTeclaDisponivel();
}

Precondição:
V.
Poscondição:
dimensao = dimensão do ecrã real.

Definido na linha 550 do ficheiro ecra_impl.H.

Referenciado por extremo(), moveCursorPara(), parteVisivelContem(), refrescaTudo(), Slang::Ecra::Troco::Troco() e trocoDoEcraCompleto().

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

Devolve a posição da origem do ecrã real no ecrã virtual.

De momento devolve sempre (0, 0).

Precondição:
V.
Poscondição:
origem = origem do ecrã real, de momento sempre (0, 0).

Definido na linha 559 do ficheiro ecra_impl.H.

Referenciado por extremo() e parteVisivelContem().

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

Devolve a posição do extremo do ecrã real no ecrã virtual.

De momento devolve sempre dimensao() - Dimensao(1, 1).

Precondição:
V.
Poscondição:
extremo = extremo do ecrã real, de momento sempre (dimensao().numeroDeLinhas() - 1, dimensao().numeroDeColunas() - 1).

Definido na linha 568 do ficheiro ecra_impl.H.

Referências dimensao() e origem().

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

Devolve a posição corrente do cursor.

O programa de exemplo abaixo permite deslocar o cursor de acordo com as teclas premidas, dizendo em cada instante se o cursor se encontra dentro ou fora do ecrã. Para isso recorre à operação posicaoDoCursor(), pois precisa de recolocar o cursor depois de uma operação de escrita: 

#include <string>
#include <Slang++/slang.H>

using namespace std;
using namespace Slang;

int main()
{
    while(true) { 
        if(teclado.haTeclaDisponivel(10)) { 
            teclado.leProximaTeclaDisponivel();
            Tecla tecla_premida = teclado.teclaLida(); 
            
            if(tecla_premida.eDeDeslocamento())
                ecra.moveCursorDeAcordoCom(tecla_premida); 
            else if(tecla_premida == 's')
                break;
        } 
        
        if(ecra.foiRedimensionado())
            ecra << apaga;

        string mensagem;
        if(ecra.cursorEstaVisivel())
            mensagem = "Visível";
        else
            mensagem = "Invisível";

        Posicao posicao_do_cursor = ecra.posicaoDoCursor();

        ecra << cursor(ecra.dimensao().numeroDeLinhas() / 2, 0)
             << largura(ecra.dimensao().numeroDeColunas()) << ao_centro 
             << mensagem;

        ecra << posicao_do_cursor << refresca; 
    }
}

Precondição:
V.
Poscondição:
posicaoDoCursor = posição corrente do cursor.

Definido na linha 577 do ficheiro ecra_impl.H.

Referenciado por avancaCursor(), baixaCursor(), cola(), cursorEstaVisivel(), desenha(), desenhaSegmentoHorizontalCom(), desenhaSegmentoVerticalCom(), Slang::CaixaDeTexto::interage(), Slang::MenuSimples::interage(), operator<<(), operator>>(), recuaCursor(), sobeCursor(), trocoDe() e trocoNoCursorCom().

Slang::Justificacao Slang::Ecra::justificacaoActual (    )  const [inline]
 

Devolve a justificação actual das inserções no ecrã.

Precondição:
V.
Poscondição:
justificacaoActual = justificação actual do ecrã.

Definido na linha 587 do ficheiro ecra_impl.H.

int Slang::Ecra::larguraDaProximaOperacaoDeEscrita (    )  const [inline]
 

Devolve a largura a usar na próxima inserção no ecrã.

Note-se que o valor 0 significa que não se usa largura na inserção.

Precondição:
V.
Poscondição:
larguraDaProximaOperacaoDeEscrita = largura a usar na próxima inserção no ecrã.

Definido na linha 596 do ficheiro ecra_impl.H.

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

Indica se o ecrã real 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ã. Note-se que conceptualmente este predicado pode mudar de valor devolvido sem que tenha sido invocado nenhum modificador. Note-se ainda que logo após devolver verdadeiro devolverá falso até ocorrer novo redimensionamento.

É esta operação que permite ao programa 

#include <string>
#include <Slang++/slang.H>

using namespace std;
using namespace Slang;

int main()
{
    while(true) { 
        if(teclado.haTeclaDisponivel(10)) { 
            teclado.leProximaTeclaDisponivel();
            Tecla tecla_premida = teclado.teclaLida(); 
            
            if(tecla_premida.eDeDeslocamento())
                ecra.moveCursorDeAcordoCom(tecla_premida); 
            else if(tecla_premida == 's')
                break;
        } 
        
        if(ecra.foiRedimensionado())
            ecra << apaga;

        string mensagem;
        if(ecra.cursorEstaVisivel())
            mensagem = "Visível";
        else
            mensagem = "Invisível";

        Posicao posicao_do_cursor = ecra.posicaoDoCursor();

        ecra << cursor(ecra.dimensao().numeroDeLinhas() / 2, 0)
             << largura(ecra.dimensao().numeroDeColunas()) << ao_centro 
             << mensagem;

        ecra << posicao_do_cursor << refresca; 
    }
}

adaptar-se a alterações na dimensão do ecrã real.

Precondição:
V.
Poscondição:
foiRedimensionado = ecrã real foi redimensionado deste a construção do ecrã ou desde a última invocação do predicado e não redimensionado.

Definido na linha 605 do ficheiro ecra_impl.H.

Referenciado por Slang::CaixaDeTexto::interage() e Slang::MenuSimples::interage().

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

Indica se o cursor está sobre o ecrã real, i.e., se o cursor é visível.

Note-se que quando o cursor está "invisível" é um seu "fantasma" visível no ecrã real. A biblioteca S-Lang não permite ocultar este "fantasma", infelismente.

Na documentação de posicaoDoCursor() encontra-se um programa de exemplo que faz uso deste predicado.

Precondição:
V.
Poscondição:
cursorEstaVisivel = parteVisivelContem(posicaoDoCursor()).

Definido na linha 619 do ficheiro ecra_impl.H.

Referências parteVisivelContem() e posicaoDoCursor().

bool Slang::Ecra::parteVisivelContem (  Posicao const &    posicao )  const [inline]
 

Indica se uma posição está sobre o ecrã real, i.e., se a parte visível do ecrã contém essa posição.

Precondição:
V.
Poscondição:
parteVisivelContem = Caixa(origem(), extremo()).contem(posicao).

Definido na linha 628 do ficheiro ecra_impl.H.

Referências dimensao() e origem().

Referenciado por cursorEstaVisivel().

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

Indica se o cursor está limitado ao ecrã real, i.e., se o ecrã proíbe o cursor de se deslocar para fora da sua parte visível.

Precondição:
V.
Poscondição:
cursorEstaLimitadoAoEcraReal = cursor está proibído de abandonar a parte visível do ecrã.

Definido na linha 637 do ficheiro ecra_impl.H.

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

Indica se o cursor ficará imóvel na próxima operação de inserção.

Precondição:
V.
Poscondição:
cursorImovelNaProximaOperacaoDeInsercao = cursor ficará imóvel na próxima operação de inserção.

Definido na linha 647 do ficheiro ecra_impl.H.

void Slang::Ecra::mudaJustificacaoPara (  Justificacao const    nova_justificacao )  [inline]
 

Muda a justificação do ecrã para a justificação dada.

A justificação mantém-se até à próxima alteração.

Precondição:
V.
Poscondição:
justificacaoActual() = nova_justificacao

Definido na linha 657 do ficheiro ecra_impl.H.

Referências Slang::Justificacao.

Referenciado por operator<<().

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

Coloca o ecrã num estado tal que a próxima operação de inserção não tem efeito sobre a posição do cursor.

Precondição:
V.
Poscondição:
cursorImovelNaProximaOperacaoDeInsercao().

Definido na linha 668 do ficheiro ecra_impl.H.

void Slang::Ecra::mudaLarguraDaProximaOperacaoDeEscritaPara (  int const    largura_da_proxima_operacao_de_escrita )  [inline]
 

Coloca o ecrã num estado tal que a próxima operação de inserção será feita usando exactamente largura_da_proxima_operacao_de_escrita células do ecrã.

Precondição:
0 <= largura_da_proxima_operacao_de_escrita.
Poscondição:
LarguraDaProximaOperacaoDeEscrita() = largura_da_proxima_operacao_de_escrita
Veja também:
largura()

Definido na linha 680 do ficheiro ecra_impl.H.

Referenciado por Slang::operator<<().

void Slang::Ecra::mudaObjectoCorEmUsoPara (  ObjectoCor const &    objecto_cor )  [inline]
 

Muda o objecto cor em uso para objecto_cor.

Útil para alterar as cores das próximas inserções no ecrã. Normalmente usa-se o correspondente operador de inserção para obter o mesmo efeito. As duas formas de utilização de objectos cor estão demonstradas no programa de exemplo abaixo: 

#include <Slang++/slang.H>

using namespace Slang;

int main()
{
    Ecra::ObjectoCor cor1(amarelo, azul); 
    Ecra::ObjectoCor cor2(azul, amarelo); 

    ecra << parado << "Cor do fundo..." << baixaCursor;
    ecra << cor1 << parado << "Amarelo sobre azul..." << baixaCursor;
    ecra << fundo << parado << "De novo cor do fundo..." << baixaCursor;

    ecra.mudaObjectoCorEmUsoPara(cor2);
    ecra << parado << "Azul sobre amarelo..." << baixaCursor;

    ecra << refresca;

    teclado.leProximaTeclaDisponivel();
}

Precondição:
V.
Poscondição:
As próximas inserções passarão a ser realizadas usando o objecto cor objecto_cor.

Definido na linha 693 do ficheiro ecra_impl.H.

Referências Slang::Ecra::ObjectoCor::numero_do_objecto.

Referenciado por operator<<().

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

Muda o objecto cor em uso para o objecto cor do fundo.

Útil para que as próximas inserções sejam feitas como células do fundo.

Veja-se o exemplo na documentação da operação mudaObjectoCorEmUsoPara().

Precondição:
V.
Poscondição:
As próximas escritas passarão a ser realizadas usando o objecto cor do fundo.

Definido na linha 704 do ficheiro ecra_impl.H.

void Slang::Ecra::mudaCoresDasCelulasDoFundoPara (  Cor const    cor_do_texto,
Cor const    cor_do_fundo
)  [inline]
 

Modifica as cores das células do fundo.

Útil para modificar o aspecto do fundo mesmo quando não se tem acesso ao construtor do ecrã.

Um exemplo de utilização desta operação pode ser visto abaixo: 

#include <Slang++/slang.H>

using namespace Slang;

int main()
{
    ecra << parado << "Cor do fundo..." << baixaCursor;

    Ecra::ObjectoCor cor(branco, verde); 
    ecra << cor << parado << "Branco sobre verde..." << baixaCursor;

    ecra << refresca;
    teclado.leProximaTeclaDisponivel();

    // A cor do texto já inserido como fundo no ecrã mudará:
    ecra.mudaCoresDasCelulasDoFundoPara(vermelho, branco);

    ecra << refresca;
    teclado.leProximaTeclaDisponivel();

    ecra << fundo << parado 
         << "Mais com a cor do fundo, que passou a vermelho sobre branco...";
         
    ecra << refresca;
    teclado.leProximaTeclaDisponivel();
}

Precondição:
V.
Poscondição:
Células desenhadas com o objecto cor do fundo serão desenhadas com as cores dadas.

Definido na linha 716 do ficheiro ecra_impl.H.

Referências Slang::Cor.

Referenciado por Ecra().

void Slang::Ecra::moveCursorPara (  Posicao const &    nova_posicao_do_cursor ) 
 

Desloca o cursor para a posição dada.

Precondição:
V.
Poscondição:
posicaoDoCursor() = nova_posicao_do_cursor (mas limitada ao ecrã real se se optou por limitar o posicionamento do cursor).

Definido na linha 123 do ficheiro ecra.C.

Referências Slang::Posicao::coluna(), dimensao(), Slang::Posicao::linha(), Slang::Dimensao::numeroDeColunas() e Slang::Dimensao::numeroDeLinhas().

Referenciado por avancaCursor(), baixaCursor(), cola(), desenha(), desenhaSegmentoHorizontalCom(), desenhaSegmentoVerticalCom(), operator<<(), operator>>(), recuaCursor(), sobeCursor() e trocoDe().

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

Sobe o cursor uma linha.

Precondição:
p = posicaoDoCursor().
Poscondição:
posicaoDoCursor() = p - Dimensao(1, 0) (mas limitada ao ecrã real se se optou por limitar o posicionamento do cursor).

Definido na linha 729 do ficheiro ecra_impl.H.

Referências moveCursorPara() e posicaoDoCursor().

Referenciado por moveCursorDeAcordoCom().

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

Baixa o cursor uma linha.

Precondição:
p = posicaoDoCursor().
Poscondição:
posicaoDoCursor() = p + Dimensao(1, 0) (mas limitada ao ecrã real se se optou por limitar o posicionamento do cursor).

Definido na linha 740 do ficheiro ecra_impl.H.

Referências moveCursorPara() e posicaoDoCursor().

Referenciado por moveCursorDeAcordoCom().

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

Recua o cursor uma coluna (para a esquerda).

Precondição:
p = posicaoDoCursor().
Poscondição:
posicaoDoCursor() = p - Dimensao(0, 1) (mas limitada ao ecrã real se se optou por limitar o posicionamento do cursor).

Definido na linha 751 do ficheiro ecra_impl.H.

Referências moveCursorPara() e posicaoDoCursor().

Referenciado por moveCursorDeAcordoCom().

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

Avança o cursor uma coluna (para a direita).

Precondição:
p = posicaoDoCursor().
Poscondição:
posicaoDoCursor() = p + Dimensao(0, 1) (mas limitada ao ecrã real se se optou por limitar o posicionamento do cursor).

Definido na linha 762 do ficheiro ecra_impl.H.

Referências moveCursorPara() e posicaoDoCursor().

Referenciado por moveCursorDeAcordoCom().

void Slang::Ecra::moveCursorDeAcordoCom (  Tecla const &    tecla ) 
 

Desloca o cursor na direcção dada por uma tecla de deslocamento.

Precondição:
tecla.eDeslocamento() e p = posicaoDoCursor().
Poscondição:
(posicaoDoCursor() = p - Dimensao(1, 0) e tecla = Tecla::cima) ou (posicaoDoCursor() = p + Dimensao(1, 0) e tecla = Tecla::baixo) ou (posicaoDoCursor() = p - Dimensao(0, 1) e tecla = Tecla::esquerda) ou (posicaoDoCursor() = p + Dimensao(0, 1) e tecla = Tecla::direita) (mas limitada ao ecrã real se se optou por limitar o posicionamento do cursor).

Definido na linha 150 do ficheiro ecra.C.

Referências avancaCursor(), baixaCursor(), Slang::Tecla::eDeDeslocamento(), recuaCursor() e sobeCursor().

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

Devolve um troço do ecrã correspondente à caixa dada.

Um exemplo de utilização pode ser encontrado em: 

#include <string>

#include <Slang++/slang.H>

extern "C" {
#include <unistd.h>  // para sleep()
}

using namespace std;

using namespace Slang;

// Este exemplo deve ser testado em janelas com pelo menos 80 colunas!
int main()
{
    string letras = "abcdefghijklmnopqrstuvwxyz";

    // Preenche o ecrã com um padrão de letras:
    for(int i = 0; i != ecra.dimensao().numeroDeLinhas(); ++i) {
        ecra << cursor(i, 0);
        for(int j = 0; j != ecra.dimensao().numeroDeColunas(); ++j)
            ecra << letras[(i * ecra.dimensao().numeroDeColunas() +
                            j) % letras.size()];
    }

    ecra << refresca;

    Aviso("Ecrã preenchido.").interage();

    // Cria uma caixa de dimensão 10 × 20 com origem na posição (0, 0):
    Caixa caixa(Posicao(0, 0), Dimensao(10, 20));  
        
    // Obtém cópia do troço de ecrã que se encontra sob a caixa:
    Ecra::Troco troco = ecra.trocoDe(caixa); 

    Aviso("Troço copiado.  Tome atenção às alterações que "
          "ocorrerão no ecrã!").interage();

    // Move o cursor para a posição (11, 21), cola o troço copiado acima nessa
    // posição e refresca o ecrã de modo a que estas modificações se tornem
    // visíveis:
    ecra << cursor(11, 21) << troco << refresca;

    Aviso("Troço colado.  Não viu?  Vou colar em sequência...").interage();

    for(int j = 22; j != 80; ++j) {
        // Move o cursor para a posição (11, j), cola o troço copiado acima nessa
        // posição e refresca o ecrã de modo a que estas modificações se tornem
        // visíveis:
        ecra << cursor(11, j) << troco << refresca;
        
        // Espera 1 segundo:
        sleep(1);
    }

    Aviso("Agora viu...").interage();
}

Precondição:
caixa.eCanonica().
Poscondição:
trocoDe = troço representando a cópia da zona do ecrã correspondendo a caixa.

Definido na linha 181 do ficheiro ecra.C.

Referências Slang::Posicao::coluna(), Slang::Ecra::Troco::dados, Slang::Caixa::dimensao(), Slang::Caixa::eCanonica(), Slang::Posicao::linha(), moveCursorPara(), Slang::Dimensao::numeroDeColunas(), Slang::Dimensao::numeroDeLinhas(), Slang::Caixa::origem() e posicaoDoCursor().

Referenciado por trocoDoEcraCompleto() e trocoNoCursorCom().

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

Devolve uma cópia integral do ecrã real.

Precondição:
V.
Poscondição:
trocoDoEcraCompleto = troço representando a cópia do ecrã real completo.

Definido na linha 773 do ficheiro ecra_impl.H.

Referências dimensao() e trocoDe().

Referenciado por Slang::CaixaDeTexto::interage() e Slang::MenuSimples::interage().

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

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

Precondição:
dimensao.eCanonica().
Poscondição:
trocoNoCursorCom = troço representando a cópia da zona do ecrã com origem em posicaoDoCursor() e dimensão dimensao.

Definido na linha 783 do ficheiro ecra_impl.H.

Referências Slang::Dimensao::eCanonica(), posicaoDoCursor() e trocoDe().

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

Cola no ecrã, na posição indicada (por omissão o canto superior esquerdo do ecrã), 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.

Precondição:
V.
Poscondição:
ecrã contém cópia do troço troco a partir da posição em, ficando o cursor na posição imediatamente após a última coluna da última linha onde o troço foi colocado (mas limitada ao ecrã real se se optou por limitar o posicionamento do cursor), excepto se o cursor tiver de ficar parado.
Veja também:
parado

Definido na linha 211 do ficheiro ecra.C.

Referências Slang::Posicao::coluna(), Slang::Ecra::Troco::dados, Slang::Ecra::Troco::dimensao(), Slang::fundo(), Slang::Posicao::linha(), moveCursorPara(), Slang::Dimensao::numeroDeColunas(), Slang::Dimensao::numeroDeLinhas() e posicaoDoCursor().

Referenciado por Slang::CaixaDeTexto::interage(), Slang::MenuSimples::interage() e operator<<().

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

Toca a "campaínha" do ecrã.

Por vezes o ecrã pisca, embora não seja nunca alterado. Por exemplo: 

#include <Slang++/slang.H>

using namespace Slang;

int main()
{
    ecra << refresca;

    while(true) {
        teclado.leProximaTeclaDisponivel();
        Tecla tecla_premida = teclado.teclaLida();

        if(tecla_premida.eChar() and tecla_premida.comoChar() == 's')
            break;

        ecra << campainha;
    }
}

Precondição:
V.
Poscondição:
Uma campaínha soou.

Definido na linha 793 do ficheiro ecra_impl.H.

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

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

Precondição:
V.
Poscondição:
ecrã "vazio" entre posicaoDoCursor() e o final da respectiva linha.

Definido na linha 802 do ficheiro ecra_impl.H.

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

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

Precondição:
V.
Poscondição:
ecrã vazio entre posicaoDoCursor() e o final do ecrã.

Definido na linha 813 do ficheiro ecra_impl.H.

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

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

Precondição:
V.
Poscondição:
ecrã vazio.

Definido na linha 824 do ficheiro ecra_impl.H.

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

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

Precondição:
V.
Poscondição:
Ecrã real reflecte exactamente a parte correspondente do ecrã virtual.

Definido na linha 835 do ficheiro ecra_impl.H.

Referenciado por refrescaTudo().

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

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

O efeito deve ser semelhante ao obtido pela operação refresca(), só diferindo em caso de erro do sistema. Útil para tentar ultrapassar erros de programação, fornecendo-se ao utilizador uma forma de refrescar o ecrã inteiro.

Precondição:
V.
Poscondição:
Ecrã real reflecte exactamente a parte correspondente do ecrã virtual.

Definido na linha 844 do ficheiro ecra_impl.H.

Referências dimensao() e refresca().

void Slang::Ecra::desenha (  Caixa const &    caixa ) 
 

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

O interior da caixa não é alterado. O cursor é colocado na célula imediatamente à direita do canto inferior direito da caixa (mas limitado ao ecrã real se se optou por limitar o posicionamento do cursor), excepto se se tiver optado por fixar o cursor.

O mesmo efeito pode ser obtido inserindo a caixa no ecrã. Veja-se o exemplo na documentação da classe Caixa.

Precondição:
caixa.eCanonica().
Poscondição:
ecrã contém caracteres desenhando uma caixa nas posições correspondentes à borda de caixa e o cursor está colocado na célula imediatamente à direita do canto inferior direito da caixa (mas limitado ao ecrã real se se optou por limitar o posicionamento do cursor), excepto se se tiver optado por fixar o cursor.

Definido na linha 250 do ficheiro ecra.C.

Referências Slang::Posicao::coluna(), Slang::Caixa::dimensao(), Slang::Posicao::linha(), moveCursorPara(), Slang::Dimensao::numeroDeColunas(), Slang::Dimensao::numeroDeLinhas(), Slang::Caixa::origem() e posicaoDoCursor().

Referenciado por operator<<().

void Slang::Ecra::desenhaSegmentoHorizontalCom (  int const    largura ) 
 

Desenha um segmento de recta horizontal, com a largura dada, a partir da posição do cursor (para a direita).

Veja-se um exemplo de utilização na documentação do manipulador segmento_horizontal().

Precondição:
0 <= largura
Poscondição:
Ecrã contém segmento de recta horizontal com a largura dada e o cursor está colocado na célula imediatamente à direita do extremo direito do segmento (mas limitado ao ecrã real se se optou por limitar o posicionamento do cursor), excepto se se tiver optado por fixar o cursor.
Veja também:
segmento_horizontal()

Definido na linha 275 do ficheiro ecra.C.

Referências Slang::largura(), moveCursorPara() e posicaoDoCursor().

Referenciado por Slang::operator<<().

void Slang::Ecra::desenhaSegmentoVerticalCom (  int const    altura ) 
 

Desenha um segmento de recta vertical, com a altura dada, a partir da posição do cursor (para baixo).

Veja-se um exemplo de utilização na documentação do manipulador segmento_horizontal().

Precondição:
0 <= altura
Poscondição:
Ecrã contém segmento de recta vertical com a altura dada e o cursor está colocado na célula imediatamente abaixo do extremo inferior do segmento (mas limitado ao ecrã real se se optou por limitar o posicionamento do cursor), excepto se se tiver optado por fixar o cursor.

Definido na linha 298 do ficheiro ecra.C.

Referências moveCursorPara() e posicaoDoCursor().

Referenciado por Slang::operator<<().

Slang::Ecra & Slang::Ecra::operator<< (  std::string const &    cadeia ) 
 

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

O cursor é deslocado para a posição à direita do último caractere escrito (mas limitado ao ecrã real se se optou por limitar o posicionamento do cursor)., 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. Os espaços são inseridos à esquerda, à direita ou de ambos os lados, consoante o tipo de justificação em vigor no ecrã.

Precondição:
V.
Poscondição:
(ver descrição acima).
Veja também:
parado

largura

Justificacao

Definido na linha 321 do ficheiro ecra.C.

Referências Slang::a_direita, Slang::a_esquerda, Slang::ao_centro, moveCursorPara() e posicaoDoCursor().

template<typename T>
Slang::Ecra & Slang::Ecra::operator<< (  T const &    valor )  [inline]
 

Insere um valor do tipo T genérico na posição do cursor.

O efeito é idêntico ao do operador<< para cadeias de caracteres. O tipo T do valor inserido tem de ter o operador << disponível para inserções em canais ostream (ou pelo menos ostringstream).

Precondição:
V.
Poscondição:
(ver descrição acima).

Definido na linha 857 do ficheiro ecra_impl.H.

Referências Slang::ecra.

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

Desenha uma caixa no ecrã.

Efeito equivalente ao da operação desenha(Caixa).

Veja-se o exemplo na documentação da classe Caixa.

Precondição:
caixa.eCanonica().
Poscondição:
Ver descrição de desenha().

Definido na linha 874 do ficheiro ecra_impl.H.

Referências Slang::caixa(), desenha() e Slang::Caixa::eCanonica().

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

Desenha um símbolo especial no ecrã.

Veja-se um exemplo de utilização na classe Simbolo.

Precondição:
V.
Poscondição:
ecrã contém o símbolo simbolo a partir da posição do cursor (ver descrição de operador << para cadeias de caracteres), avançando o cursor para a posição à sua direita (mas limitado ao ecrã real se se optou por limitar o posicionamento do cursor).
Veja também:
Simbolo

Definido na linha 888 do ficheiro ecra_impl.H.

Referências Slang::Simbolo.

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 (mas limitado ao ecrã real se se optou por limitar o posicionamento do cursor), 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.

Veja-se um exemplo de utilização na documentação da operação trocoDe().

Precondição:
V.
Poscondição:
ecrã contém cópia do troço troco a partir da posição em, ficando o cursor na posição imediatamente após a última coluna da última linha onde o troço foi colocado (mas limitado ao ecrã real se se optou por limitar o posicionamento do cursor), excepto se o cursor tiver de ficar parado.
Veja também:
parado

cola

Definido na linha 903 do ficheiro ecra_impl.H.

Referências cola() e posicaoDoCursor().

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

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

Precondição:
V.
Poscondição:
troco é cópia da zona do ecrã começando na posição actual do cursor e com dimensão troco.dimensao().
Veja também:
trocoDe()

Definido na linha 390 do ficheiro ecra.C.

Referências Slang::Posicao::coluna(), Slang::Ecra::Troco::dados, Slang::Ecra::Troco::dimensao(), Slang::Posicao::linha(), moveCursorPara(), Slang::Dimensao::numeroDeColunas(), Slang::Dimensao::numeroDeLinhas() e posicaoDoCursor().

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

Altera a posição do cursor para a posição dada (mas limitada ao ecrã real se se optou por limitar o posicionamento do cursor).

Precondição:
V.
Poscondição:
posicaoDoCursor() = nova_posicao_do_cursor (mas limitada ao ecrã real se se optou por limitar o posicionamento do cursor).
Veja também:
cursor

moveCursorPara()

Definido na linha 917 do ficheiro ecra_impl.H.

Referências moveCursorPara().

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

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

Um exemplo de utilização pode ser encontrado na documentação da operacao mudaObjectoCorEmUsoPara().

Precondição:
V.
Poscondição:
Próximas inserções no ecrã (excepto colagens) serão feitas usando o objecto cor passado.
Veja também:
mudaObjectoCorEmUsoPara()

Definido na linha 930 do ficheiro ecra_impl.H.

Referências mudaObjectoCorEmUsoPara().

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

Muda a justificação do ecrã para a justificação dada.

A justificação mantém-se até à próxima alteração.

Precondição:
V.
Poscondição:
justificacaoActual() = justificacao das inserções no ecrã em vigor.

Definido na linha 944 do ficheiro ecra_impl.H.

Referências Slang::Justificacao e mudaJustificacaoPara().

Slang::Ecra & Slang::Ecra::operator<< (  void     manipulador(Ecra &ecra) )  [inline]
 

"Gancho" para definir novos manipuladores do ecrã.

Um novo manipulador consegue-se facilmente definindo um procedimento que receba um ecrã por referência. Esse procedimento será invocado automaticamente quando for inserido no ecrã através do operador <<.

O exemplo abaixo demonstra como se pode definir um manipulador para deslocar o cursor para uma posição aleatória do ecrã real: 

#include <cstdlib>

#include <Slang++/slang.H>

using namespace std;

using namespace Slang;

void cursor_aleatorio(Ecra& ecra)
{
    ecra << cursor(rand() % ecra.dimensao().numeroDeLinhas(),
                   rand() % ecra.dimensao().numeroDeColunas());
}

int main()
{
    ecra << refresca;

    while(true) {
        teclado.leProximaTeclaDisponivel();
        Tecla tecla_premida = teclado.teclaLida();

        if(tecla_premida.eChar() and tecla_premida.comoChar() == 's')
            break;

        ecra << cursor_aleatorio << refresca;
    }
}

Precondição:
V.
Poscondição:
O efeito é o mesmo de invocar manipulador(*this).

Definido na linha 958 do ficheiro ecra_impl.H.

Referências Slang::ecra.

Documentação das classes amigas e funções relacionadas

friend class ObjectoCor [friend]
 

Definido na linha 1821 do ficheiro ecra.H.

A documentação para esta classe foi gerada a partir dos seguintes ficheiros:
Gerado em Tue Dec 3 15:19:37 2002 para Pacotes por doxygen1.3-rc1