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  

Ferramentas de ecrã

Módulo correspondente ao ficheiro Slang++/ecra.H. Mais...


Ficheiros

file  ecra.C
 Ficheiro de implementação do módulo ecras.

file  caixa1.C
 Programa que demostra o desenho de uma caixa no ecrã.

file  campainha1.C
 Este programa toca a campainha do ecrã a cada tecla premida, saindo quando se pressiona 's'.

file  ecra1.C
 Programa que demostra a utilização do ecrã de forma simples.

file  ecra2.C
 Programa que demostra a utilização do troços de ecrã e respectiva cópia e colagem.

file  ecra3.C
 Programa que permite ao utilizador deslocar o cursor através das setas do teclado, indicando em cada instante se o cursor está ou não visível.

file  ecra4.C
 Programa que demonstra que a alteração das cores do fundo do ecrã altera todas as células do ecrã que com ele tenham sido desenhadas.

file  exemplo3.C
 Programa que demostra a utilização do teclado e do ecrã de forma simples.

file  justificacao1.C
 Programa que demostra os vários tipos de justificação e o seu efeito.

file  manipulador1.C
 Programa que define um manipulador que move o cursor para uma posição arbitrária mas visível do ecrã.

file  objectocor1.C
 Programa que demostra o efeito dos objectos cor e da alterção das suas cores já depois de feitas inserções por seu intermédio.

file  objectocor2.C
 Programa que demonstra o efeito do tempo de vida sobre os objectos cor.

file  objectocor3.C
 Programa que demonstra que a alteração de um objecto cor altera todas as células do ecrã que com ele tenham sido desenhadas.

file  segmentos1.C
 Programa que demonstra a utilização de segmentos de recta horizontais e verticais.

file  simbolo1.C
 Programa que mostra os símbolos possíveis de inserir no ecrã.

file  ecra.H
 Ficheiro de interface do módulo ecras.


Componentes

class  Posicao
 Representa a posição de uma célula do ecrã. Mais...

class  Dimensao
 Representa uma dimensão em células do ecrã. Mais...

class  Caixa
 Representa caixas no ecrã. Mais...

class  Ecra
 Representa o ecrã. Mais...

class  ObjectoCor
 Esta classe é usada para indicar a cor das células do ecrã (as células têm uma cor de texto e outra de fundo). Mais...

class  Troco
 Esta classe serve para representar um troço de ecrã. Mais...


Operadores associados ao tipo enumerado Cor

std::ostream & operator<< (std::ostream &saida, Cor const cor)
 Insere uma cor num canal.

std::istream & operator>> (std::istream &entrada, Cor &cor)
 Extrai uma cor de um canal.

int const numero_de_cores
 Constante que guarda o número total de cores.


Manipuladores do ecrã

Posicao const cursor (int const linha, int const coluna)
 Manipulador usado para colocar o cursor numa dada posição.

Posicao const & cursor (Posicao const &posicao)
 Manipulador usado para colocar o cursor numa dada posição.

Caixa const caixa (int const linha, int const coluna, int const numero_de_linhas, int const numero_de_colunas)
 Manipulador usado para desenhar uma caixa com caracteres especiais numa dada posição e com uma dada dimensão.

Caixa const caixa (Posicao const &origem=Posicao(), Dimensao const &dimensao=Dimensao())
 Manipulador usado para desenhar uma caixa com caracteres especiais numa dada posição e com uma dada dimensão.

void fundo (Ecra &ecra)
 Manipulador usado para indicar que as próximas escritas devem ser realizadas usando a cor do fundo do ecrã.

void parado (Ecra &ecra)
 Manipulador usado para manter o cursor na posição corrente durante a próxima operação de inserção no ecrã.

void sobeCursor (Ecra &ecra)
 Manipulador usado para subir o cursor no ecrã.

void baixaCursor (Ecra &ecra)
 Manipulador usado para baixar o cursor no ecrã.

void recuaCursor (Ecra &ecra)
 Manipulador usado para recuar o cursor no ecrã.

void avancaCursor (Ecra &ecra)
 Manipulador usado para avançar o cursor no ecrã.

