Matrix.cpp

Go to the documentation of this file.

 
 // Inclusione <automatica> dell'header che si sta implementando
#include "Matrix.h"
 
// Implementazione del metodo 'Init' della categoria 'Init'
// Init (1) --> default
bool Matrix::Init()
{
    // Se esiste, dealloco istanza corrente
    if (m_Matrix)
    {
        // Deallocazione
        delete m_Matrix;
 
        //Sanificazione manuale
        m_Matrix = nullptr;
    }
 
    // Assegnazione constexpr agli attributi della classe (valori di default)
    m_CLK = Matrix__file::_CLK;
    m_OE = Matrix__file::_OE;
    m_LAT = Matrix__file::_LAT;
    m_A = Matrix__file::_A;
    m_B = Matrix__file::_B;
    m_C = Matrix__file::_C;
    m_DOUBLE_BUFFERING = Matrix__file::_DOUBLE_BUFFERING;
 
    // Costruzione dell'oggetto di classe "RGBmatrixPanel" con il corrispettivo costruttore parametrico
    m_Matrix = new RGBmatrixPanel(m_A, m_B, m_C, m_CLK, m_LAT, m_OE, m_DOUBLE_BUFFERING);
 
    // Dopo l'allocazione, controllo che effettivamente � andata a buon fine. Un puntatore nullo (i.e. 'nullptr') sarebbe indice di errori durante l'allocazione.
    if (m_Matrix)
        return true;
 
    return false;
}
 
// Implementazione del metodo 'Init' della categoria 'Init'
// Init (2) --> parametrico
bool Matrix::Init(const bool& t_DOUBLE_BUFFERING)
{
    // Se esiste, dealloco istanza corrente
    if (m_Matrix)
    {
        // Deallocazione
        delete m_Matrix;
 
        //Sanificazione manuale
        m_Matrix = nullptr;
    }
 
    // Assegnazione constexpr agli attributi della classe (valori di default)
    m_CLK = Matrix__file::_CLK;
    m_OE = Matrix__file::_OE;
    m_LAT = Matrix__file::_LAT;
    m_A = Matrix__file::_A;
    m_B = Matrix__file::_B;
    m_C = Matrix__file::_C;
 
    // Assegnazione valore del parametro 't_DOUBLE_BUFFERING' all'attributo della classe 'm_DOUBLE_BUFFERING'
    m_DOUBLE_BUFFERING = t_DOUBLE_BUFFERING;
 
    // Costruzione dell'oggetto di classe "RGBmatrixPanel" con il corrispettivo costruttore parametrico
    m_Matrix = new RGBmatrixPanel(m_A, m_B, m_C, m_CLK, m_LAT, m_OE, m_DOUBLE_BUFFERING);
 
    // Dopo l'allocazione, controllo che effettivamente � andata a buon fine. Un puntatore nullo (i.e. 'nullptr') sarebbe indice di errori durante l'allocazione.
    if (m_Matrix)
        return true;
 
    return false;
}
 
// Implementazione del metodo 'Init' della categoria 'Init'
// Init (3) --> parametrico
bool Matrix::Init(const unsigned int& t_A, const unsigned int& t_B, const unsigned int& t_C,
    const unsigned int& t_CLK, const unsigned int& t_LAT, const unsigned int& t_OE,
    const bool& t_DOUBLE_BUFFERING)
{
    // Se esiste, dealloco istanza corrente
    if (m_Matrix)
    {
        // Deallocazione
        delete m_Matrix;
 
        //Sanificazione manuale
        m_Matrix = nullptr;
    }
 
    // Assegnazione valore dei parametri agli attributi della classe
    m_CLK = t_CLK;
    m_OE = t_OE;
    m_LAT = t_LAT;
    m_A = t_A;
    m_B = t_B;
    m_C = t_C;
    m_DOUBLE_BUFFERING = t_DOUBLE_BUFFERING;
 
    // Costruzione dell'oggetto di classe "RGBmatrixPanel" con il corrispettivo costruttore parametrico
    m_Matrix = new RGBmatrixPanel(m_A, m_B, m_C, m_CLK, m_LAT, m_OE, m_DOUBLE_BUFFERING);
 
    // Dopo l'allocazione, controllo che effettivamente � andata a buon fine. Un puntatore nullo (i.e. 'nullptr') sarebbe indice di errori durante l'allocazione.
    if (m_Matrix)
        return true;
 
    return false;
}
 
// Implementazione del metodo 'Begin' della categoria 'Service Management'
bool Matrix::Begin()
{
    // Prima, controllo che l'oggetto di classe "m_Matrix" sia stato già allocato. 
    // Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con conseguente fail della memoria.
    if (m_Matrix)
    {
        // Avvio la matrice con l'utilizzo del metodo 'begin' della classe "RGBmatrixPanel"
        m_Matrix->begin();
 
        // Assegnazione dello stato di avviamento della matrice --> 'true' (da default --> 'false')
        m_isStarted = true;
        
        return true;
    }
    else
        return false;
}
 
// Implementazione del metodo 'get_Matrix' della categoria 'LowLevel getters'
RGBmatrixPanel* const Matrix::get_Matrix()
{
    // Ritorno l'attributo 'm_Matrix' perch� rappresenta gi� un puntatore
    return m_Matrix;
}
 
// Implementazione del metodo 'get_CLK' della categoria 'LowLevel getters'
unsigned int* const Matrix::get_CLK()
{
    // Ritorno l'indirizzo di memoria dell'attributo 'm_CLK'
    // Calcolo dell'indirizzo attraverso utilizzo dell'operatore '&'
    return &m_CLK;
}
 
// Implementazione del metodo 'get_OE' della categoria 'LowLevel getters'
unsigned int* const Matrix::get_OE()
{
    // Ritorno l'indirizzo di memoria dell'attributo 'm_OE'
    // Calcolo dell'indirizzo attraverso utilizzo dell'operatore '&'
    return &m_OE;
}
 
// Implementazione del metodo 'get_LAT' della categoria 'LowLevel getters'
unsigned int* const Matrix::get_LAT()
{
    // Ritorno l'indirizzo di memoria dell'attributo 'm_LAT'
    // Calcolo dell'indirizzo attraverso utilizzo dell'operatore '&'
    return &m_LAT;
}
 
// Implementazione del metodo 'get_A' della categoria 'LowLevel getters'
unsigned int* const Matrix::get_A()
{
    // Ritorno l'indirizzo di memoria dell'attributo 'm_A'
    // Calcolo dell'indirizzo attraverso utilizzo dell'operatore '&'
    return &m_A;
}
 
