---

ecra.H

Ir para a documentação deste ficheiro.

#ifndef SLANG_ECRA_H
#define SLANG_ECRA_H

#include <string>
#include <vector>
#include <iostream>

#include <Slang/teclado.H>

namespace Slang {

#define ANTIGO

#ifdef ANTIGO

#define Coordenada Posicao
#endif
    
    class Dimensao;

    class Posicao {
    public:


        explicit Posicao(int linha = 0, int coluna = 0);
        explicit Posicao(std::istream& entrada);



        int linha() const;
        int coluna() const;



        void linha(int linha);
        void coluna(int coluna);



        void carrega(std::istream& entrada);
        void guarda(std::ostream& saida) const;



        Posicao& operator += (Posicao const& c);
        Posicao& operator -= (Posicao const& c);
        Posicao& operator += (Dimensao const& c);
        Posicao& operator -= (Dimensao const& c);

    private:
        int linha_;
        int coluna_;
    };

    Posicao operator + (Posicao a, Posicao const& b);
    Posicao operator - (Posicao a, Posicao const& b);
    Posicao operator + (Posicao a, Dimensao const& b);
    Posicao operator - (Posicao a, Dimensao const& b);
    Posicao operator - (Posicao const& b);
    bool operator == (Posicao const& a, Posicao const& b);

    class Dimensao {
    public:


        explicit Dimensao(int linhas = 0, int colunas = 0);
        explicit Dimensao(Posicao const& c);
        explicit Dimensao(std::istream& entrada);



        int linhas() const;
        int colunas() const;



        void linhas(int linhas);
        void colunas(int colunas);



        void carrega(std::istream& entrada);
        void guarda(std::ostream& saida) const;



        Dimensao& operator += (Dimensao const& c);
        Dimensao& operator -= (Dimensao const& c);

    private:
        int linhas_;            // -1 significa tão alto quanto possível.
        int colunas_;           // -1 significa tão largo quanto possível.
    };

    Dimensao operator + (Dimensao a, Dimensao const& b);
    Dimensao operator - (Dimensao a, Dimensao const& b);
    bool operator == (Dimensao const& a, Dimensao const& b);

    class Caixa {
    public:


        explicit Caixa(Posicao const& origem = Posicao(), 
                       Dimensao const& dimensao = Dimensao());
        explicit Caixa(Posicao const& a, Posicao const& b);
        explicit Caixa(std::istream& entrada);
        


        Posicao origem() const;
        Posicao destino() const;
        Dimensao dimensao() const;

        bool vazia() const;



        bool contem(Posicao const& p) const;
        bool bordaContem(Posicao const& p) const;



        void origem(Posicao const& origem);
        void destino(Posicao const& destino);
        void dimensao(Dimensao const& dimensao);



        Caixa& operator += (Posicao const& c);
        Caixa& operator += (Caixa const& c);
        Caixa& operator *= (Caixa const& c);



        void carrega(std::istream& entrada);
        void guarda(std::ostream& saida) const;

    private:
        Posicao origem_;
        Dimensao dimensao_;
    };

    Caixa operator + (Caixa a, Posicao const& c);
    Caixa operator + (Posicao const& c, Caixa a);
    Caixa operator + (Caixa a, Caixa const& b);
    Caixa operator * (Caixa a, Caixa const& b);// caixa intersecção.

