TerminalGui.cpp

Go to the documentation of this file.

#include "TerminalGui.h"
#include "Connessione.h"
#include <wx/font.h>

// La Event Table serve per mappare i vari eventi che devono essere gestiti
// dalla classe con dei suoi metodi.
// Event Table - Inizio
BEGIN_EVENT_TABLE(TerminalGui,CHILD_FRAME)
    // L'evento si verifica quando viene premuto invio nella commandline.
    EVT_TEXT_ENTER(COMMAND_LINE,TerminalGui::EnterCommand)
    // L'evento si verifica quando viene chiuso il terminale
    // (premendo il pulsante nella finestra).
        EVT_CLOSE(TerminalGui::TerminalGuiClose)
END_EVENT_TABLE()
// Event Table - Fine

TerminalGui::TerminalGui(Connessione* connection, PARENT_FRAME* parent,
                         wxWindowID id, const wxString& title,
                         const wxPoint& position, const wxSize& size,
                         long style, const wxString& name)
                         : CHILD_FRAME(parent, id, title, position,
                         size, style, name), connessione(connection)
{ 
    CreateGUIControls();  // Il metodo crea i componenti grafici del terminale.
}

TerminalGui::~TerminalGui()
{
    StoreFrameSize(GetRect());  // Salva dimensioni e posizione della finestra
}

void TerminalGui::CreateGUIControls()
{
    #ifdef _WIN32
    this->SetIcon(wxICON(B));  // Carica l'icona su Win32
    #else
    #include "res/Terminals.xpm"
    SetIcon( wxIcon(Terminals_xpm) );
    #endif
    // Inizializza il TextCtrl principale dove vengono stampati i messaggi
    // mandati dal parser (per la descrizione dei parametri passati al
    // costruttore si rimanda alla documentazione delle wxWidgets).
    viewer = new wxTextCtrl(this, VIEWER, _(""), wxPoint(0,0),
                            wxSize(TERMINALWIDTH, TERMINALHEIGHT-20),
                            wxTE_MULTILINE|wxTE_READONLY|wxTE_RICH);
    // Inizializza la linea di comando dove l'utente digita i messaggi
    // da inviare al terminale.Premendo Invio verra generato un
    // EVT_TEXT_ENTER che sara' gestito dall'APP.
    commandline = new wxTextCtrl(this, COMMAND_LINE, _(""),
                                 wxPoint(0, TERMINALHEIGHT-20),
                                 wxSize(TERMINALWIDTH, 20), wxTE_PROCESS_ENTER);
    USE_FONT;  // Definito in Definitions.h
    viewer->SetFont(FONT);  // Assegna il font FONT ai Componenti del terminale
    commandline->SetFont(FONT);
}

void TerminalGui::SetLayout()
{
    // Vengono usati i Sizer per costruire il Layout della finestra.

    wxBoxSizer *columnsizer = new wxBoxSizer(wxVERTICAL); // Sizer delle colonne
  
    columnsizer->Add(viewer, 1, wxEXPAND);  // Aggiunge il viewer al sizer e li
                                            // rende ridimensionabili.
    columnsizer->Add(commandline, 0, wxEXPAND);  // Aggiunge la commandline al
                                                 // sizer e la rende ad altezza
                                                 // fissa e larghezza variabile

    SetAutoLayout(TRUE);
    SetSizer(columnsizer);

    columnsizer->Fit(this);
    columnsizer->SetSizeHints(this);
}

void TerminalGui::receiveMsg(wxString message, wxTextAttr style)
{
            viewer->SetDefaultStyle(style); // Assegna al messaggio lo stile passato
                                        // come parametro
        viewer->AppendText(message);  // Aggiunge al viewer il messaggio
        viewer->SetDefaultStyle(STYLE_DEFAULT); // Ripristina lo stile di Default

}    