// Implementazione del metodo 'get_B' della categoria 'LowLevel getters'
unsigned int* const Matrix::get_B()
{
    // Ritorno l'indirizzo di memoria dell'attributo 'm_B'
    // Calcolo dell'indirizzo attraverso utilizzo dell'operatore '&'
    return &m_B;
}
 
// Implementazione del metodo 'get_C' della categoria 'LowLevel getters'
unsigned int* const Matrix::get_C()
{
    // Ritorno l'indirizzo di memoria dell'attributo 'm_C'
    // Calcolo dell'indirizzo attraverso utilizzo dell'operatore '&'
    return &m_C;
}
 
// Implementazione del metodo 'get_DOUBLE_BUFFERING' della categoria 'LowLevel getters'
bool* const Matrix::get_DOUBLE_BUFFERING()
{
    // Ritorno l'indirizzo di memoria dell'attributo 'm_DOUBLE_BUFFERING'
    // Calcolo dell'indirizzo attraverso utilizzo dell'operatore '&'
    return &m_DOUBLE_BUFFERING;
}
 
// Implementazione del metodo 'ReInit' della categoria 'LowLevel reallocator'
bool Matrix::ReInit()
{
    // Se esiste, dealloco istanza corrente
    if (m_Matrix)
    {
        // Deallocazione
        delete m_Matrix;
 
        //Sanificazione manuale
        m_Matrix = nullptr;
    }
 
    // Costruzione dell'oggetto di classe "RGBmatrixPanel" con il corrispettivo costruttore parametrico
    m_Matrix = new RGBmatrixPanel(m_A, m_B, m_C, m_CLK, m_LAT, m_OE, m_DOUBLE_BUFFERING);
 
    // Dopo l'allocazione, controllo che effettivamente � andata a buon fine. Un puntatore nullo (i.e. 'nullptr') sarebbe indice di errori durante l'allocazione.
    if (m_Matrix)
        return true;
 
    return false;
}
 
// Implementazione del metodo 'DefineShades' della categoria 'Risorse Interne'
void Matrix::DefineShades(const Color& t_COLOR, unsigned int& t_RED, unsigned int& t_GREEN, unsigned int& t_BLUE)
{
    // Determino il colore scelto attraverso il campo enumerativo
    switch (t_COLOR)
    {
    case Color::AQUA:
        t_RED = 0;
        t_GREEN = 255;
        t_BLUE = 255;
        break;
 
    case Color::BLACK:
        t_RED = 0;
        t_GREEN = 0;
        t_BLUE = 0;
        break;
 
    case Color::BLUE:
        t_RED = 0;
        t_GREEN = 0;
        t_BLUE = 255;
        break;
 
    case Color::FUCHSIA:
        t_RED = 255;
        t_GREEN = 0;
        t_BLUE = 255;
        break;
 
    case Color::GREEN:
        t_RED = 0;
        t_GREEN = 128;
        t_BLUE = 0;
        break;
 
    case Color::LIME:
        t_RED = 0;
        t_GREEN = 255;
        t_BLUE = 0;
        break;
 
    case Color::NAVY:
        t_RED = 0;
        t_GREEN = 0;
        t_BLUE = 128;
        break;
 
    case Color::PURPLE:
        t_RED = 128;
        t_GREEN = 0;
        t_BLUE = 128;
        break;
 
    case Color::RED:
        t_RED = 255;
        t_GREEN = 0;
        t_BLUE = 0;
        break;
 
    case Color::TEAL:
        t_RED = 0;
        t_GREEN = 128;
        t_BLUE = 128;
        break;
 
    case Color::WHITE:
        t_RED = 255;
        t_GREEN = 255;
        t_BLUE = 255;
        break;
 
    case Color::YELLOW:
        t_RED = 255;
        t_GREEN = 255;
        t_BLUE = 0;
        break;
    }
}
 
// Implementazione del metodo 'from_String_to_Char' della categoria 'Risorse Interne'
char* Matrix::from_String_to_Char(String& t_toConvert)
{
    // Ottengo il contenitore allocato
    char* l_Container = allocate_forConversion(t_toConvert.length() + 1);
 
    // Imposto il contenitore (per la successiva deallocazione)
    set_Container(l_Container);
 
    // Converto con il metodo di Arduino 'toCharArray'
    t_toConvert.toCharArray(l_Container, t_toConvert.length() + 1);
 
    // Ritorno il contenitore contenente la stringa convertita 
    return l_Container;
}
 
// Implementazione del metodo 'allocate_forConversion' della categoria 'Risorse Interne'
char* Matrix::allocate_forConversion(const unsigned int& t_Length)
{
    // Allocazione
    char* l_Container = new char[t_Length];
 
    return l_Container;
}
 
// Implementazione del metodo 'deallocate_forConversion' della categoria 'Risorse Interne'
bool Matrix::deallocate_forConversion(char* t_toDeallocate)
{
    if (!t_toDeallocate)
        return false;
 
    delete[] t_toDeallocate;
    return true;
}
 
// Implementazione del metodo 'set_Container' della categoria 'Risorse Interne'
void Matrix::set_Container(char* t_toSet)
{
    m_Container = t_toSet;
}
 
// Implementazione del metodo 'reset_Container' della categoria 'Risorse Interne'
void Matrix::reset_Container()
{
    m_Container = nullptr;
}
 
// Implementazione del metodo 'Clear' della categoria 'Metodi'
bool Matrix::Clear()
{
    // Effettuo l'operazione attraverso il metodo 'fillScreen' della classe "RGBmatrixPanel"
 
    // Prima, controllo che l'oggetto di classe "m_Matrix" sia stato gi� allocato. 
    // Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con conseguente fail della memoria.
    // Inoltre, in questa implementazione, controllo anche che la matrice sia gi� stata avviata 
    if (m_Matrix && m_isStarted)
    {
        // Nessuna specializzazione del comportamento
        // Effettuo la "pulizia" dello schermo
        m_Matrix->fillScreen(0);
 
        return true;
    }
    else
        return false;
}
 
