---

ecra.H

Ir para a documentação deste ficheiro.

#ifndef SLANG_ECRA_H
#define SLANG_ECRA_H

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

#include <Slang++/teclado.H>

namespace Slang {

    // Declaração de classe definida mais abaixo.
    class Dimensao;


    class Posicao {
    public:


        explicit Posicao(int const linha = 0, 
                         int const coluna = 0);




        int linha() const;

        int coluna() const;




        void mudaLinhaPara(int const nova_linha);

        void mudaColunaPara(int const nova_coluna);




        explicit Posicao(std::istream& entrada);

        void carregaDe(std::istream& entrada);

        void guardaEm(std::ostream& saida) const;




        Posicao& operator+=(Dimensao const& deslocamento);

        Posicao& operator-=(Dimensao const& deslocamento);


    private:
        int linha_;
        int coluna_;

        bool cumpreInvariante() const;
    };

    Posicao const operator+(Posicao posicao, 
                            Dimensao const& deslocamento);

    Posicao const operator-(Posicao posicao, 
                            Dimensao const& deslocamento);

    Posicao const operator+(Dimensao const& deslocamento,
                            Posicao posicao);

    Posicao const operator-(Dimensao const& deslocamento,
                            Posicao const& posicao);

    Dimensao const operator-(Posicao const& destino,
                             Posicao const& origem);

    Posicao const operator-(Posicao const& posicao);

    bool operator==(Posicao const& uma_posicao, 
                    Posicao const& outra_posicao);

    bool operator!=(Posicao const& uma_posicao, 
                    Posicao const& outra_posicao);


    class Dimensao {
    public:


        explicit Dimensao(int const numero_de_linhas = 0, 
                          int const numero_de_colunas = 0);

        explicit Dimensao(Posicao const& posicao);




        int numeroDeLinhas() const;

        int numeroDeColunas() const;




        bool eCanonica() const;




        void mudaNumeroDeLinhasPara(int const novo_numero_de_linhas);

        void mudaNumeroDeColunasPara(int const novo_numero_de_colunas);




        explicit Dimensao(std::istream& entrada);

        void carregaDe(std::istream& entrada);

        void guardaEm(std::ostream& saida) const;




        Dimensao& operator+=(Dimensao const& dimensao);

        Dimensao& operator-=(Dimensao const& dimensao);


    private:
        bool cumpreInvariante() const;

        int numero_de_linhas;
        int numero_de_colunas;
    };

    Dimensao const operator+(Dimensao uma_dimensao, 
                             Dimensao const& outra_dimensao);

    Dimensao const operator-(Dimensao uma_dimensao, 
                             Dimensao const& outra_dimensao);

    Dimensao const operator-(Dimensao const& dimensao);

    bool operator==(Dimensao const& uma_dimensao, 
                    Dimensao const& outra_dimensao);

    bool operator!=(Dimensao const& uma_dimensao, 
                    Dimensao const& outra_dimensao);


    class Caixa {
    public:


        explicit Caixa(Posicao const& origem = Posicao(), 
                       Dimensao const& dimensao = Dimensao());

        explicit Caixa(Posicao const& origem, 
                       Posicao const& extremo);

        


        Posicao const& origem() const;

        Posicao extremo() const;

        Dimensao const& dimensao() const;




        bool eVazia() const;

        bool eCanonica() const;

        bool contem(Posicao const& posicao) const;

        bool bordaContem(Posicao const& posicao) const;




        void mudaOrigemPara(Posicao const& nova_origem);

        void mudaExtremoPara(Posicao const& novo_extremo);

        void mudaDimensaoPara(Dimensao const& nova_dimensao);




        explicit Caixa(std::istream& entrada);

        void carregaDe(std::istream& entrada);

        void guardaEm(std::ostream& saida) const;




        Caixa& operator+=(Dimensao const& deslocamento);

        Caixa& operator-=(Dimensao const& deslocamento);

        Caixa& operator+=(Caixa const& outra_caixa);

        Caixa& operator*=(Caixa const& outra_caixa);


    private:
        bool cumpreInvariante() const;

        Posicao origem_;
        Dimensao dimensao_;
    };