ManipuladorDaLargura largura (int const largura)
 Manipulador usado para indicar o número de células do ecrã a ocupar na próxima operação de inserção no ecrã.

ManipuladorDeDesenhoDeSegmento segmento_horizontal (int const largura)
 Manipulador usado para desenhar um segmento de recta horizontal.

ManipuladorDeDesenhoDeSegmento segmento_vertical (int const altura)
 Manipulador usado para desenhar um segmento de recta vertical.

void refresca (Ecra &ecra)
 Manipulador usado para refrescar o ecrã.

void refresca_tudo (Ecra &ecra)
 Manipulador usado para fazer o refrescamento total do ecrã.

void apaga (Ecra &ecra)
 Manipulador usado para apagar o ecrã (ou seja, para o pintar com a cor do fundo).

void apaga_fim_da_linha (Ecra &ecra)
 Manipulador usado para apagar até ao fim da linha do cursor (ou seja, para o pintar com a cor do fundo).

void apaga_fim_do_ecra (Ecra &ecra)
 Manipulador usado para apagar desde a posição do cursor até ao fim do ecrã (ou seja, para o pintar com a cor do fundo).

void campainha (Ecra &ecra)
 Manipulador usado para fazer soar a campainha.


Constantes associadas à classe Caixa

Caixa const caixa_vazia
 Constante representando uma caixa vazia, i.e., com dimensão nula.

Caixa const caixa_universal
 Constante representando a caixa universal (enche todo o espaço).


Enumerações

enum  Cor {
  preto, primeira_cor = preto, cinza, vermelho,
  vermelho_brilhante, verde, verde_brilhante, castanho,
  amarelo, azul, azul_brilhante, magenta,
  magenta_brilhante, ciano, ciano_brilhante, cinzento_claro,
  branco, ultima_cor = branco
}
 Representa as possíveis cores do texto e do fundo de cada célula do ecrã. Mais...

enum  Simbolo {
  diamante = '`', tijolo, ht, ff,
  cr, lf, grau, mais_menos,
  nl, vt, canto_inferior_direito, canto_superior_direito,
  canto_superior_esquerdo, canto_inferior_esquerdo, cruzamento, traco_topo,
  traco_superior, traco_horizontal, traco_inferior, traco_base,
  encontro_direita, encontro_esquerda, encontro_cima, encontro_baixo,
  traco_vertical, menor_ou_igual, maior_ou_igual, pi,
  diferente
}
 Representa caracteres especiais úteis para desenhar no ecrã caixas e outros símbolos pouco usuais. Mais...

enum  Justificacao { ao_centro, a_esquerda, a_direita }
 Representa os vários tipos de justificação possíveis ao escrever texto no ecrã. Mais...


Variáveis

Ecra ecra
 Uma variável global representando o ecrã.

std::string const nomes_das_cores [numero_de_cores]
 Constante global com os nomes das cores.

Descrição detalhada

Módulo correspondente ao ficheiro Slang++/ecra.H.

Contém ferramentas para escrever e manipular o ecrã.

Documentação dos valores da enumeração

enum Slang::Cor
 

Representa as possíveis cores do texto e do fundo de cada célula do ecrã.

Note-se que nem todas as cores são válidas para o fundo em todos os terminais! Experimente para verificar quais funcionam bem... Ver na documentação abaixo os nomes das cores usados para inserção e extração de canais.

Valores da enumeração:
preto  Num canal: preto.
primeira_cor 
cinza  Num canal: cinza.
vermelho  Num canal: vermelho.
vermelho_brilhante  Num canal: vermelho-brilhante.
verde  Num canal: verde.
verde_brilhante  Num canal: verde-brilhante.
castanho  Num canal: castanho.
amarelo  Num canal: amarelo.
azul  Num canal: azul.
azul_brilhante  Num canal: azul-brilhante.
magenta  Num canal: magenta.
magenta_brilhante  Num canal: magenta-brilhante.
ciano  Num canal: ciano.
ciano_brilhante  Num canal: ciano-brilhante.
cinzento_claro  Num canal: cinzento-claro.
branco  Num canal: branco.
ultima_cor 

Definido na linha 921 do ficheiro ecra.H.

