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

ecra.H

Ir para a documentação deste ficheiro.
00001 
00010 #ifndef SLANG_ECRA_H
00011 #define SLANG_ECRA_H
00012 
00013 #include <string>
00014 #include <vector>
00015 #include <iostream>
00016 
00017 #include <Slang/teclado.H>
00018 
00019 namespace Slang {
00020 
00027 #define ANTIGO
00028 
00029 #ifdef ANTIGO
00030 
00031 #define Coordenada Posicao
00032 #endif
00033     
00034     class Dimensao;
00035 
00042     class Posicao {
00043     public:
00045 
00046 
00051         explicit Posicao(int linha = 0, int coluna = 0);
00058         explicit Posicao(std::istream& entrada);
00060 
00062 
00063 
00064         int linha() const;
00066         int coluna() const;
00068 
00070 
00071 
00072         void linha(int linha);
00074         void coluna(int coluna);
00076 
00078 
00079 
00085         void carrega(std::istream& entrada);
00090         void guarda(std::ostream& saida) const;
00092 
00094 
00095 
00097         Posicao& operator += (Posicao const& c);
00100         Posicao& operator -= (Posicao const& c);
00102         Posicao& operator += (Dimensao const& c);
00104         Posicao& operator -= (Dimensao const& c);
00106 
00107     private:
00108         int linha_;
00109         int coluna_;
00110     };
00111 
00118     Posicao operator + (Posicao a, Posicao const& b);
00122     Posicao operator - (Posicao a, Posicao const& b);
00125     Posicao operator + (Posicao a, Dimensao const& b);
00128     Posicao operator - (Posicao a, Dimensao const& b);
00131     Posicao operator - (Posicao const& b);
00134     bool operator == (Posicao const& a, Posicao const& b);
00136 
00142     class Dimensao {
00143     public:
00145 
00146 
00151         explicit Dimensao(int linhas = 0, int colunas = 0);
00153         explicit Dimensao(Posicao const& c);
00160         explicit Dimensao(std::istream& entrada);
00162 
00164 
00165 
00166         int linhas() const;
00168         int colunas() const;
00170 
00172 
00173 
00174         void linhas(int linhas);
00176         void colunas(int colunas);
00178 
00180 
00181 
00187         void carrega(std::istream& entrada);
00192         void guarda(std::ostream& saida) const;
00194 
00196 
00197 
00198         Dimensao& operator += (Dimensao const& c);
00200         Dimensao& operator -= (Dimensao const& c);
00202 
00203     private:
00204         int linhas_;            // -1 significa tão alto quanto possível.
00205         int colunas_;           // -1 significa tão largo quanto possível.
00206     };
00207 
00213     Dimensao operator + (Dimensao a, Dimensao const& b);
00216     Dimensao operator - (Dimensao a, Dimensao const& b);
00219     bool operator == (Dimensao const& a, Dimensao const& b);
00221 
00227     class Caixa {
00228     public:
00230 
00231 
00235         explicit Caixa(Posicao const& origem = Posicao(), 
00236                        Dimensao const& dimensao = Dimensao());
00243         explicit Caixa(Posicao const& a, Posicao const& b);
00250         explicit Caixa(std::istream& entrada);
00252         
00254 
00255 
00256         Posicao origem() const;
00258         Posicao destino() const;
00260         Dimensao dimensao() const;
00262 
00265         bool vazia() const;
00266 
00268 
00269 
00271         bool contem(Posicao const& p) const;
00274         bool bordaContem(Posicao const& p) const;
00276 
00278 
00279 
00281         void origem(Posicao const& origem);
00285         void destino(Posicao const& destino);
00287         void dimensao(Dimensao const& dimensao);
00289 
00291 
00292 
00293         Caixa& operator += (Posicao const& c);
00295         Caixa& operator += (Caixa const& c);
00297         Caixa& operator *= (Caixa const& c);
00299 
00301 
00302 
00308         void carrega(std::istream& entrada);
00313         void guarda(std::ostream& saida) const;
00315 
00316     private:
00317         Posicao origem_;
00318         Dimensao dimensao_;
00319     };
00320 
00326     Caixa operator + (Caixa a, Posicao const& c);
00329     Caixa operator + (Posicao const& c, Caixa a);
00332     Caixa operator + (Caixa a, Caixa const& b);
00335     Caixa operator * (Caixa a, Caixa const& b);// caixa intersecção.
00337 
00344     Caixa const caixa_vazia = Caixa();
00348     Caixa const caixa_universal = Caixa(Posicao(-10000, -10000), 
00349                                         Dimensao(10000, 10000));
00351 
00352 
00361     enum Cor {
00362         preto,                  
00363         primeira_cor = preto,        
00364         cinza,                  
00365         vermelho,               
00366         vermelho_brilhante,     
00367         verde,                  
00368         verde_brilhante,        
00369         castanho,               
00370         amarelo,                
00371         azul,                   
00372         azul_brilhante,         
00373         magenta,                
00374         magenta_brilhante,      
00375         ciano,                  
00376         ciano_brilhante,        
00377         cinzento_claro,         
00378         branco,                 
00379         ultima_cor = branco
00380     };
00381 
00387     enum Simbolo {
00388         diamante = '`',
00389         tijolo,
00390         ht,
00391         ff,
00392         cr,
00393         lf,
00394         grau,
00395         mais_menos,
00396         nl,
00397         vt,
00398         canto_inferior_direito,
00399         canto_superior_direito,
00400         canto_superior_esquerdo,
00401         canto_inferior_esquerdo,
00402         cruzamento,
00403         traco_topo,
00404         traco_superior,
00405         traco_horizontal,
00406         traco_inferior,
00407         traco_base,
00408         encontro_direita,
00409         encontro_esquerda,
00410         encontro_cima,
00411         encontro_baixo,
00412         traco_vertical,
00413         menor_ou_igual,
00414         maior_ou_igual,
00415         pi,
00416         diferente
00417     };
00418 
00425     enum Justificacao {
00429         ao_centro,
00433         a_esquerda,
00437         a_direita
00438     };
00439 
00445     std::ostream& operator << (std::ostream& saida, Cor cor);
00448     std::istream& operator >> (std::istream& entrada, Cor& cor);
00450 
00454     int const numero_de_cores = ultima_cor + 1;
00455 
00456 
00540     class Ecra {
00541     public:
00542         // Várias classes embutidas para definir manipuladores.  Muitos
00543         // métodos podem ser invocados indirectamente usando manipuladores:
00544         struct Fundo;
00545         struct Parado;
00546         struct Largura;
00547         struct Linha;
00548         struct Refresca;
00549         struct RefrescaTudo;
00550         struct Apaga;
00551         struct ApagaFimDaLinha;
00552         struct ApagaFimDoEcra;
00553         struct Campainha;
00554         class Troco;
00555 
00556         // A classe ObjectoCor será definida mais abaixo.
00557         class ObjectoCor;
00558 
00574         explicit Ecra(Cor texto = branco, Cor fundo = preto, 
00575                       bool limita_cursor = false);
00576 
00579         ~Ecra();
00580 
00582 
00583 
00584         Dimensao dimensao() const;
00586         Posicao cursor() const;
00593         bool redimensionado() const;
00595 
00597 
00598 
00602         void atributos(Cor texto, Cor fundo);
00607         void cursor(Posicao const& posicao);
00609         void cima();
00611         void baixo();
00613         void esquerda();
00615         void direita();
00619         void desloca(Tecla const& tecla);
00621 
00623 
00624 
00626         Troco copia(Caixa const& caixa) const;
00628         Troco copia() const;
00632         Troco copia(Dimensao const& dimensao) const;
00643         void cola(Troco const& troco, Posicao const& origem = Posicao());
00645 
00647 
00648 
00649         void campainha() const;
00652         void apagaFimDaLinha(); 
00655         void apagaFimDoEcra();
00657         void apaga();
00660         void refresca() const;
00663         void refrescaTudo() const;
00667         void desenhaCaixa(Caixa const& caixa);
00669 
00671 
00672 
00680         Ecra& operator << (char c);
00691         Ecra& operator << (int i);
00705         Ecra& operator << (string c);
00707 
00709 
00710 
00714         Ecra& operator << (Caixa const& caixa);
00718         Ecra& operator << (Simbolo simbolo);
00726         Ecra& operator << (Troco const& troco);
00730         Ecra& operator << (Posicao const& posicao);
00736         Ecra& operator << (ObjectoCor const& objecto_cor);
00738 
00742         Ecra const& operator >> (Troco& troco) const;
00743         
00744         // Operadores de inserção de manipuladores no ecrã:
00745         Ecra& operator << (Fundo const&);
00746         Ecra& operator << (Parado const&);
00747         Ecra& operator << (Justificacao const&);
00748         Ecra& operator << (Largura const&);
00749         Ecra& operator << (Linha const&);
00750         Ecra& operator << (Refresca const&);
00751         Ecra& operator << (RefrescaTudo const&);
00752         Ecra& operator << (Apaga const&);
00753         Ecra& operator << (ApagaFimDaLinha const&);
00754         Ecra& operator << (ApagaFimDoEcra const&);
00755         Ecra& operator << (Campainha const&);
00756 
00757     private:
00758         // Métodos auxiliares.  Usados para a implementação:
00759         
00760         // Colocar atributos num dado objecto:
00761         void atributos(Cor texto, Cor fundo, int objecto);
00762 
00763         // Verificar se o tamanho do ecrã sofreu alterações:
00764         void verificaTamanho() const;
00765 
00766         // Assim ninguém pode invocar o construtor por cópia...
00767         Ecra(Ecra const&);
00768         // ...nem a atribuição por cópia:
00769         Ecra& operator = (Ecra const&);
00770 
00771         // Só os membros da classe podem posicionar o cursor sem que isso seja 
00772         // considerado uma alteração.  Quando o fizerem têm de se
00773         // responsabilizar por voltar a por o cursor na posição original.
00774         void cursor(Posicao const& posicao) const;
00775 
00776         // Usados pelos objectos cor para reservar ou libertar um lugar na
00777         // palete:
00778         int reservaObjecto();
00779         void libertaObjecto(int objecto);
00780 
00781         // Variáveis membro:
00782         bool limita_cursor;     // o cursor está a ser limitado?
00783         mutable bool redimensionado_; // o ecrã foi redimensionado?
00784         bool para_no_proximo; // a próxima operação de escrita simples não
00785                                 // altera a posição do cursor.
00786         Justificacao justificacao; // as próximas operações de escrita usam a
00787                                 // justificação indicada.
00788         int largura_do_proximo; // a próxima operação de escrita simples
00789                                 // ocupará pelo menos os espaços indicados.
00790         vector<int> ocupacao_objecto;// estado de ocupação dos objectos da
00791                                 // palete.
00792 
00793 
00794         // Variáveis membro de classe:
00795         static bool existe_instancia;// Para não deixar existir qualquer outra 
00796                                 // instância do ecrã.
00797         static volatile bool tamanho_mudou; // o ecrã foi redimensionado?
00798                                 // alterada pelo menipulador do sinal SIGWINCH.
00799         static char *nome_de_cor[numero_de_cores];// nomes das cores usados
00800                                 // pelo Slang.
00801 
00802         // Métodos de classe:
00803         static void manipuladorTamanhoMudou(int sinal);// manipulador do sinal
00804                                 // SIGWINCH.
00805 
00806         // Amizades:
00807         friend ObjectoCor;
00808     };
00809 
00860     class Ecra::ObjectoCor {
00861     public:
00865         ObjectoCor(Cor texto, Cor fundo);
00866         
00868         ~ObjectoCor();
00869 
00871 
00872 
00873         Cor texto() const;
00875         Cor fundo() const;
00877 
00879 
00880 
00882         void texto(Cor texto);
00885         void fundo(Cor fundo);
00887 
00888     private:
00889         // Não se podem copiar estes objectos!
00890         ObjectoCor(ObjectoCor const&);
00891         ObjectoCor& operator = (ObjectoCor const&);
00892         Cor texto_;             // cor do texto.
00893         Cor fundo_;             // cor do fundo.
00894         int objecto;            // número do objecto (entrada na palete).
00895 
00896         // A classe Ecra precisa de aceder ao número do objecto:
00897         friend Ecra;
00898     };
00899 
00912     class Ecra::Troco {
00913     public:
00919         explicit Troco(Dimensao const& dimensao);
00920 
00922         Dimensao dimensao() const;
00923 
00924     private:
00925         Dimensao dimensao_;
00926         vector<unsigned short> dados;
00927         // A classe Ecra precisa de acesso a dados privados desta classe.
00928         friend Ecra;
00929     };
00930 
00931 
00936     extern Ecra ecra;
00937 
00938 
00939     // Classes para os manipuladores:
00940 
00941     struct Ecra::Fundo {
00942     };
00943 
00944     struct Ecra::Parado {
00945     };
00946     
00947     struct Ecra::Largura {
00948         explicit Largura(int largura = 0); 
00949         Largura operator() (int largura) const;
00950         int largura;
00951     };
00952     
00953     struct Ecra::Linha {
00954         explicit Linha(bool horizontal, int dimensao = 1); 
00955         Linha operator() (int dimensao) const;
00956         bool horizontal;
00957         int dimensao;
00958     };
00959     
00960     struct Ecra::Refresca {
00961     };
00962 
00963     struct Ecra::RefrescaTudo {
00964     };
00965 
00966     struct Ecra::ApagaFimDaLinha {
00967     };
00968     
00969     struct Ecra::ApagaFimDoEcra {
00970     };
00971     
00972     struct Ecra::Apaga {
00973     };
00974 
00975     struct Ecra::Campainha {
00976     };
00977 
00978     // Manipuladores não documentados.
00979     Caixa caixa(Posicao const& origem = Posicao(), 
00980                 Dimensao const& dimensao = Dimensao());
00981     Posicao cursor(Posicao const& posicao);
00982 
00986 
01000     Posicao cursor(int linha, int coluna);
01001 
01014     Caixa caixa(int linha, int coluna, int linhas, int colunas);
01015     
01033     Ecra::Fundo const fundo = Ecra::Fundo();
01034 
01050     Ecra::Parado const parado = Ecra::Parado();
01051 
01066     Ecra::Largura const largura;
01067 
01079     Ecra::Linha const linha_horizontal(true);
01080 
01092     Ecra::Linha const linha_vertical(false);
01093 
01108     Ecra::Refresca const refresca = Ecra::Refresca();
01109 
01119     Ecra::RefrescaTudo const refresca_tudo = Ecra::RefrescaTudo();
01120 
01132     Ecra::Apaga const apaga = Ecra::Apaga();
01133 
01146     Ecra::ApagaFimDaLinha const apaga_fim_da_linha = Ecra::ApagaFimDaLinha();
01147 
01161     Ecra::ApagaFimDoEcra const apaga_fim_do_ecra = Ecra::ApagaFimDoEcra();
01162 
01171     Ecra::Campainha const campainha = Ecra::Campainha();
01173 
01178     extern string const nomes_das_cores[numero_de_cores];
01179 }
01180 
01181 #include <Slang/ecra_impl.H>
01182 
01183 #endif // SLANG_ECRA_H

Gerado em Mon May 14 17:22:13 2001 para Slang++ por doxygen1.2.6 escrito por Dimitri van Heesch, © 1997-2001