// Implementazione del metodo 'set_Cursor' della categoria 'Metodi'
bool Matrix::set_Cursor(const int& t_x, const int& t_y)
{
    // Effettuo l'operazione attraverso il metodo 'setCursor' della classe "RGBmatrixPanel'
 
    // Prima, controllo che l'oggetto di classe "m_Matrix" sia stato gi� allocato. 
    // Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con conseguente fail della memoria.
    // Inoltre, in questa implementazione, controllo anche che la matrice sia gi� stata avviata 
    if (m_Matrix && m_isStarted)
    {
        // Nessuna specializzazione del comportamento
        m_Matrix->setCursor(t_x, t_y);
 
        return true;
    }
    else
        return false;
}
 
// Implementazione del metodo 'swapBuffers' della categoria 'Metodi'
bool Matrix::SwapBuffers(const IncrementalModifyBuffer& t_Switch)
{
    // Effettuo l'operazione attraverso il metodo 'swapBuffers' della classe "RGBmatrixPanel'
 
    // Prima, controllo che l'oggetto di classe "m_Matrix" sia stato gi� allocato. 
    // Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con conseguente fail della memoria.
    // Inoltre, in questa implementazione, controllo anche che la matrice sia gi� stata avviata 
    if (m_Matrix && m_isStarted && m_DOUBLE_BUFFERING)
    {
        // Specializzazione --> 'DOUBLE_BUFFERING'
        switch (t_Switch)
        {
        case IncrementalModifyBuffer::ALLOW_INCREMENTAL_MODIFY:
            m_Matrix->swapBuffers((bool)IncrementalModifyBuffer::ALLOW_INCREMENTAL_MODIFY); /*true*/
            break;
 
        case IncrementalModifyBuffer::LOCK_INCREMENTAL_MODIFY:
            m_Matrix->swapBuffers((bool)IncrementalModifyBuffer::LOCK_INCREMENTAL_MODIFY);  /*false*/
            break;
 
        case IncrementalModifyBuffer::INVALID_REFERENCE:
            return false;
            break;
        }
 
        return true;
    }
    else
        return false;
}
 
// Implementazione del metodo 'set_Color' della categoria 'Metodi'
// set_Color (1)
bool Matrix::set_Color(const unsigned int& t_RED, const unsigned int& t_GREEN, const unsigned int& t_BLUE)
{
    // Effettuo l'operazione attraverso il metodo 'setTextColor' della classe "RGBmatrixPanel'
 
    // Prima, controllo che l'oggetto di classe "m_Matrix" sia stato gi� allocato. 
    // Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con conseguente fail della memoria.
    // Inoltre, in questa implementazione, controllo anche che la matrice sia gi� stata avviata 
    if (m_Matrix && m_isStarted)
    {
        // Nessuna specializzazione del comportamento
        m_Matrix->setTextColor(m_Matrix->Color888(t_RED, t_GREEN, t_BLUE));
 
        return true;
    }
    else
        return false;
}
 
// Implementazione del metodo 'set_Color' della categoria 'Metodi'
// set_Color (2)
bool Matrix::set_Color(const Color& t_COLOR)
{
    // Effettuo l'operazione attraverso il metodo 'setTextColor' della classe "RGBmatrixPanel'
 
    // Prima, controllo che l'oggetto di classe "m_Matrix" sia stato gi� allocato. 
    // Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con conseguente fail della memoria.
    // Inoltre, in questa implementazione, controllo anche che la matrice sia gi� stata avviata 
    if (m_Matrix && m_isStarted)
    {
        unsigned int l_RED;
        unsigned int l_GREEN;
        unsigned int l_BLUE;
 
        // Determino il colore scelto attraverso il campo enumerativo
        DefineShades(t_COLOR, l_RED, l_GREEN, l_BLUE);
 
        // Nessuna specializzazione del comportamento
        m_Matrix->setTextColor(m_Matrix->Color888(l_RED, l_GREEN, l_BLUE));
 
        return true;
    }
    else
        return false;
}
 
// Implementazione del metodo 'set_TextSize' della categoria 'Metodi'
bool Matrix::set_TextSize(const unsigned int& t_Size)
{
    // Effettuo l'operazione attraverso il metodo 'setTextSize' della classe "RGBmatrixPanel'
 
    // Prima, controllo che l'oggetto di classe "m_Matrix" sia stato gi� allocato. 
    // Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con conseguente fail della memoria.
    // Inoltre, in questa implementazione, controllo anche che la matrice sia gi� stata avviata 
    if (m_Matrix && m_isStarted)
    {
        // Nessuna specializzazione del comportamento
        m_Matrix->setTextSize(t_Size);
 
        return true;
    }
    else
        return false;
}
 
// Implementazione del metodo 'Show' della categoria 'Metodi'
// Show (1)
bool Matrix::Show(const char* t_toShow)
{
    // Effettuo l'operazione attraverso il metodo 'print' della classe "RGBmatrixPanel'
 
    // Prima, controllo che l'oggetto di classe "m_Matrix" sia stato gi� allocato. 
    // Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con conseguente fail della memoria.
    // Inoltre, in questa implementazione, controllo anche che la matrice sia gi� stata avviata 
    if (m_Matrix && m_isStarted)
    {
        m_Matrix->print(t_toShow);
 
        return true;
    }
    else
        return false;
}
 
// Implementazione del metodo 'Show' della categoria 'Metodi'
// Show (2)
bool Matrix::Show(String& t_toShow)
{
    // Effettuo l'operazione attraverso il metodo 'print' della classe "RGBmatrixPanel'
 
    // Prima, controllo che l'oggetto di classe "m_Matrix" sia stato gi� allocato. 
    // Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con conseguente fail della memoria.
    // Inoltre, in questa implementazione, controllo anche che la matrice sia gi� stata avviata 
    if (m_Matrix && m_isStarted)
    {
        // Conversione
        char* l_convertedString = from_String_to_Char(t_toShow);
 
        m_Matrix->print(l_convertedString);
 
        return true;
    }
    else
        return false;
}
 
// Implementazione del metodo 'SwapBuffersAutomated' della categoria 'Metodi di Automazione'
bool Matrix::SwapBuffersAutomated()
{
    // Effettuo l'operazione attraverso il metodo 'swapBuffers' della classe "RGBmatrixPanel'
 
    // Prima, controllo che l'oggetto di classe "m_Matrix" sia stato gi� allocato. 
    // Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con conseguente fail della memoria.
    // Inoltre, in questa implementazione, controllo anche che la matrice sia gi� stata avviata 
    if (m_Matrix && m_isStarted && m_DOUBLE_BUFFERING)
    {
        // Specializzazione --> 'DOUBLE_BUFFERING'
        m_Matrix->swapBuffers((bool)IncrementalModifyBuffer::LOCK_INCREMENTAL_MODIFY);
 
        // Nonostante lo stato di 'IncrementalModifyBuffer' sia impostato su 'LOCK_INCREMENTAL_MODIFY', è necessaria una "pulizia" "di sicurezza" per 
        // assicurarsi l'eliminazione di eventuali informazioni precedentemente stampato sullo stato di 'IncrementalModifyBuffer::ALLOW_INCREMENTAL_MODIFY'
        Clear();
 
        return true;
    }
    else
        return false;
}
 