Referenciado por Slang::Ecra::Ecra(), main(), Slang::Ecra::ObjectoCor::mudaCorDoFundoPara(), Slang::Ecra::ObjectoCor::mudaCorDoTextoPara(), Slang::Ecra::mudaCoresDasCelulasDoFundoPara(), Slang::Ecra::ObjectoCor::ObjectoCor() e Slang::operator>>().

enum Slang::Simbolo
 

Representa caracteres especiais úteis para desenhar no ecrã caixas e outros símbolos pouco usuais.

Pode ver o aspecto destes símbolos executando o seguinte programa de exemplo: 

#include <Slang++/slang.H>

using namespace Slang;

int main()
{
    for(int s = int(diamante); s != int(diferente) + 1; ++s)
        ecra << largura(2) << Simbolo(s);

    ecra << refresca;

    teclado.leProximaTeclaDisponivel();
}
Valores da enumeração:
diamante 
tijolo 
ht 
ff 
cr 
lf 
grau 
mais_menos 
nl 
vt 
canto_inferior_direito 
canto_superior_direito 
canto_superior_esquerdo 
canto_inferior_esquerdo 
cruzamento 
traco_topo 
traco_superior 
traco_horizontal 
traco_inferior 
traco_base 
encontro_direita 
encontro_esquerda 
encontro_cima 
encontro_baixo 
traco_vertical 
menor_ou_igual 
maior_ou_igual 
pi 
diferente 

Definido na linha 979 do ficheiro ecra.H.

Referenciado por main() e Slang::Ecra::operator<<().

enum Slang::Justificacao
 

Representa os vários tipos de justificação possíveis ao escrever texto no ecrã.

O valor a_esquerda (que é a justificação por omissão do ecrã) faz com que as entidades inseridas no ecrã fiquem à esquerda do espaço para eles reservado. O valor a_direita alinha as entidades à direita. O valor ao_centro leva as entidades inseridas a serem colocadas ao centro do espaço para elas reservado através, por exemplo, do manipulador largura(). Se o espaço reservado for insuficiente, a entidade inserida será truncada à direita, de ambos os lados, ou à esquerda, consoante a justificação escolhida seja à esquerda, ao centro ou à direita.

O programa que se segue ilustra o funcionamento destes valores enumerados, que ao serem inseridos no ecrã alteram a justificação de forma permanente: 

#include <string>
#include <Slang++/slang.H> 
        
using namespace std; 
using namespace Slang; 
        
int main() 
{ 
    char caractere = '*';
    string cadeia("abcde");

    Ecra::ObjectoCor cor(amarelo, azul); 
        
    ecra << cor; 

    ecra << parado << largura(10) << a_esquerda << caractere << baixaCursor; 
    ecra << parado << largura(10) << ao_centro << caractere << baixaCursor; 
    ecra << parado << largura(10) << a_direita << caractere << baixaCursor; 

    ecra << parado << largura(10) << a_esquerda << cadeia << baixaCursor; 
    ecra << parado << largura(10) << ao_centro << cadeia << baixaCursor; 
    ecra << parado << largura(10) << a_direita << cadeia << baixaCursor; 

    ecra << parado << largura(3) << a_esquerda << cadeia << baixaCursor; 
    ecra << parado << largura(3) << ao_centro << cadeia << baixaCursor; 
    ecra << parado << largura(3) << a_direita << cadeia << baixaCursor; 
    
    ecra << refresca;

    teclado.leProximaTeclaDisponivel();
}

Veja também:
largura()
Valores da enumeração:
ao_centro  Manipulador usado para colocar justificação centrada.
a_esquerda  Manipulador usado para colocar justificação à esquerda.
a_direita  Manipulador usado para colocar justificação à direita.

Definido na linha 1034 do ficheiro ecra.H.

Referenciado por Slang::Ecra::mudaJustificacaoPara() e Slang::Ecra::operator<<().

Documentação das funções

std::ostream & Slang::operator<< (  std::ostream &    saida,
Cor const    cor
)  [inline]
 

Insere uma cor num canal.

Precondição:
V.
Poscondição:
não saida.good() ou (saida.good() e canal contém a representação textual da cor).