void TerminalGui::TerminalGuiClose(wxCloseEvent& event)
{
    // Richiama un metodo di connessione che si occupa di distruggere
    // il terminale e di aggiornare al sua lista interna di Terminali Aperti.
    connessione->DeleteTerminal(GetName());
}       

void TerminalGui::EnterCommand(wxCommandEvent& event)
{
    wxString cmd = commandline->GetValue();  // Comando inserito
    if(cmd.Len() < 1)  // Evita di mandare al parser stringhe nulle
        return;
    if(cmd.GetChar(0) != '/' ){  // Se la stringa digitata non e' un comando
                                 // (che inizia con / ) allora scrive il
                                 // messaggio sul viewer (i comandi infatti non
                                 // appaiono sul terminale).
        viewer->SetDefaultStyle(STYLE_ITALIC);
        *viewer << "<" + connessione->GetMyNick() + "> ";
        viewer->SetDefaultStyle(STYLE_DEFAULT);
        *viewer << cmd;
        *viewer << _("\n");
    }
    // Invia la stringa al parserOut che si occupera' di inviarla al server
    // (parsandola nel caso sia un comando)
    connessione->getParserOut()->sendMessage(cmd,GetName());
    commandline->Clear();  // Pulisce la commandline
}

// Salva le impostazioni grafiche della finestra

unsigned int TerminalGui::offset = 0;  // L'offset di creazione delle finestre
                                       // viene inizializzato a zero

wxRect TerminalGui::DetermineFrameSize(wxConfig* config)
{
    const int minFrameWidth = TERMINALWIDTH;  // Imposta le dimensioni minime
                                              // del Terminale
    const int minFrameHeight = TERMINALHEIGHT;
    wxSize scr = wxGetDisplaySize();  // Cattura la dimensione del Display

    wxRect rect;
    wxConfig* cfg = config;
    if (!config) cfg = new wxConfig(_("Quirck"));  // Apre (o crea) un file di
                                                   // configurazione
    wxString key = T_LOCATION;  // Chiave radice delle impostazioni
    if (cfg->Exists(key)){  // Se la chiave esiste gia' legge
                            // le impostazioni salvate
        rect.x = cfg->Read(key + _("/") + T_LOCATION_X, rect.x) + offset;
        rect.y = cfg->Read(key + _("/") + T_LOCATION_Y, rect.y) + offset;
        rect.width = cfg->Read(key + _("/") + T_LOCATION_W, rect.width);
        rect.height = cfg->Read(key + _("/") + T_LOCATION_H, rect.height);
    }
    
    if (!config) delete cfg;

    // Controlla che i valori caricati siano coerenti con le dimensioni dello
    // schermo altrimenti usa impostazioni piu' adatte.
    rect.x = wxMin(abs(rect.x), (scr.x - minFrameWidth));
    rect.y = wxMin(abs(rect.y), (scr.y - minFrameHeight));
    rect.width = wxMax(abs(rect.width), (minFrameWidth));
    rect.width = wxMin(abs(rect.width), (scr.x - rect.x));
    rect.height = wxMax(abs(rect.height), (minFrameHeight));
    rect.height = wxMin(abs(rect.height), (scr.y - rect.y));
    
    offset += 15;  // Viene incrementato l'offset di creazione delle finestre

    return rect;
}

void TerminalGui::StoreFrameSize(wxRect rect, wxConfig* config)
{
    wxConfig* cfg = config;
    if (!config) cfg = new wxConfig(_("Quirck"));  // Apre (o crea) un file di
                                                   // configurazione
    wxString key = T_LOCATION; // Scrive nel file le impostazioni della finestra.
    cfg->Write(key + _("/") + T_LOCATION_X, rect.x);
    cfg->Write(key + _("/") + T_LOCATION_Y, rect.y);
    cfg->Write(key + _("/") + T_LOCATION_W, rect.width);
    cfg->Write(key + _("/") + T_LOCATION_H, rect.height);
    if (!config) delete cfg;
}

---