// Implementazione del metodo 'ShowAutomated' della categoria 'Metodi di Automazione'
// ShowAutomated (1.1)
bool Matrix::ShowAutomated(const char* t_toShow, const int& t_x, const int& t_y, const unsigned int& t_Size,
    const unsigned int& t_RED, const unsigned int& t_GREEN, const unsigned int& t_BLUE, const IncrementalModifyBuffer& t_Switch /* = IncrementalModifyBuffer::INVALID_REFERENCE */)
{
    // Effettuo l'operazione attraverso il metodo 'print' della classe "RGBmatrixPanel'
 
    // Prima, controllo che l'oggetto di classe "m_Matrix" sia stato gi� allocato. 
    // Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con conseguente fail della memoria.
    // Inoltre, in questa implementazione, controllo anche che la matrice sia gi� stata avviata 
    if (m_Matrix && m_isStarted)
    {
        // Specializzazione
        if (m_DOUBLE_BUFFERING)
        {
            // 'DOUBLE_BUFFERING'
            // Imposto il cursore nella posizione ricevuta dai parametri 't_x', 't_y'
            set_Cursor(t_x, t_y);
 
            // Imposto la dimensione del testo da visualizzare ricevuta dal parametro 't_Size'
            set_TextSize(t_Size);
 
            // Imposto il colore del testo da visualizzare ricevuto dai parametri 't_RED', 't_GREEN', 't_BLUE'
            set_Color(t_RED, t_GREEN, t_BLUE);
 
            // Visualizzo le informazioni sulla matrice ricevute dal parametro 't_toShow'
            Show(t_toShow);
 
            // Per visualizzare effettivamente le informazioni, effettuo lo swap dei buffer
            if (!SwapBuffers(t_Switch)) { return false; }
        }
        else
        {
            // 'SINGLE_BUFFERING'
            // Imposto il cursore nella posizione ricevuta dai parametri 't_x', 't_y'
            set_Cursor(t_x, t_y);
 
            // Imposto la dimensione del testo da visualizzare ricevuta dal parametro 't_Size'
            set_TextSize(t_Size);
 
            // Imposto il colore del testo da visualizzare ricevuto dai parametri 't_RED', 't_GREEN', 't_BLUE'
            set_Color(t_RED, t_GREEN, t_BLUE);
 
            // Visualizzo le informazioni sulla matrice ricevute dal parametro 't_toShow'
            Show(t_toShow);
        }
 
        return true;
    }
    else
        return false;
}
 
// Implementazione del metodo 'ShowAutomated' della categoria 'Metodi di Automazione'
// ShowAutomated (1.2)
bool Matrix::ShowAutomated(const char* t_toShow, const int& t_x, const int& t_y, const unsigned int& t_Size, const Color& t_COLOR,
    const IncrementalModifyBuffer& t_Switch /* = IncrementalModifyBuffer::INVALID_REFERENCE */)
{
    // Effettuo l'operazione attraverso il metodo 'print' della classe "RGBmatrixPanel'
 
    // Prima, controllo che l'oggetto di classe "m_Matrix" sia stato gi� allocato. 
    // Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con conseguente fail della memoria.
    // Inoltre, in questa implementazione, controllo anche che la matrice sia gi� stata avviata 
    if (m_Matrix && m_isStarted)
    {
        // Specializzazione
        if (m_DOUBLE_BUFFERING)
        {
            // 'DOUBLE_BUFFERING'
            // Imposto il cursore nella posizione ricevuta dai parametri 't_x', 't_y'
            set_Cursor(t_x, t_y);
 
            // Imposto la dimensione del testo da visualizzare ricevuta dal parametro 't_Size'
            set_TextSize(t_Size);
 
            // Imposto il colore del testo da visualizzare ricevuto dai parametri 't_RED', 't_GREEN', 't_BLUE'
            set_Color(t_COLOR);
 
            // Visualizzo le informazioni sulla matrice ricevute dal parametro 't_toShow'
            Show(t_toShow);
 
            // Per visualizzare effettivamente le informazioni, effettuo lo swap dei buffer
            if (!SwapBuffers(t_Switch)) { return false; }
        }
        else
        {
            // 'SINGLE_BUFFERING'
            // Imposto il cursore nella posizione ricevuta dai parametri 't_x', 't_y'
            set_Cursor(t_x, t_y);
 
            // Imposto la dimensione del testo da visualizzare ricevuta dal parametro 't_Size'
            set_TextSize(t_Size);
 
            // Imposto il colore del testo da visualizzare ricevuto dai parametri 't_RED', 't_GREEN', 't_BLUE'
            set_Color(t_COLOR);
 
            // Visualizzo le informazioni sulla matrice ricevute dal parametro 't_toShow'
            Show(t_toShow);
        }
 
        return true;
    }
    else
        return false;
}
 