Definido na linha 531 do ficheiro ecra_impl.H.

Slang::Posicao const Slang::cursor (  int const    linha,
int const    coluna
)  [inline]
 

Manipulador usado para colocar o cursor numa dada posição.

Usar como se segue: 

        // Coloca cursor na linha 10 coluna 20 do ecrã:
        ecra << cursor(10, 20);

        // Escreve "Olá mundo!" a partir dessa posição:
        ecra << "Olá mundo";

        // Refresca o ecrã:
        ecra << refresca;

Veja também:
Ecra::moveCursorPara()

Definido na linha 1122 do ficheiro ecra_impl.H.

istream & Slang::operator>> (  std::istream &    entrada,
Cor &    cor
) 
 

Extrai uma cor de um canal.

Precondição:
cor = c.
Poscondição:
(não entrada.good() e cor = c) ou (entrada.good() e canal já não contém a representação textual da cor e cor = cor cuja representação textual estava no canal).

Definido na linha 74 do ficheiro ecra.C.

Referências Slang::Cor.

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

Manipulador usado para colocar o cursor numa dada posição.

Usar como se segue: 

        // Definição de uma posicão:
        Posicao posicao(10, 20);

        // Coloca cursor na posição do ecrã definida:
        ecra << cursor(posicao);

        // Escreve "Olá mundo!" a partir dessa posição:
        ecra << "Olá mundo";

        // Refresca o ecrã:
        ecra << refresca;

embora fosse mais simples omitir a utilização do manipulador, inserindo directamente a posição no ecrã: 

        // Definição de uma posicão:
        Posicao posicao(10, 20);

        // Coloca cursor na posição do ecrã definida:
        ecra << posicao;

        // Escreve "Olá mundo!" a partir dessa posição:
        ecra << "Olá mundo";

        // Refresca o ecrã:
        ecra << refresca;

que ainda pode ser simplificado para: 

        // Coloca cursor na posição do ecrã definida:
        ecra << Posicao(10, 20);

        // Escreve "Olá mundo!" a partir dessa posição:
        ecra << "Olá mundo";

        // Refresca o ecrã:
        ecra << refresca;

Veja também:
Ecra::moveCursorPara()

Definido na linha 1127 do ficheiro ecra_impl.H.

Referenciado por cursor_aleatorio() e main().

Slang::Caixa const Slang::caixa (  int const    linha,
int const    coluna,
int const    numero_de_linhas,
int const    numero_de_colunas
)  [inline]
 

Manipulador usado para desenhar uma caixa com caracteres especiais numa dada posição e com uma dada dimensão.

Usar como se segue: 

        // Desenha caixa com origem na linha 10 coluna 20 com 5 linhas e 15
        // colunas:
        ecra << caixa(10, 20, 5, 15);

        // Refresca o ecrã:
        ecra << refresca;

Veja também:
Ecra::desenha()

Definido na linha 1132 do ficheiro ecra_impl.H.

Referenciado por Slang::Ecra::operator<<().

Slang::Caixa const Slang::caixa (  Posicao const &    origem = Posicao(),
Dimensao const &    dimensao = Dimensao()
)  [inline]
 

Manipulador usado para desenhar uma caixa com caracteres especiais numa dada posição e com uma dada dimensão.

Usar como se segue: 

        // Definição de uma posição e uma dimensão para a caixa:
        Posicao posicao(10, 20);
        Dimensao dimensao(5, 15);

        // Desenha caixa com a posição e dimensão definidas:
        ecra << caixa(posicao, dimensao);

        // Refresca o ecrã:
        ecra << refresca;

Neste caso poder-se-ia ter omitido o manipulador, usando-se em vez dele o construtor da classe Caixa, que se pode inserir num ecrã: 

        // Definição de uma posição e uma dimensão para a caixa:
        Posicao posicao(10, 20);
        Dimensao dimensao(5, 15);

        // Desenha caixa com a posição e dimensão definidas:
        ecra << Caixa(posicao, dimensao);

        // Refresca o ecrã:
        ecra << refresca;

Veja também:
Ecra::desenha()

Definido na linha 1141 do ficheiro ecra_impl.H.

Referenciado por main().