    Caixa const operator+(Caixa caixa, Dimensao const& deslocamento);

    Caixa const operator-(Caixa caixa, Dimensao const& deslocamento);

    Caixa const operator+(Dimensao const& deslocamento, Caixa caixa);

    Caixa const operator+(Caixa uma_caixa, Caixa const& outra_caixa);

    Caixa const operator*(Caixa uma_caixa, Caixa const& outra_caixa);

    bool operator==(Caixa const& uma_caixa, Caixa const& outra_caixa);

    bool operator!=(Caixa const& uma_caixa, Caixa const& outra_caixa);


    Caixa const caixa_vazia = Caixa();

    Caixa const caixa_universal = 
    Caixa(Posicao(std::numeric_limits<int>::min(),
                  std::numeric_limits<int>::min()), 
          Dimensao(std::numeric_limits<int>::max(),
                  std::numeric_limits<int>::max()));



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


    std::ostream& operator<<(std::ostream& saida, Cor const cor);

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

    int const numero_de_cores = ultima_cor + 1;


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


    class Ecra {
    public:
        // A classe Manipulador será definida mais abaixo.
        class Manipulador;

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

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



        explicit Ecra(Cor cor_do_texto = branco, 
                      Cor cor_do_fundo = preto, 
                      bool limita_cursor_ao_ecra_real = false);

        ~Ecra();




        Dimensao const dimensao() const;

        Posicao const origem() const;

        Posicao const extremo() const;

        Posicao const posicaoDoCursor() const;

        Justificacao justificacaoActual() const;

        int larguraDaProximaOperacaoDeEscrita() const;




        bool foiRedimensionado() const;

        bool cursorEstaVisivel() const;

        bool parteVisivelContem(Posicao const& posicao) const;

        bool cursorEstaLimitadoAoEcraReal() const;

        bool cursorImovelNaProximaOperacaoDeInsercao() const;




        void mudaJustificacaoPara(Justificacao const nova_justificacao);

        void impoeImobilidadeDoCursorNaProximaInsercao();

        void mudaLarguraDaProximaOperacaoDeEscritaPara
        (int const largura_da_proxima_operacao_de_escrita);

        void mudaObjectoCorEmUsoPara(ObjectoCor const& 
                                     objecto_cor);

        void mudaObjectoCorEmUsoParaFundo();

        void mudaCoresDasCelulasDoFundoPara(Cor const cor_do_texto, 
                                            Cor const cor_do_fundo);

        void moveCursorPara(Posicao const& nova_posicao_do_cursor);

        void sobeCursor();

        void baixaCursor();

        void recuaCursor();

        void avancaCursor();

        void moveCursorDeAcordoCom(Tecla const& tecla);




        Troco const trocoDe(Caixa const& caixa) const;

        Troco const trocoDoEcraCompleto() const;

        Troco const trocoNoCursorCom(Dimensao const& dimensao) const;

        void cola(Troco const& troco, 
                  Posicao const& em = Posicao());




        void tocaCampainha() const;

        void apagaDoCursorAteOFimDaLinha(); 

        void apagaDoCursorAteOFim();

        void apaga();

        void refresca() const;

        void refrescaTudo() const;

        void desenha(Caixa const& caixa);

        void desenhaSegmentoHorizontalCom(int const largura);

        void desenhaSegmentoVerticalCom(int const altura);



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

        template <typename T>
        Ecra& operator<<(T const& valor);



        Ecra& operator<<(Caixa const& caixa);

        Ecra& operator<<(Simbolo const simbolo);

        Ecra& operator<<(Troco const& troco);




        Ecra const& operator>>(Troco& troco) const;



        Ecra& operator<<(Posicao const& nova_posicao_do_cursor);

        Ecra& operator<<(ObjectoCor const& objecto_cor);

        Ecra& operator<<(Justificacao const nova_justificacao);

        Ecra& operator<<(void manipulador(Ecra& ecra));


    private:
        bool cursor_esta_limitado_ao_ecra_real;

        mutable bool redimensionado_;

        bool cursor_imovel_na_proxima_operacao_de_escrita;

        Justificacao justificacao_actual;

        int largura_da_proxima_operacao_de_escrita;