// Implementazione del metodo 'ShowAutomated' della categoria 'Metodi di Automazione'
// ShowAutomated (2.1)
bool Matrix::ShowAutomated(String& t_toShow, const int& t_x, const int& t_y, const unsigned int& t_Size,
    const unsigned int& t_RED, const unsigned int& t_GREEN, const unsigned int& t_BLUE, const IncrementalModifyBuffer& t_Switch /* = IncrementalModifyBuffer::INVALID_REFERENCE */)
{
    // Effettuo l'operazione attraverso il metodo 'print' della classe "RGBmatrixPanel'
 
    // Prima, controllo che l'oggetto di classe "m_Matrix" sia stato gi� allocato. 
    // Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con conseguente fail della memoria.
    // Inoltre, in questa implementazione, controllo anche che la matrice sia gi� stata avviata 
    if (m_Matrix && m_isStarted)
    {
        // Specializzazione
        if (m_DOUBLE_BUFFERING)
        {
            // 'DOUBLE_BUFFERING'
            // Imposto il cursore nella posizione ricevuta dai parametri 't_x', 't_y'
            set_Cursor(t_x, t_y);
 
            // Imposto la dimensione del testo da visualizzare ricevuta dal parametro 't_Size'
            set_TextSize(t_Size);
 
            // Imposto il colore del testo da visualizzare ricevuto dai parametri 't_RED', 't_GREEN', 't_BLUE'
            set_Color(t_RED, t_GREEN, t_BLUE);
 
            // Visualizzo le informazioni sulla matrice ricevute dal parametro 't_toShow'
            Show(t_toShow);
 
            // Per via della chiamata all'overload del metodo 'Show' con parametro --> 'String&', effettuo le operazioni di deallocazione
            deallocate_forConversion(m_Container);
            reset_Container();
 
            // Per visualizzare effettivamente le informazioni, effettuo lo swap dei buffer
            if (!SwapBuffers(t_Switch)) { return false; }
        }
        else
        {
            // 'SINGLE_BUFFERING'
            // Imposto il cursore nella posizione ricevuta dai parametri 't_x', 't_y'
            set_Cursor(t_x, t_y);
 
            // Imposto la dimensione del testo da visualizzare ricevuta dal parametro 't_Size'
            set_TextSize(t_Size);
 
            // Imposto il colore del testo da visualizzare ricevuto dai parametri 't_RED', 't_GREEN', 't_BLUE'
            set_Color(t_RED, t_GREEN, t_BLUE);
 
            // Visualizzo le informazioni sulla matrice ricevute dal parametro 't_toShow'
            Show(t_toShow);
 
            // Per via della chiamata all'overload del metodo 'Show' con parametro --> 'String&', effettuo le operazioni di deallocazione
            deallocate_forConversion(m_Container);
            reset_Container();
        }
 
        return true;
    }
    else
        return false;
}
 
// Implementazione del metodo 'ShowAutomated' della categoria 'Metodi di Automazione'
// ShowAutomated (2.2)
bool Matrix::ShowAutomated(String& t_toShow, const int& t_x, const int& t_y, const unsigned int& t_Size, const Color& t_COLOR,
    const IncrementalModifyBuffer& t_Switch /* = IncrementalModifyBuffer::INVALID_REFERENCE */)
{
    // Effettuo l'operazione attraverso il metodo 'print' della classe "RGBmatrixPanel'
 
    // Prima, controllo che l'oggetto di classe "m_Matrix" sia stato gi� allocato. 
    // Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con conseguente fail della memoria.
    // Inoltre, in questa implementazione, controllo anche che la matrice sia gi� stata avviata 
    if (m_Matrix && m_isStarted)
    {
        // Specializzazione
        if (m_DOUBLE_BUFFERING)
        {
            // 'DOUBLE_BUFFERING'
            // Imposto il cursore nella posizione ricevuta dai parametri 't_x', 't_y'
            set_Cursor(t_x, t_y);
 
            // Imposto la dimensione del testo da visualizzare ricevuta dal parametro 't_Size'
            set_TextSize(t_Size);
 
            // Imposto il colore del testo da visualizzare ricevuto dai parametri 't_RED', 't_GREEN', 't_BLUE'
            set_Color(t_COLOR);
 
            // Visualizzo le informazioni sulla matrice ricevute dal parametro 't_toShow'
            Show(t_toShow);
 
            // Per via della chiamata all'overload del metodo 'Show' con parametro --> 'String&', effettuo le operazioni di deallocazione
            deallocate_forConversion(m_Container);
            reset_Container();
 
            // Per visualizzare effettivamente le informazioni, effettuo lo swap dei buffer
            if (!SwapBuffers(t_Switch)) { return false; }
        }
        else
        {
            // 'SINGLE_BUFFERING'
            // Imposto il cursore nella posizione ricevuta dai parametri 't_x', 't_y'
            set_Cursor(t_x, t_y);
 
            // Imposto la dimensione del testo da visualizzare ricevuta dal parametro 't_Size'
            set_TextSize(t_Size);
 
            // Imposto il colore del testo da visualizzare ricevuto dai parametri 't_RED', 't_GREEN', 't_BLUE'
            set_Color(t_COLOR);
 
            // Visualizzo le informazioni sulla matrice ricevute dal parametro 't_toShow'
            Show(t_toShow);
 
            // Per via della chiamata all'overload del metodo 'Show' con parametro --> 'String&', effettuo le operazioni di deallocazione
            deallocate_forConversion(m_Container);
            reset_Container();
        }
 
        return true;
    }
    else
        return false;
}
 
// Implementazione del metodo 'ClearShowAutomated' della categoria 'Metodi di Automazione'
// ClearShowAutomated (1.1)
bool Matrix::ClearShowAutomated(const char* t_toShow, const int& t_x, const int& t_y, const unsigned int& t_Size,
    const unsigned int& t_RED, const unsigned int& t_GREEN, const unsigned int& t_BLUE, const IncrementalModifyBuffer& t_Switch /* = IncrementalModifyBuffer::INVALID_REFERENCE */)
{
    // Effettuo l'operazione attraverso il metodo 'print' della classe "RGBmatrixPanel'
 
    // Prima, controllo che l'oggetto di classe "m_Matrix" sia stato gi� allocato. 
    // Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con conseguente fail della memoria.        
    // Inoltre, in questa implementazione, controllo anche che la matrice sia gi� stata avviata 
    if (m_Matrix && m_isStarted)
    {
        // Specializzazione
        if (m_DOUBLE_BUFFERING)
        {
            // 'DOUBLE_BUFFERING'
            // "Pulisco" il 'back-buffer'
            Clear();
 
            // Imposto il cursore nella posizione ricevuta dai parametri 't_x', 't_y'
            set_Cursor(t_x, t_y);
 
            // Imposto la dimensione del testo da visualizzare ricevuta dal parametro 't_Size'
            set_TextSize(t_Size);
 
            // Imposto il colore del testo da visualizzare ricevuto dai parametri 't_RED', 't_GREEN', 't_BLUE'
            set_Color(t_RED, t_GREEN, t_BLUE);
 
            // Visualizzo le informazioni sulla matrice ricevute dal parametro 't_toShow'
            Show(t_toShow);
 
            // Per visualizzare effettivamente le informazioni, effettuo lo swap dei buffer
            if (!SwapBuffers(t_Switch)) { return false; }
        }
        else
        {
            // 'SINGLE_BUFFERING'
            // "Pulisco" lo schermo / buffer
            Clear();
 
            // Imposto il cursore nella posizione ricevuta dai parametri 't_x', 't_y'
            set_Cursor(t_x, t_y);
 
            // Imposto la dimensione del testo da visualizzare ricevuta dal parametro 't_Size'
            set_TextSize(t_Size);
 
            // Imposto il colore del testo da visualizzare ricevuto dai parametri 't_RED', 't_GREEN', 't_BLUE'
            set_Color(t_RED, t_GREEN, t_BLUE);
 
            // Visualizzo le informazioni sulla matrice ricevute dal parametro 't_toShow'
            Show(t_toShow);
        }
 
        return true;
    }
    else
        return false;
}
 