void Slang::fundo (  Ecra &    ecra )  [inline]
 

Manipulador usado para indicar que as próximas escritas devem ser realizadas usando a cor do fundo do ecrã.

Usar como se segue: 

        // Coloca cursor no canto superior esquerdo do ecrã:
        ecra << cursor(0, 0);

        // Define objecto cor para a próxima escrita:
        Ecra::ObjectoCor cor(amarelo, vermelho);

        // Escreve "Olá mundo! " usando a cor indicada:
        ecra << oor << "Olá mundo! ";

        // Escreve "Olá mundo!" mas usando a cor do fundo:
        ecra << fundo << "Olá mundo!";

        // Refresca o ecrã:
        ecra << refresca;

Veja também:
Ecra::mudaObjectoCorEmUsoParaFundo().

Definido na linha 1146 do ficheiro ecra_impl.H.

Referências Slang::ecra.

Referenciado por Slang::Ecra::cola(), Slang::CaixaDeTexto::interage(), Slang::MenuSimples::interage() e main().

void Slang::parado (  Ecra &    ecra )  [inline]
 

Manipulador usado para manter o cursor na posição corrente durante a próxima operação de inserção no ecrã.

Usar como se segue: 

        // Coloca cursor no canto superior esquerdo do ecrã:
        ecra << cursor(0, 0);

        // Escreve "Olá mundo!" mantendo a posição do cursor no topo superior
        // esquerdo do ecrã:
        ecra << parado << "Olá mundo!";

        // Refresca o ecrã:
        ecra << refresca;

Veja também:
Ecra::impoeImobilidadeDoCursorNaProximaInsercao()

Definido na linha 1151 do ficheiro ecra_impl.H.

Referências Slang::ecra.

Referenciado por main(), procedimento1() e procedimento2().

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

Manipulador usado para subir o cursor no ecrã.

Usar como se segue: 

        // Coloca cursor a meio do ecrã, à esquerda:
        ecra << cursor(ecra.dimensao().numeroDeLinhas() / 2, 0);

        // Escreve "mundo!" mantendo a posição do cursor:
        ecra << parado << "mundo!";

        // Sobe cursor para a linha acima:
        ecra << sobeCursor;

        // Escreve "Olá" mantendo a posição do cursor:
        ecra << parado << "Olá";

        // Refresca o ecrã:
        ecra << refresca;

Veja também:
Ecra::sobeCursor()

Definido na linha 1156 do ficheiro ecra_impl.H.

Referências Slang::ecra.

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

Manipulador usado para baixar o cursor no ecrã.

Usar como se segue: 

        // Coloca cursor a meio do ecrã, à esquerda:
        ecra << cursor(ecra.dimensao().numeroDeLinhas() / 2, 0);

        // Escreve "Olá" mantendo a posição do cursor:
        ecra << parado << "Olá";

        // Baixa o cursor:
        ecra << sobeCursor;

        // Escreve "mundo!" mantendo a posição do cursor:
        ecra << parado << "mundo!";

        // Refresca o ecrã:
        ecra << refresca;

Veja também:
Ecra::baixaCursor()

Definido na linha 1161 do ficheiro ecra_impl.H.

Referências Slang::ecra.

Referenciado por main(), procedimento1() e procedimento2().

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

Manipulador usado para recuar o cursor no ecrã.

Usa-se como os manipuladores sobeCursor() e baixaCursor().

Veja também:
Ecra::recuaCursor()

Definido na linha 1166 do ficheiro ecra_impl.H.

Referências Slang::ecra.

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

Manipulador usado para avançar o cursor no ecrã.

Usa-se como os manipuladores sobeCursor() e baixaCursor().

Veja também:
Ecra::avancaCursor()

Definido na linha 1171 do ficheiro ecra_impl.H.

Referências Slang::ecra.

Slang::ManipuladorDaLargura Slang::largura (  int const    largura )  [inline]
 

Manipulador usado para indicar o número de células do ecrã a ocupar na próxima operação de inserção no ecrã.