    Caixa const caixa_vazia = Caixa();
    Caixa const caixa_universal = Caixa(Posicao(-10000, -10000), 
                                        Dimensao(10000, 10000));


    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
    };

    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
    };

    enum Justificacao {
        ao_centro,
        a_esquerda,
        a_direita
    };

    std::ostream& operator << (std::ostream& saida, Cor cor);
    std::istream& operator >> (std::istream& entrada, Cor& cor);

    int const numero_de_cores = ultima_cor + 1;


    class Ecra {
    public:
        // Várias classes embutidas para definir manipuladores.  Muitos
        // métodos podem ser invocados indirectamente usando manipuladores:
        struct Fundo;
        struct Parado;
        struct Largura;
        struct Linha;
        struct Refresca;
        struct RefrescaTudo;
        struct Apaga;
        struct ApagaFimDaLinha;
        struct ApagaFimDoEcra;
        struct Campainha;
        class Troco;

        // A classe ObjectoCor será definida mais abaixo.
        class ObjectoCor;

        explicit Ecra(Cor texto = branco, Cor fundo = preto, 
                      bool limita_cursor = false);

        ~Ecra();



        Dimensao dimensao() const;
        Posicao cursor() const;
        bool redimensionado() const;



        void atributos(Cor texto, Cor fundo);
        void cursor(Posicao const& posicao);
        void cima();
        void baixo();
        void esquerda();
        void direita();
        void desloca(Tecla const& tecla);



        Troco copia(Caixa const& caixa) const;
        Troco copia() const;
        Troco copia(Dimensao const& dimensao) const;
        void cola(Troco const& troco, Posicao const& origem = Posicao());



        void campainha() const;
        void apagaFimDaLinha(); 
        void apagaFimDoEcra();
        void apaga();
        void refresca() const;
        void refrescaTudo() const;
        void desenhaCaixa(Caixa const& caixa);



        Ecra& operator << (char c);
        Ecra& operator << (int i);
        Ecra& operator << (string c);



        Ecra& operator << (Caixa const& caixa);
        Ecra& operator << (Simbolo simbolo);
        Ecra& operator << (Troco const& troco);
        Ecra& operator << (Posicao const& posicao);
        Ecra& operator << (ObjectoCor const& objecto_cor);

        Ecra const& operator >> (Troco& troco) const;
        
        // Operadores de inserção de manipuladores no ecrã:
        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&);

    private:
        // Métodos auxiliares.  Usados para a implementação:
        
        // Colocar atributos num dado objecto:
        void atributos(Cor texto, Cor fundo, int objecto);

        // Verificar se o tamanho do ecrã sofreu alterações:
        void verificaTamanho() const;

        // Assim ninguém pode invocar o construtor por cópia...
        Ecra(Ecra const&);
        // ...nem a atribuição por cópia:
        Ecra& operator = (Ecra const&);

        // Só os membros da classe podem posicionar o cursor sem que isso seja 
        // considerado uma alteração.  Quando o fizerem têm de se
        // responsabilizar por voltar a por o cursor na posição original.
        void cursor(Posicao const& posicao) const;

        // Usados pelos objectos cor para reservar ou libertar um lugar na
        // palete:
        int reservaObjecto();
        void libertaObjecto(int objecto);

        // Variáveis membro:
        bool limita_cursor;     // o cursor está a ser limitado?
        mutable bool redimensionado_; // o ecrã foi redimensionado?
        bool para_no_proximo; // a próxima operação de escrita simples não
                                // altera a posição do cursor.
        Justificacao justificacao; // as próximas operações de escrita usam a
                                // justificação indicada.
        int largura_do_proximo; // a próxima operação de escrita simples
                                // ocupará pelo menos os espaços indicados.
        vector<int> ocupacao_objecto;// estado de ocupação dos objectos da
                                // palete.


        // Variáveis membro de classe:
        static bool existe_instancia;// Para não deixar existir qualquer outra 
                                // instância do ecrã.
        static volatile bool tamanho_mudou; // o ecrã foi redimensionado?
                                // alterada pelo menipulador do sinal SIGWINCH.
        static char *nome_de_cor[numero_de_cores];// nomes das cores usados
                                // pelo Slang.

        // Métodos de classe:
        static void manipuladorTamanhoMudou(int sinal);// manipulador do sinal
                                // SIGWINCH.

        // Amizades:
        friend ObjectoCor;
    };

    class Ecra::ObjectoCor {
    public:
        ObjectoCor(Cor texto, Cor fundo);
        
        ~ObjectoCor();



        Cor texto() const;
        Cor fundo() const;



        void texto(Cor texto);
        void fundo(Cor fundo);

    private:
        // Não se podem copiar estes objectos!
        ObjectoCor(ObjectoCor const&);
        ObjectoCor& operator = (ObjectoCor const&);
        Cor texto_;             // cor do texto.
        Cor fundo_;             // cor do fundo.
        int objecto;            // número do objecto (entrada na palete).

        // A classe Ecra precisa de aceder ao número do objecto:
        friend Ecra;
    };

    class Ecra::Troco {
    public:
        explicit Troco(Dimensao const& dimensao);

        Dimensao dimensao() const;

    private:
        Dimensao dimensao_;
        vector<unsigned short> dados;
        // A classe Ecra precisa de acesso a dados privados desta classe.
        friend Ecra;
    };


    extern Ecra ecra;


    // Classes para os manipuladores:

    struct Ecra::Fundo {
    };

    struct Ecra::Parado {
    };
    
    struct Ecra::Largura {
        explicit Largura(int largura = 0); 
        Largura operator() (int largura) const;
        int largura;
    };
    
    struct Ecra::Linha {
        explicit Linha(bool horizontal, int dimensao = 1); 
        Linha operator() (int dimensao) const;
        bool horizontal;
        int dimensao;
    };
    
    struct Ecra::Refresca {
    };

    struct Ecra::RefrescaTudo {
    };

    struct Ecra::ApagaFimDaLinha {
    };
    
    struct Ecra::ApagaFimDoEcra {
    };
    
    struct Ecra::Apaga {
    };

    struct Ecra::Campainha {
    };

    // Manipuladores não documentados.
    Caixa caixa(Posicao const& origem = Posicao(), 
                Dimensao const& dimensao = Dimensao());
    Posicao cursor(Posicao const& posicao);


    Posicao cursor(int linha, int coluna);

    Caixa caixa(int linha, int coluna, int linhas, int colunas);
    
    Ecra::Fundo const fundo = Ecra::Fundo();

    Ecra::Parado const parado = Ecra::Parado();

    Ecra::Largura const largura;

    Ecra::Linha const linha_horizontal(true);

    Ecra::Linha const linha_vertical(false);

    Ecra::Refresca const refresca = Ecra::Refresca();

    Ecra::RefrescaTudo const refresca_tudo = Ecra::RefrescaTudo();

    Ecra::Apaga const apaga = Ecra::Apaga();

    Ecra::ApagaFimDaLinha const apaga_fim_da_linha = Ecra::ApagaFimDaLinha();

    Ecra::ApagaFimDoEcra const apaga_fim_do_ecra = Ecra::ApagaFimDoEcra();

    Ecra::Campainha const campainha = Ecra::Campainha();

    extern string const nomes_das_cores[numero_de_cores];
}

#include <Slang/ecra_impl.H>

#endif // SLANG_ECRA_H

---