// Implementazione del metodo 'ClearShowAutomated' della categoria 'Metodi di Automazione'
// ClearShowAutomated (1.2)
bool Matrix::ClearShowAutomated(const char* t_toShow, const int& t_x, const int& t_y, const unsigned int& t_Size, const Color& t_COLOR,
    const IncrementalModifyBuffer& t_Switch /* = IncrementalModifyBuffer::INVALID_REFERENCE */)
{
    // Effettuo l'operazione attraverso il metodo 'print' della classe "RGBmatrixPanel'
 
    // Prima, controllo che l'oggetto di classe "m_Matrix" sia stato gi� allocato. 
    // Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con conseguente fail della memoria.        
    // Inoltre, in questa implementazione, controllo anche che la matrice sia gi� stata avviata 
    if (m_Matrix && m_isStarted)
    {
        // Specializzazione
        if (m_DOUBLE_BUFFERING)
        {
            // 'DOUBLE_BUFFERING'
            // "Pulisco" il 'back-buffer'
            Clear();
 
            // Imposto il cursore nella posizione ricevuta dai parametri 't_x', 't_y'
            set_Cursor(t_x, t_y);
 
            // Imposto la dimensione del testo da visualizzare ricevuta dal parametro 't_Size'
            set_TextSize(t_Size);
 
            // Imposto il colore del testo da visualizzare ricevuto dai parametri 't_RED', 't_GREEN', 't_BLUE'
            set_Color(t_COLOR);
 
            // Visualizzo le informazioni sulla matrice ricevute dal parametro 't_toShow'
            Show(t_toShow);
 
            // Per visualizzare effettivamente le informazioni, effettuo lo swap dei buffer
            if (!SwapBuffers(t_Switch)) { return false; }
        }
        else
        {
            // 'SINGLE_BUFFERING'
            // "Pulisco" lo schermo / buffer
            Clear();
 
            // Imposto il cursore nella posizione ricevuta dai parametri 't_x', 't_y'
            set_Cursor(t_x, t_y);
 
            // Imposto la dimensione del testo da visualizzare ricevuta dal parametro 't_Size'
            set_TextSize(t_Size);
 
            // Imposto il colore del testo da visualizzare ricevuto dai parametri 't_RED', 't_GREEN', 't_BLUE'
            set_Color(t_COLOR);
 
            // Visualizzo le informazioni sulla matrice ricevute dal parametro 't_toShow'
            Show(t_toShow);
        }
 
        return true;
    }
    else
        return false;
}
 
// Implementazione del metodo 'ClearShowAutomated' della categoria 'Metodi di Automazione'
// ClearShowAutomated (2.1)
bool Matrix::ClearShowAutomated(String& t_toShow, const int& t_x, const int& t_y, const unsigned int& t_Size,
    const unsigned int& t_RED, const unsigned int& t_GREEN, const unsigned int& t_BLUE, const IncrementalModifyBuffer& t_Switch /* = IncrementalModifyBuffer::INVALID_REFERENCE */)
{
    // Effettuo l'operazione attraverso il metodo 'print' della classe "RGBmatrixPanel'
 
    // Prima, controllo che l'oggetto di classe "m_Matrix" sia stato gi� allocato. 
    // Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con conseguente fail della memoria.        
    // Inoltre, in questa implementazione, controllo anche che la matrice sia gi� stata avviata 
    if (m_Matrix && m_isStarted)
    {
        // Specializzazione
        if (m_DOUBLE_BUFFERING)
        {
            // 'DOUBLE_BUFFERING'
            // "Pulisco" il 'back-buffer'
            Clear();
 
            // Imposto il cursore nella posizione ricevuta dai parametri 't_x', 't_y'
            set_Cursor(t_x, t_y);
 
            // Imposto la dimensione del testo da visualizzare ricevuta dal parametro 't_Size'
            set_TextSize(t_Size);
 
            // Imposto il colore del testo da visualizzare ricevuto dai parametri 't_RED', 't_GREEN', 't_BLUE'
            set_Color(t_RED, t_GREEN, t_BLUE);
 
            // Visualizzo le informazioni sulla matrice ricevute dal parametro 't_toShow'
            Show(t_toShow);
 
            // Per via della chiamata all'overload del metodo 'Show' con parametro --> 'String&', effettuo le operazioni di deallocazione
            deallocate_forConversion(m_Container);
            reset_Container();
 
            // Per visualizzare effettivamente le informazioni, effettuo lo swap dei buffer
            if (!SwapBuffers(t_Switch)) { return false; }
        }
        else
        {
            // 'SINGLE_BUFFERING'
            // "Pulisco" lo schermo / buffer
            Clear();
 
            // Imposto il cursore nella posizione ricevuta dai parametri 't_x', 't_y'
            set_Cursor(t_x, t_y);
 
            // Imposto la dimensione del testo da visualizzare ricevuta dal parametro 't_Size'
            set_TextSize(t_Size);
 
            // Imposto il colore del testo da visualizzare ricevuto dai parametri 't_RED', 't_GREEN', 't_BLUE'
            set_Color(t_RED, t_GREEN, t_BLUE);
 
            // Visualizzo le informazioni sulla matrice ricevute dal parametro 't_toShow'
            Show(t_toShow);
 
            // Per via della chiamata all'overload del metodo 'Show' con parametro --> 'String&', effettuo le operazioni di deallocazione
            deallocate_forConversion(m_Container);
            reset_Container();
        }
 
        return true;
    }
    else
        return false;
}
 