        std::vector<int> ocupacao_dos_objectos;

        static bool ja_existe_instancia;

        // Variável alterada pelo manipulador do sinal SIGWINCH
        // (SIGnal WINdow CHanged):
        static volatile bool tamanho_do_ecra_real_mudou;

        static char *nome_de_cor_do_s_lang[numero_de_cores];

        // Assim ninguém pode invocar o construtor por cópia...
        Ecra(Ecra const&);

        // ...nem a atribuição por cópia:
        Ecra& operator = (Ecra const&);

        // Coloca atributos num dado objecto:
        void mudaCoresDe(int const objecto, 
                         Cor const cor_do_texto, Cor const cor_do_fundo);

        // Verifica se a dimensão do ecrã real sofreu alterações:
        void verificaRedimensionamento() 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 moveCursorPara(Posicao const& posicao) const;

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

        // Manipulador do sinal SIGWINCH:
        static void manipuladorDeRedimensionamento(int sinal);

        bool cumpreInvariante() const;

        // Amizades:
        friend class ObjectoCor;
    };

    class Ecra::ObjectoCor {
    public:
        ObjectoCor(Cor const cor_do_texto, Cor const cor_do_fundo);
        
        ~ObjectoCor();



        Cor corDoTexto() const;

        Cor corDoFundo() const;




        void mudaCorDoTextoPara(Cor const nova_cor_do_texto);

        void mudaCorDoFundoPara(Cor const nova_cor_do_fundo);


    private:
        static int const numero_de_objectos_cor_no_s_lang = 256;

        // Não se podem copiar estes objectos!
        ObjectoCor(ObjectoCor const&);
        ObjectoCor& operator=(ObjectoCor const&);

        Cor cor_do_texto;
        Cor cor_do_fundo;
        int numero_do_objecto;  // entrada na palete.

        bool cumpreInvariante() const;

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

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

        Dimensao dimensao() const;

    private:
        Dimensao dimensao_;
        std::vector<unsigned short> dados;

        bool cumpreInvariante() const;

        // A classe Ecra precisa de acesso a dados privados desta
        // classe.
        friend class Ecra;
    };


    extern Ecra ecra;


    // Classes auxiliares para manipuladores:

    struct ManipuladorDaLargura {
        explicit ManipuladorDaLargura(int const largura = 0); 

        int largura;
    };
    
    Ecra& operator<<(Ecra& ecra, 
                     ManipuladorDaLargura const& manipulador);

    struct ManipuladorDeDesenhoDeSegmento {
        explicit ManipuladorDeDesenhoDeSegmento(bool const e_horizontal, 
                                                int const dimensao = 1); 

        bool e_horizontal;
        int dimensao;
    };

    Ecra& operator<<(Ecra& ecra, 
                     ManipuladorDeDesenhoDeSegmento const& manipulador);



    Posicao const cursor(int const linha, int const coluna);

    Posicao const& cursor(Posicao const& posicao);

    Caixa const caixa(int const linha, int const coluna, 
                      int const numero_de_linhas, int const numero_de_colunas);

    Caixa const caixa(Posicao const& origem = Posicao(), 
                      Dimensao const& dimensao = Dimensao());
    
    void fundo(Ecra& ecra);

    void parado(Ecra& ecra);

    void sobeCursor(Ecra& ecra);

    void baixaCursor(Ecra& ecra);

    void recuaCursor(Ecra& ecra);

    void avancaCursor(Ecra& ecra);

    ManipuladorDaLargura largura(int const largura);

    ManipuladorDeDesenhoDeSegmento segmento_horizontal(int const largura);

    ManipuladorDeDesenhoDeSegmento segmento_vertical(int const altura);

    void refresca(Ecra& ecra);

    void refresca_tudo(Ecra& ecra);

    void apaga(Ecra& ecra);

    void apaga_fim_da_linha(Ecra& ecra);

    void apaga_fim_do_ecra(Ecra& ecra);

    void campainha(Ecra& ecra);


    extern std::string const nomes_das_cores[numero_de_cores];
}

#include <Slang++/ecra_impl.H>

#endif // SLANG_ECRA_H

---