Usar como se segue: 

        // Coloca cursor no canto superior esquerdo do ecrã:
        ecra << cursor(0, 0);

        // Define objecto cor para a próxima escrita:
        Ecra::ObjectoCor cor(amarelo, vermelho);

        // Escreve "Olá mundo! " usando a cor indicada e centrados em 30
        // caracteres:
        ecra << oor << ao_centro << largura(30) << "Olá mundo!";

Precondição:
0 <= largura
Veja também:
Ecra::mudaLarguraDaProximaOperacaoDeEscritaPara()

Definido na linha 1176 do ficheiro ecra_impl.H.

Referências Slang::largura().

Referenciado por Slang::Ecra::desenhaSegmentoHorizontalCom(), Slang::largura(), main(), Slang::ManipuladorDaLargura::ManipuladorDaLargura() e Slang::segmento_horizontal().

Slang::ManipuladorDeDesenhoDeSegmento Slang::segmento_horizontal (  int const    largura )  [inline]
 

Manipulador usado para desenhar um segmento de recta horizontal.

Veja-se um exemplo de utilização no programa abaixo: 

#include <Slang++/slang.H>

using namespace Slang;

int main()
{
    // Guardar dimensão do ecrã:
    int const altura = ecra.dimensao().numeroDeLinhas();
    int const largura = ecra.dimensao().numeroDeColunas();

    // Desenhar segmento de recta horizontal a meio do ecrã e com meia largura
    // do ecrã: 
    ecra << cursor(altura / 2, largura / 4) 
         << segmento_horizontal(largura / 2);

    // Desenhar segmento de recta vertical a meio do ecrã e com meia altura do
    // ecrã: 
    ecra << cursor(altura / 4, largura / 2) 
         << segmento_vertical(altura / 2);

    // Refescar e esperar por tecla:
    ecra << refresca;
    teclado.leProximaTeclaDisponivel();

    ecra << apaga << refresca;
    teclado.leProximaTeclaDisponivel();

    // O mesmo, mas usando operações da classe Ecra:

    ecra << cursor(altura / 2, largura / 4);
    ecra.desenhaSegmentoHorizontalCom(largura / 2);

    ecra << cursor(altura / 4, largura / 2);
    ecra.desenhaSegmentoVerticalCom(altura / 2);

    // Refescar e esperar por tecla:
    ecra << refresca;
    teclado.leProximaTeclaDisponivel();
}

Precondição:
0 <= largura
Veja também:
Ecra::desenhaSegmentoHorizontalCom()

Definido na linha 1184 do ficheiro ecra_impl.H.

Referências Slang::largura().

Referenciado por main().

Slang::ManipuladorDeDesenhoDeSegmento Slang::segmento_vertical (  int const    altura )  [inline]
 

Manipulador usado para desenhar um segmento de recta vertical.

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

Precondição:
0 <= largura
Veja também:
Ecra::desenhaSegmentoVerticalCom()

Definido na linha 1192 do ficheiro ecra_impl.H.

Referenciado por main().

void Slang::refresca (  Ecra &    ecra )  [inline]
 

Manipulador usado para refrescar o ecrã.

Usado como se segue: 

        // Coloca cursor no canto superior esquerdo do ecrã:
        ecra << cursor(0, 0);

        // Escreve "Olá mundo!" a partir dessa posição:
        ecra << "Olá mundo";

        // Refresca o ecrã:
        ecra << refresca;

Veja também:
Ecra::refresca()

Definido na linha 1199 do ficheiro ecra_impl.H.

Referências Slang::ecra.

Referenciado por Slang::CaixaDeTexto::interage(), Slang::MenuSimples::interage(), main(), procedimento1() e procedimento2().

void Slang::refresca_tudo (  Ecra &    ecra )  [inline]
 

Manipulador usado para fazer o refrescamento total do ecrã.

Usado como se segue: 

        ecra << refresca_tudo;

Veja também:
Ecra::refrescaTudo()

Definido na linha 1204 do ficheiro ecra_impl.H.

Referências Slang::ecra.

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

Manipulador usado para apagar o ecrã (ou seja, para o pintar com a cor do fundo).

Usar como se segue: 

        // Apaga o ecrã:
        ecra << apaga;

        // Refresca o ecrã:
        ecra << refresca;

Veja também:
Ecra::apaga()