// Implementazione del metodo 'ClearShowAutomated' della categoria 'Metodi di Automazione'
// ClearShowAutomated (2.2)
bool Matrix::ClearShowAutomated(String& t_toShow, const int& t_x, const int& t_y, const unsigned int& t_Size, const Color& t_COLOR,
    const IncrementalModifyBuffer& t_Switch /* = IncrementalModifyBuffer::INVALID_REFERENCE */)
{
    // Effettuo l'operazione attraverso il metodo 'print' della classe "RGBmatrixPanel'
 
    // Prima, controllo che l'oggetto di classe "m_Matrix" sia stato gi� allocato. 
    // Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con conseguente fail della memoria.        
    // Inoltre, in questa implementazione, controllo anche che la matrice sia gi� stata avviata 
    if (m_Matrix && m_isStarted)
    {
        // Specializzazione
        if (m_DOUBLE_BUFFERING)
        {
            // 'DOUBLE_BUFFERING'
            // "Pulisco" il 'back-buffer'
            Clear();
 
            // Imposto il cursore nella posizione ricevuta dai parametri 't_x', 't_y'
            set_Cursor(t_x, t_y);
 
            // Imposto la dimensione del testo da visualizzare ricevuta dal parametro 't_Size'
            set_TextSize(t_Size);
 
            // Imposto il colore del testo da visualizzare ricevuto dai parametri 't_RED', 't_GREEN', 't_BLUE'
            set_Color(t_COLOR);
 
            // Visualizzo le informazioni sulla matrice ricevute dal parametro 't_toShow'
            Show(t_toShow);
 
            // Per via della chiamata all'overload del metodo 'Show' con parametro --> 'String&', effettuo le operazioni di deallocazione
            deallocate_forConversion(m_Container);
            reset_Container();
 
            // Per visualizzare effettivamente le informazioni, effettuo lo swap dei buffer
            if (!SwapBuffers(t_Switch)) { return false; }
        }
        else
        {
            // 'SINGLE_BUFFERING'
            // "Pulisco" lo schermo / buffer
            Clear();
 
            // Imposto il cursore nella posizione ricevuta dai parametri 't_x', 't_y'
            set_Cursor(t_x, t_y);
 
            // Imposto la dimensione del testo da visualizzare ricevuta dal parametro 't_Size'
            set_TextSize(t_Size);
 
            // Imposto il colore del testo da visualizzare ricevuto dai parametri 't_RED', 't_GREEN', 't_BLUE'
            set_Color(t_COLOR);
 
            // Visualizzo le informazioni sulla matrice ricevute dal parametro 't_toShow'
            Show(t_toShow);
 
            // Per via della chiamata all'overload del metodo 'Show' con parametro --> 'String&', effettuo le operazioni di deallocazione
            deallocate_forConversion(m_Container);
            reset_Container();
        }
 
        return true;
    }
    else
        return false;
}
 
// Implementazione del metodo 'ShowBitmap' della categoria 'Metodi di Automazione'
// ShowBitmap (1)
bool Matrix::ShowBitmap(const unsigned char* t_toShow, const int& t_x, const int& t_y, const unsigned int& t_RED, const unsigned int& t_GREEN, const unsigned int& t_BLUE,
    const IncrementalModifyBuffer& t_Switch /* = IncrementalModifyBuffer::INVALID_REFERENCE */, const unsigned int& t_w /* = Matrix__file::_w */, const unsigned int& t_h /* = Matrix__file::_h */)
{
    // Effettuo l'operazione attraverso il metodo 'print' della classe "RGBmatrixPanel'
 
    // Prima, controllo che l'oggetto di classe "m_Matrix" sia stato gi� allocato. 
    // Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con conseguente fail della memoria.        
    // Inoltre, in questa implementazione, controllo anche che la matrice sia gi� stata avviata 
    if (m_Matrix && m_isStarted)
    {
        // Specializzazione
        if (m_DOUBLE_BUFFERING)
        {
            // 'DOUBLE_BUFFERING'
            // Visualizzo l'immagine bitmap
            m_Matrix->drawBitmap(t_x, t_y, t_toShow, t_w, t_h, m_Matrix->Color888(t_RED, t_GREEN, t_BLUE));
 
            // Per visualizzare effettivamente le informazioni, effettuo lo swap dei buffer
            if (!SwapBuffers(t_Switch)) { return false; }
        }
        else
        {
            // Visualizzo l'immagine bitmap
            m_Matrix->drawBitmap(t_x, t_y, t_toShow, t_w, t_h, m_Matrix->Color888(t_RED, t_GREEN, t_BLUE));
        }
 
        return true;
    }
    else
        return false;
}
 
// Implementazione del metodo 'ShowBitmap' della categoria 'Metodi di Automazione'
// ShowBitmap (2)
bool Matrix::ShowBitmap(const unsigned char* t_toShow, const int& t_x, const int& t_y, const Color& t_COLOR,
    const IncrementalModifyBuffer& t_Switch /* = IncrementalModifyBuffer::INVALID_REFERENCE */, const unsigned int& t_w /* = Matrix__file::_w */, const unsigned int& t_h /* = Matrix__file::_h */)
{
    // Effettuo l'operazione attraverso il metodo 'print' della classe "RGBmatrixPanel'
 
    // Prima, controllo che l'oggetto di classe "m_Matrix" sia stato gi� allocato. 
    // Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con conseguente fail della memoria.        
    // Inoltre, in questa implementazione, controllo anche che la matrice sia gi� stata avviata 
    if (m_Matrix && m_isStarted)
    {
        unsigned int l_RED;
        unsigned int l_GREEN;
        unsigned int l_BLUE;
 
        // Determino il colore scelto attraverso il campo enumerativo
        DefineShades(t_COLOR, l_RED, l_GREEN, l_BLUE);
 
        // Specializzazione
        if (m_DOUBLE_BUFFERING)
        {
            // 'DOUBLE_BUFFERING'
            // Visualizzo l'immagine bitmap
            m_Matrix->drawBitmap(t_x, t_y, t_toShow, t_w, t_h, m_Matrix->Color888(l_RED, l_GREEN, l_BLUE));
 
            // Per visualizzare effettivamente le informazioni, effettuo lo swap dei buffer
            if (!SwapBuffers(t_Switch)) { return false; }
        }
        else
        {
            // Visualizzo l'immagine bitmap
            m_Matrix->drawBitmap(t_x, t_y, t_toShow, t_w, t_h, m_Matrix->Color888(l_RED, l_GREEN, l_BLUE));
        }
 
        return true;
    }
    else
        return false;
}
 