Definido na linha 1209 do ficheiro ecra_impl.H.

Referências Slang::ecra.

Referenciado por main().

void Slang::apaga_fim_da_linha (  Ecra &    ecra )  [inline]
 

Manipulador usado para apagar até ao fim da linha do cursor (ou seja, para o pintar com a cor do fundo).

Usar como se segue: 

        // Apaga linha 10 a partir da coluna 20:
        ecra << cursor(10, 20) << apaga_fim_da_linha;

        // Refresca o ecrã:
        ecra << refresca;

Veja também:
Ecra::apagaDoCursorAteOFimDaLinha()

Definido na linha 1214 do ficheiro ecra_impl.H.

Referências Slang::ecra.

void Slang::apaga_fim_do_ecra (  Ecra &    ecra )  [inline]
 

Manipulador usado para apagar desde a posição do cursor até ao fim do ecrã (ou seja, para o pintar com a cor do fundo).

Usar como se segue: 

        // Apaga ecrã a partir da coluna 20 da linha 10:
        ecra << cursor(10, 20) << apaga_fim_do_ecra;

        // Refresca o ecrã:
        ecra << refresca;

Veja também:
Ecra::apagaDoCursorAteOFim()

Definido na linha 1219 do ficheiro ecra_impl.H.

Referências Slang::ecra.

void Slang::campainha (  Ecra &    ecra )  [inline]
 

Manipulador usado para fazer soar a campainha.

Usar como se segue: 

        ecra << campainha;

Veja também:
Ecra::tocaCampainha()

Definido na linha 1224 do ficheiro ecra_impl.H.

Referências Slang::ecra.

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

Documentação das variáveis

Caixa const Slang::caixa_vazia
 

Constante representando uma caixa vazia, i.e., com dimensão nula.

Esta caixa tem como origem o canto superior esquerdo do ecrã.

Definido na linha 897 do ficheiro ecra.H.

Slang::Ecra Slang::ecra
 

Uma variável global representando o ecrã.

A ideia é que substitua a variável global cout usada normalmente para escrever no ecrã. É através desta variável que se procede a todas as inserções no ecrã.

Definido na linha 515 do ficheiro ecra.C.

Referenciado por Slang::apaga(), Slang::apaga_fim_da_linha(), Slang::apaga_fim_do_ecra(), Slang::avancaCursor(), Slang::baixaCursor(), Slang::campainha(), cursor_aleatorio(), Slang::fundo(), Slang::CaixaDeTexto::interage(), Slang::MenuSimples::interage(), main(), Slang::Ecra::ObjectoCor::mudaCorDoFundoPara(), Slang::Ecra::ObjectoCor::mudaCorDoTextoPara(), Slang::Ecra::ObjectoCor::ObjectoCor(), Slang::operator<<(), Slang::Ecra::operator<<(), Slang::parado(), procedimento1(), procedimento2(), Slang::recuaCursor(), Slang::refresca(), Slang::refresca_tudo(), Slang::sobeCursor() e Slang::Ecra::ObjectoCor::~ObjectoCor().

string const Slang::nomes_das_cores
 

Valor inicial:

 {
    "preto",
    "cinza",
    "vermelho",
    "vermelho-brilhante",
    "verde",
    "verde-brilhante",
    "castanho",
    "amarelo",
    "azul",
    "azul-brilhante",
    "magenta",
    "magenta-brilhante",
    "ciano",
    "ciano-brilhante",
    "cinzento-claro",
    "branco"
}
Constante global com os nomes das cores.

Indexável com os valores do tipo enumerado Cor.

Definido na linha 517 do ficheiro ecra.C.

Referenciado por Slang::MenuDeCores::MenuDeCores().

Caixa const Slang::caixa_universal
 

Constante representando a caixa universal (enche todo o espaço).

Definido na linha 905 do ficheiro ecra.H.

int const Slang::numero_de_cores
 

Constante que guarda o número total de cores.

Definido na linha 966 do ficheiro ecra.H.

Referenciado por Slang::MenuDeCores::MenuDeCores().

Gerado em Tue Dec 3 15:19:36 2002 para Pacotes por doxygen1.3-rc1