// Implementazione del metodo 'ClearShowBitmap' della categoria 'Metodi di Automazione'
// ClearShowBitmap (1)
bool Matrix::ClearShowBitmap(const unsigned char* t_toShow, const int& t_x, const int& t_y, const unsigned int& t_RED, const unsigned int& t_GREEN, const unsigned int& t_BLUE,
    const IncrementalModifyBuffer& t_Switch /* = IncrementalModifyBuffer::INVALID_REFERENCE */, const unsigned int& t_w /* = Matrix__file::_w */, const unsigned int& t_h /* = Matrix__file::_h */)
{
    // Effettuo l'operazione attraverso il metodo 'print' della classe "RGBmatrixPanel'
 
    // Prima, controllo che l'oggetto di classe "m_Matrix" sia stato gi� allocato. 
    // Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con conseguente fail della memoria.        
    // Inoltre, in questa implementazione, controllo anche che la matrice sia gi� stata avviata 
    if (m_Matrix && m_isStarted)
    {
        // Specializzazione
        if (m_DOUBLE_BUFFERING)
        {
            // 'DOUBLE_BUFFERING'
            // "Pulisco" il 'back-buffer'
            Clear();
 
            // Visualizzo l'immagine bitmap
            m_Matrix->drawBitmap(t_x, t_y, t_toShow, t_w, t_h, m_Matrix->Color888(t_RED, t_GREEN, t_BLUE));
 
            // Per visualizzare effettivamente le informazioni, effettuo lo swap dei buffer
            if (!SwapBuffers(t_Switch)) { return false; }
        }
        else
        {
            // 'SINGLE_BUFFERING'
            // "Pulisco" lo schermo / buffer
            Clear();
 
            // Visualizzo l'immagine bitmap
            m_Matrix->drawBitmap(t_x, t_y, t_toShow, t_w, t_h, m_Matrix->Color888(t_RED, t_GREEN, t_BLUE));
        }
 
        return true;
    }
    else
        return false;
}
 
// Implementazione del metodo 'ClearShowBitmap' della categoria 'Metodi di Automazione'
// ClearShowBitmap (2)
bool Matrix::ClearShowBitmap(const unsigned char* t_toShow, const int& t_x, const int& t_y, const Color& t_COLOR,
    const IncrementalModifyBuffer& t_Switch /* = IncrementalModifyBuffer::INVALID_REFERENCE */, const unsigned int& t_w /* = Matrix__file::_w */, const unsigned int& t_h /* = Matrix__file::_h */)
{
    // Effettuo l'operazione attraverso il metodo 'print' della classe "RGBmatrixPanel'
 
    // Prima, controllo che l'oggetto di classe "m_Matrix" sia stato gi� allocato. 
    // Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con conseguente fail della memoria.        
    // Inoltre, in questa implementazione, controllo anche che la matrice sia gi� stata avviata 
    if (m_Matrix && m_isStarted)
    {
        unsigned int l_RED;
        unsigned int l_GREEN;
        unsigned int l_BLUE;
 
        // Determino il colore scelto attraverso il campo enumerativo
        DefineShades(t_COLOR, l_RED, l_GREEN, l_BLUE);
 
        // Specializzazione
        if (m_DOUBLE_BUFFERING)
        {
            // 'DOUBLE_BUFFERING'
            // "Pulisco" il 'back-buffer'
            Clear();
 
            // Visualizzo l'immagine bitmap
            m_Matrix->drawBitmap(t_x, t_y, t_toShow, t_w, t_h, m_Matrix->Color888(l_RED, l_GREEN, l_BLUE));
 
            // Per visualizzare effettivamente le informazioni, effettuo lo swap dei buffer
            if (!SwapBuffers(t_Switch)) { return false; }
        }
        else
        {
            // 'SINGLE_BUFFERING'
            // "Pulisco" lo schermo / buffer
            Clear();
 
            // Visualizzo l'immagine bitmap
            m_Matrix->drawBitmap(t_x, t_y, t_toShow, t_w, t_h, m_Matrix->Color888(l_RED, l_GREEN, l_BLUE));
        }
 
        return true;
    }
    else
        return false;
}
 
// Implementazione del metodo 'ShowLogo_GBE' della categoria 'Metodi di Automazione'
bool Matrix::ShowLogo_GBE()
{
    // Prima, controllo che l'oggetto di classe "m_Matrix" sia stato gi� allocato. 
    // Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con conseguente fail della memoria.        
    // Inoltre, in questa implementazione, controllo anche che la matrice sia gi� stata avviata 
    if (m_Matrix && m_isStarted)
    {
        // Visualizzo il logo come modifica incrementale di immagini bitmap
        ClearShowBitmap(G_bitmap, 0, 0, Matrix::Color::RED, Matrix::IncrementalModifyBuffer::ALLOW_INCREMENTAL_MODIFY);
        ShowBitmap(B_bitmap, 0, 0, Matrix::Color::GREEN, Matrix::IncrementalModifyBuffer::ALLOW_INCREMENTAL_MODIFY);
        ShowBitmap(E_bitmap, 0, 0, Matrix::Color::BLUE, Matrix::IncrementalModifyBuffer::LOCK_INCREMENTAL_MODIFY);
 
        return true;
    }
    else
        return false;
}
 
// Implementazione del metodo 'ShowLogo_WiFi' della categoria 'Metodi di Automazione'
bool Matrix::ShowLogo_WiFi()
{
    // Prima, controllo che l'oggetto di classe "m_Matrix" sia stato gi� allocato. 
    // Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con conseguente fail della memoria.        
    // Inoltre, in questa implementazione, controllo anche che la matrice sia gi� stata avviata 
    if (m_Matrix && m_isStarted)
    {
        // Visualizzo il logo
        ClearShowBitmap(wifi_bitmap, 0, 0, Matrix::Color::WHITE, Matrix::IncrementalModifyBuffer::LOCK_INCREMENTAL_MODIFY);
 
        return true;
    }
    else
        return false;
}
 
// Implementazione del metodo 'ShowLogo_CrossedWiFi' della categoria 'Metodi di Automazione'
bool Matrix::ShowLogo_CrossedWiFi()
{
    // Prima, controllo che l'oggetto di classe "m_Matrix" sia stato gi� allocato. 
    // Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con conseguente fail della memoria.        
    // Inoltre, in questa implementazione, controllo anche che la matrice sia gi� stata avviata 
    if (m_Matrix && m_isStarted)
    {
        // Visualizzo il logo come modifica incrementale di immagini bitmap
        ClearShowBitmap(wifi_bitmap, 0, 0, Matrix::Color::WHITE, Matrix::IncrementalModifyBuffer::ALLOW_INCREMENTAL_MODIFY);
        ShowBitmap(cross_bitmap, 0, 0, Matrix::Color::RED, Matrix::IncrementalModifyBuffer::LOCK_INCREMENTAL_MODIFY);
        
        return true;
    }
    else
        return false;
}