GUIMainWindow.cpp

Idź do dokumentacji tego pliku.

#include <QDateTime>
#include <QLabel>
#include <QMessageBox> 
#include <QDialog>
#include <QFileDialog> 

#include "GUIMainWindow.h"
#include "exeptions.h"

GUIMainWindow::GUIMainWindow (QWidget * parent = 0, Qt::WFlags flags = 0) : QWidget (parent)
{
        QTextCodec::setCodecForCStrings( QTextCodec::codecForName("Windows-1250") );
        QTextCodec::setCodecForTr( QTextCodec::codecForName("Windows-1250"));

        is_connect = false;
        Settings = new GUISettings(this);

        if(Settings->getOpacityEnabled())
        {
                this->setAutoFillBackground(false);
                this->setAttribute(Qt::WA_NoSystemBackground, false);
                this->setWindowOpacity(Settings->getOpacity());
        }
//*******************  Boxs **************************  
        QVBoxLayout *vbox = new QVBoxLayout;
        vbox->setSpacing(0);
        QVBoxLayout *vboxul = new QVBoxLayout;
        vboxul->setSpacing(0);
        QHBoxLayout *hbox = new QHBoxLayout; 
        QVBoxLayout *main = new QVBoxLayout;
        main->setMargin(1);
//******************  GUI elements *******************
        TextToolBar = new QToolBar("Format", this);
        TextToolBar->setMaximumHeight(32);

        ChatTextInput = new GUIChatTextInput(this, TextToolBar,Settings->getFontColor());
        ChatTextInput->setMaximumHeight(100);
        ChatTextInput->setEnabled(false);

        TabList = new GUITabList(this, Settings->getBroadcast(), Settings->getFontColorSystemMsg().name(),

        Settings->getFontColorSystemUserMsg().name(), Settings->getBackgroundColor().name());

        TabList->publicChat()->chat->printSysMsg(tr("Witamy w programie lanChat"));
        TabList->publicChat()->chat->printSysMsg(tr("Wciœnij połšcz aby rozpoczšć rozmowę"));

        UserList = new GuiActiveUserList(this);
        UserList->setMaximumWidth(150);
        UserList->setEnabled(false);

        this->setApperance();
        connect(Settings, SIGNAL(settingsChanged()),this,SLOT(setApperance()));

        MainToolBar = new QToolBar("Podstawowy", this);
        MainToolBar->setMaximumHeight(32);

        createMainToolBar(MainToolBar);

        MainToolBar->setFocus();

        vbox->addWidget(TabList);
        vbox->addWidget(TextToolBar);
        vbox->addWidget(ChatTextInput);
        vboxul->addSpacing(22);
        vboxul->addWidget(UserList);
        hbox->addLayout(vbox);
        hbox->addLayout(vboxul);

        main->addWidget(MainToolBar);
        main->addLayout(hbox);

        setLayout(main);
        this->setWindowTitle("AvaLANche Chat =)");
        this->setWindowIcon(QIcon("icon/Chat/chat.png"));
        TextToolBar->setEnabled(false);

        //rozpoczecie prywatnej rozmowy, tylko otwarcie zakladki,
        connect (UserList, SIGNAL(signalPrivateChat(QHostAddress &)),this,SLOT(privateChat (QHostAddress &)));

        //odbieranie pliku od kogos tam:
        connect (&comm, SIGNAL(fileRequest (QHostAddress , QString , quint32 )), this, SLOT(incomingFile(QHostAddress , QString , quint32 )));

        //wysylanie pliku do usera
        connect (UserList, SIGNAL(signalSendFile(QHostAddress &)),this,SLOT(sendFile (QHostAddress &)));

        //Użytkownik po drugiej stronie zakceptowal przyjecie pliku
        connect (&comm, SIGNAL(acceptSendFile (QHostAddress, QString)), this, SLOT(acceptSendFile (QHostAddress, QString)));

        //Użytkownik po drugiej stronie odmuwil przyjecie pliku
        connect (&comm, SIGNAL(refuseSendFile (QHostAddress , QString)), this, SLOT(refuseSendFile (QHostAddress, QString )));

        //transfer pliku zakoaczył sie
        connect (&comm, SIGNAL(transferEnd (QHostAddress, bool)), this, SLOT(transferEnd (QHostAddress, bool)));

        //laczymy transfer plikow z sygnalem
        connect (&comm, SIGNAL(fileProgress (int)), this, SLOT(fileProgress (int)));

        //anulowanie odbierania pliku przez usera
        connect(&incoming_file_window, SIGNAL(signalCancelFileDownload()), this, SLOT(cancelFileTransfer()));

        //anulowanie wysylanie pliku przez usera
        connect(&outcomming_file_window, SIGNAL(signalCancelFileUpload()), this, SLOT(cancelFileTransfer()));

        //wysylanie sprawdzam ip usera
        connect (UserList, SIGNAL(signalCheckIp (QHostAddress &)),this,SLOT(checkIp (QHostAddress &)));

        //wysylanie sprawdzam pinga do usera
        connect (UserList, SIGNAL(signalCheckPing (QHostAddress &)),this,SLOT(checkPing (QHostAddress &)));

        //wysylanie wiadomosci wpisanej przez usera
        connect (ChatTextInput, SIGNAL(sendRequest ()),this,SLOT(sendMsg()));

        //rozlaczenie programu Użytkownik o takej nazwie juz istnieje,
        connect (UserList, SIGNAL(disconectChatUserExists()),this,SLOT(disconnectChat()));

        connect (&comm, SIGNAL(newUser(QHostAddress, QString)), this->UserList, SLOT(addUser(QHostAddress, QString)));
        connect (&comm, SIGNAL(newUser(QHostAddress, QString)), this, SLOT(setUserOnline(QHostAddress, QString)));
        connect (&comm, SIGNAL(leaveUser(QHostAddress)), this->UserList, SLOT(delUser(QHostAddress)));
        connect (&comm, SIGNAL(leaveUser(QHostAddress)), this->TabList, SLOT(setUnactiveUser(QHostAddress)));
        connect (&comm, SIGNAL(recvPMsg(QHostAddress, QString)), this, SLOT(recvPMsg(QHostAddress,QString)));
        connect (&comm, SIGNAL(recvBMsg(QHostAddress, QString)), this, SLOT(recvBMsg(QHostAddress, QString)));
        connect (&comm, SIGNAL(pong(QHostAddress, qint32)), this, SLOT(pong(QHostAddress, qint32)));
        connect (&comm, SIGNAL(connected()), this, SLOT(connected()));
        connect (&comm, SIGNAL(unableConnect()), this, SLOT(unableConnect()));
        connect (&comm, SIGNAL(invalidNick()), this, SLOT(invalidNick())); 

        connect (TabList,SIGNAL(tabCanNotBeClose()),this,SLOT(tabCanNotBeClose()));
        connect (TabList,SIGNAL(tabCanBeClose()),this,SLOT(tabCanBeClose()));
        connect (TabList,SIGNAL(isOnline()),this,SLOT(isOnline()));
        connect (TabList,SIGNAL(isNotOnline()),this,SLOT(isNotOnline()));
        connect (TabList,SIGNAL(setDisableInputText()),ChatTextInput, SLOT(setEnabled(false)));
}

void GUIMainWindow::privateChat (QHostAddress &host)
{
        TabList->addTab(host,UserList->returnNameUser(host),true,"icon/Chat/user.png");
}

void GUIMainWindow::sendFile (QHostAddress &host)
{
        //jesli klasa nie jest urzywana, tzn mozeymy wyslac tylko jeden plik naraz
        if(!(incoming_file_window.isActive()) && !(outcomming_file_window.isActive()) )
        {
        //plij jest wysylany
        is_file_outcoming = 1;
                QString file("");
                file.append( outcomming_file_window.choseFille());
                //jesli wybrano plik, tzn ciagn nie jest pusty
                if( file != "")
                {
                        QString msg;
                        msg.append(tr("wysyłam plik do usera <b>"));
                        msg.append(UserList->returnNameUser(host));
                        msg.append("</b> o scieżce: <u>");
                        msg.append(file);
                        msg.append("</u>");
                        TabList->getActiveTab()->chat->printSysMsg(msg);
                        try
                        {
                                //ustawiam zmeina na aktywna zeby nie mozna bylo wyslac 2 plikow
                                outcomming_file_window.setActive(1);
                                //wywoluje fukcje odpowidzialna za przesyl pliku..
                                comm.sendFile (host, file);
                        }
                        catch(Exeptions & wyjatek)
                        {
                                QMessageBox::warning(this,QString(tr("Wyjštek:")),wyjatek.getErrorMessage());
                        }
                }
                else
                {
                        //jesli Użytkownik nie wybral pliku i wcisnal CANCEL
                        QString msg(tr("Rezygnacja z wysłania pliku"));
                        TabList->getActiveTab()->chat->printSysMsg(msg);
                        //ustawiam zmeina na aktywna zeby nie mozna bylo wyslac 2 plikow
                        outcomming_file_window.setActive(0);
                }
        }
}

void GUIMainWindow::acceptSendFile (QHostAddress host, QString file)
{
        outcomming_file_window.setActive(1);
        QString nick= UserList->returnNameUser(host);
        outcomming_file_window.showTransfer(nick, file);
        TabList->publicChat()->chat->printSysMsg(tr("Użytkownik zakceptował połšczenie"));
}

void GUIMainWindow::refuseSendFile (QHostAddress host, QString file)
{
        QString msg;
        msg.append(tr(" Użytkownik <b>"));
        msg.append(this->UserList->returnNameUser(host));
        msg.append(tr("</b> odmówił przyjęcia pliku: <u>"));
        msg.append(file);
        msg.append("</u>");

        QMessageBox::warning(this,QString(tr("Niepowodzenie w przesyłaniu pliku")),msg);
        outcomming_file_window.setActive(0);
}

void GUIMainWindow::checkIp (QHostAddress &host)
{
        QString msg;
        msg.append(tr("użytkownik: <b>"));
        msg.append(this->UserList->returnNameUser(host));
        msg.append(tr("</b> posiada IP: <u>"));
        msg.append(host.toString());
        msg.append("</u>");
        TabList->getActiveTab()->chat->printUserMsg(msg);
}

void GUIMainWindow::checkPing (QHostAddress &host)
{
        TabList->getActiveTab()->chat->printUserMsg(tr("Sprawdzam ping do użytkownika <b>") + userName(host) + "</b>");
        try
        {
                comm.checkPing(host);
        }
        catch(Exeptions & wyjatek)
        {
                QMessageBox::warning(this,QString(tr("Wyjštek:")),wyjatek.getErrorMessage());
        }
}

void GUIMainWindow::pong(QHostAddress ip, qint32 time)
{
        QString msg;
        msg.append(tr("ping do użytkownika <b>"));
        msg.append(this->UserList->returnNameUser(ip));
        if (time == -1)
        {
                msg.append(" </b> <u> ");
                msg.append(tr("użytkownik nie odpowiada !!"));
                msg.append(" </u>");
        }
        else
        {
                msg.append(tr("</b> wynosi: <u>"));
                msg.append(QString::number(time)+tr("msek"));
                msg.append("</u>");
        }
        TabList->getActiveTab()->chat->printUserMsg(msg);
}

void GUIMainWindow::invalidNick()
{
        QMessageBox::warning(this,QString(tr("Wyjštek:")),tr("Nick jest już zajęty, zmnień nick!!"));
        disconnectChat();
}

void GUIMainWindow::recvPMsg (QHostAddress host, QString msg)
{
        int tab_is_create = TabList->isCreate(host); //0 jesli istnieje zwroci nr zakladki, jesli nie istnieje 0
        int current_index = TabList->currentIndex(); //dotychczas otwarta zakladka
        QString mesage, user_name;
        user_name = this->userName(host);

        mesage.append(this->time());
        mesage.append("&nbsp;<b> ");
        mesage.append(user_name);
        mesage.append("</b> ");
        mesage.append(msg);
        mesage.append("<br>");
        if(!tab_is_create)
        {
                TabList->addTab(host,user_name,true,"icon/Chat/chat.png");
                TabList->setTabTextColor(TabList->currentIndex());
                TabList->setTabIcon(TabList->currentIndex(),QIcon("icon/Chat/chat.png"));
                TabList->getActiveTab()->chat->append(mesage);
                TabList->setCurrentIndex(current_index);
        }
        else
        {
                if(TabList->getTabNumber(host) != TabList->currentIndex())
                {
                TabList->setTabTextColor(tab_is_create);
                TabList->setTabIcon(tab_is_create,QIcon("icon/Chat/chat.png"));
        }
                TabList->tab(tab_is_create)->chat->append(mesage);
        }
}

void GUIMainWindow::connectChat ()
{
        TabList->publicChat()->chat->printSysMsg(tr("Trwa próba połšczenia..."));
        try
        {
                connect_buton->setEnabled(false);
                comm.welcome (Settings->getNick(), Settings->getBroadcast(),Settings->getPort());
        }
        catch(Exeptions & wyjatek)
        {
                QMessageBox::warning(this,QString(tr("Wyjštek:")),wyjatek.getErrorMessage());
        }
}

void GUIMainWindow::connected()
{
        TabList->publicChat()->chat->printSysMsg(tr("Program połšczony"));
        disconnect(connect_buton, SIGNAL(triggered()), this, SLOT(connectChat()));
        connect_buton->setToolTip(tr("Rozłšcz"));
        connect_buton->setIcon(QIcon("icon/MainToolBar/disconnect.png"));
        connect(connect_buton, SIGNAL(triggered()), this, SLOT(disconnectChat()));

        UserList->setEnabled(true);
        connect_buton->setEnabled(true);
        TextToolBar->setEnabled(true);
        ChatTextInput->setEnabled(true);

        is_connect = true;

        UserList->setMyNick(Settings->getNick());
        outcomming_file_window.setDir(Settings->getFileStoragePath());
        incoming_file_window.setDir(Settings->getFileStoragePath());
}

void GUIMainWindow::unableConnect()
{
        TabList->publicChat()->chat->printSysMsg(tr("Nie udało sie połšczyć"));
        connect_buton->setEnabled(true);

        QMessageBox::warning(this,QString("Błšd"),

        tr("Próba połšczenia zakończona <b>niepowodzeniem</b><br> SprawdŸ:<br>- czy adress broadcast jest poprawny<br>"
        "- ustawienia zapory ogniowej<br>"
        "- czy komputer jest podpięty do sieci"
        "- czy połšczenie sieciowe jest włšczone"));
}

void GUIMainWindow::disconnectChat ()
{
        TabList->publicChat()->chat->printSysMsg(tr("Program rozłšczony"));
        disconnect(connect_buton, SIGNAL(triggered()), this, SLOT(disconnectChat()));
        connect_buton->setToolTip(tr("Połšcz"));
        connect_buton->setIcon(QIcon("icon/MainToolBar/connect.png"));
        connect(connect_buton, SIGNAL(triggered()), this, SLOT(connectChat()));
        try
        {
                comm.bye ();
        }
        catch(Exeptions & wyjatek)
        {
                QMessageBox::warning(this,QString(tr("Wyjštek:")),wyjatek.getErrorMessage());
        }
        UserList->clearAllUsers();
        UserList->setEnabled(false);
        TextToolBar->setEnabled(false);
        ChatTextInput->setEnabled(false);
        TabList->closeAllPrivChat();

        is_connect = false;
}

void GUIMainWindow::recvBMsg (QHostAddress host, QString msg)
{
        QString message;
        message.append(this->time());
        message.append("<b>&nbsp;");
        message.append(userName(host));
        message.append("</b><br>");
        message.append(msg);

        TabList->publicChat()->chat->append(message);
        TabList->setTabTextColor(0);
        TabList->setTabIcon(0,QIcon("icon/Chat/chat.png"));
}

void GUIMainWindow::sendMsg()
{
        if(this->ChatTextInput->toPlainText().size())
        {
                if((is_connect == true) && (TabList->getActiveTab()->getOnline() == true))
                {
                        QString msg;
                        msg.append(this->time());
                        msg.append("<b>");
                        msg.append("&nbsp;");
                        msg.append(Settings->getNick());
                        msg.append("&nbsp;</b><br>");
                        msg.append("</td></tr><tr><td>");
                        msg.append(this->ChatTextInput->toHtml());
        
                        TabList->getActiveTab()->chat->printChatText(msg);
                        if(TabList->getActiveTab()->getIp() == Settings->getBroadcast())        
                        {
                                try
                                {
                                        comm.sendBMsg (this->ChatTextInput->toHtml());
                                }
                                catch(Exeptions & wyjatek)
                                {
                                        QMessageBox::warning(this,QString(tr("Wyjštek:")),wyjatek.getErrorMessage());
                                }
                        }
                        else
                        {
                                try
                                {
                                        comm.sendPMsg (TabList->getActiveTab()->getIp(), this->ChatTextInput->toHtml());
                                }
                                catch(Exeptions & wyjatek)
                                {
                                        QMessageBox::warning(this,QString(tr("Wyjštek:")),wyjatek.getErrorMessage());
                                }
                        }
                }
                this->ChatTextInput->clear ();
        }

}

void GUIMainWindow::createMainToolBar(QToolBar *tool_bar)
{
        QAction *a;
        //polaczenie - rozlaczenie
        connect_buton = new QAction(QIcon("icon/MainToolBar/connect.png"), tr("Polacz"),tool_bar);
        connect(connect_buton, SIGNAL(triggered()), this, SLOT(connectChat())); 
        tool_bar->addAction(connect_buton);

        //settings      
        a= new QAction(QIcon("icon/MainToolBar/configure.png"), tr("Ustawienia"),tool_bar);
        connect(a, SIGNAL(triggered()), this, SLOT(configureChat()));   
        tool_bar->addAction(a);
        //clear page

        a= new QAction(QIcon("icon/MainToolBar/clear.png"), tr("Czyœć okno wiadomoœci"),tool_bar);
        connect(a, SIGNAL(triggered()),this, SLOT(clearActiveChatPage()));      
        tool_bar->addAction(a);

        //close active tab
        close_active_tab_buton= new QAction(QIcon("icon/MainToolBar/close_page_active.png"), tr("Zamknij zakładkę"),tool_bar);

        connect(close_active_tab_buton, SIGNAL(triggered()), TabList, SLOT(closeActiveTab()));  

        tool_bar->addAction(close_active_tab_buton);

        close_active_tab_buton->setEnabled(false);
        tool_bar->addSeparator();
        a= new QAction(QIcon("icon/MainToolBar/help.png"), tr("O programie"),tool_bar);
        a->setShortcut(Qt::Key_F1);
        connect(a, SIGNAL(triggered()),this, SLOT(about()));
        tool_bar->addAction(a);

}

void GUIMainWindow::about()
{
        QDialog aboutProgram;
        aboutProgram.setWindowOpacity(0.95);
        aboutProgram.setWindowTitle("lanChat ver. 1.0");
                
        QPalette pal = aboutProgram.palette();
        pal.setColor(QPalette::Window, Qt::white);
        aboutProgram.setPalette(pal);
        
        QString about;
        about.append("<TABLE>");
        about.append("<TR><TD><h3>Autorzy:</h3></TD></TR>");
        about.append("<TR><TD></TD></TR>");
        about.append("<TR><TD><b>GJMP:</b></TD><TD>   <font color=#0055FF>gjmp@o2.pl </font><br></TD></TR>");
        about.append("<TR><TD><b>luik:</b></TD><TD>   <font color=#0055FF>luik@bielawa.info </font><br></TD></TR>");
        about.append("<TR><TD><b>n0rn:</b></TD><TD>   <font color=#0055FF>n0rn@tlen.pl </font><br></TD></TR>");
        about.append("<TR><TD><b>PeBek:</b></TD><TD>  <font color=#0055FF>pebek.tux@gmail.com </font><br></TD></TR>");
        about.append("<TR><TD><b>PKW:</b></TD><TD>    <font color=#0055FF>pkw@vitea.pl </font><br></TD></TR>");
        about.append("</TABLE>");
        about.append("<TABLE>");
        about.append("<TR><TD><h3> Strona internetowa </h3></TD></TR>");
        about.append("<TR><TD><font color=#0055FF><a>http://avalanche-chat.sourceforge.net<a></font></TD></TR>");
        about.append("</TABLE>");       
        
        QHBoxLayout *main = new QHBoxLayout;
        
        QVBoxLayout *picture = new QVBoxLayout;
        QPixmap *logo = new QPixmap("icon/logoMini.png");
        QLabel *pixmapLabel = new QLabel;
        pixmapLabel->setPixmap(*logo);
        QLabel *authors = new QLabel;
        authors->setText(about);
        
        picture->addWidget(pixmapLabel);
        picture->addStretch(1);
        main->addLayout(picture);
        main->addWidget(authors);
        aboutProgram.setLayout(main);
        
        aboutProgram.exec();    
        
}






void GUIMainWindow::cancelFileTransfer()

{
        //przerwanie transferu
        try
        {
                if(is_file_outcoming)
                {
                        comm.cancelTranfer ();
                        outcomming_file_window.setActive(0);
                }
                else
                {
                        comm.cancelTranfer ();
                        incoming_file_window.setActive(0);
                }
        }
        catch(Exeptions & wyjatek)
        {
                QMessageBox::warning(this,QString(tr("Wyjštek:")),wyjatek.getErrorMessage());
        }
        TabList->getActiveTab()->chat->printSysMsg(tr(" <b>Przerwano transfer plików</b>"));
}

void GUIMainWindow::incomingFile(QHostAddress host, QString file, quint32 size)
{
        //jesli klasa juz jest aktywna
        if(!(incoming_file_window.isActive()) && !(outcomming_file_window.isActive()) )
        {
                //plij jest odbierany
                is_file_outcoming = 0;
                QString nick(this->UserList->returnNameUser(host));
                if( incoming_file_window.showWindowQuestion(nick, file) )
                {
                        //ustawiam zmiena klasy na aktywana zeby nie mozna bylo odbierac wiecej niz jeden plik
                        incoming_file_window.setActive(1);
                        QString file_to_save("");
                        file_to_save.append( incoming_file_window.saveFille(file));
                        //jelsi wybrany plik nie jest pusty
                        if( file_to_save != "")
                        {
                                //odbieramy tenze plik
                                try
                                {
                                        //wysylam potwierdzenei odbioru pliku
                                        comm.acceptFileRequest (host, file_to_save);
                                }
                                catch(Exeptions & wyjatek)
                                {
                                        QMessageBox::warning(this,QString(tr("Wyjštek:")),wyjatek.getErrorMessage());
                                }
                                
                                TabList->getActiveTab()->chat->append(tr("Zapisuje plik jako: <b>"));
                                TabList->getActiveTab()->chat->append(file_to_save);
                                incoming_file_window.showTransfer(nick, file_to_save);
                        }
                        else
                        {
                                TabList->getActiveTab()->chat->printSysMsg(tr("Odmowa przyjęcia pliku"));
                                try
                                {
                                        //jeœli nie chemy przyjšc pliku
                                        comm.refuseFileRequest (host);
                                        //klasa ustawiam na deaktywna
                                        incoming_file_window.setActive(0);
                                }
                                catch(Exeptions & wyjatek)
                                {
                                        QMessageBox::warning(this,QString(tr("Wyjštek:")),wyjatek.getErrorMessage());
                                }
                        }
                }
                else
                {
                        TabList->getActiveTab()->chat->printSysMsg(tr("Odmowa przyjęcia pliku"));
                        try
                        {
                                //jesli nie chemy przyjac pliku
                                comm.refuseFileRequest (host);
                                //klasa ustawiam na deaktywna
                                incoming_file_window.setActive(0);
                        }
                        catch(Exeptions & wyjatek)
                        {
                                QMessageBox::warning(this,QString(tr("Wyjštek:")),wyjatek.getErrorMessage());
                        }
                }
        }
}



void GUIMainWindow::transferEnd (QHostAddress host, bool czy_ok)

{
        if(is_file_outcoming)
        {
                outcomming_file_window.upgradeTransfer(100);
                outcomming_file_window.setActive(0);
        }
        else
        {
                incoming_file_window.upgradeTransfer(100);
                incoming_file_window.setActive(0);
        }
        if(czy_ok)
        {
                TabList->getActiveTab()->chat->printSysMsg(tr("Transfer pliku zakończył się powodzeniem"));
        }
        else
        {
                TabList->getActiveTab()->chat->printSysMsg(tr("Transfer pliku zakończył się <b> NIEPOWODZENIEM </b>"));
        }
}

void GUIMainWindow::fileProgress (int procent)
{
        if(is_file_outcoming)
        {
                outcomming_file_window.upgradeTransfer(procent);
        }
        else
        {
                incoming_file_window.upgradeTransfer(procent);
        }
}

void GUIMainWindow::configureChat()
{
         Settings->exec();
}

void GUIMainWindow::tabCanNotBeClose()
{
        close_active_tab_buton->setEnabled(false);
}

void GUIMainWindow::tabCanBeClose()
{
        close_active_tab_buton->setEnabled(true);
}

void GUIMainWindow::isOnline()
{
        if(is_connect)
        ChatTextInput->setEnabled(true);
}

void GUIMainWindow::isNotOnline()
{
        ChatTextInput->setEnabled(false);
}

void GUIMainWindow::setUserOnline(QHostAddress host, QString msg)
{
        if(TabList->isCreate(host))
        {
                TabList->tab(TabList->getTabNumber(host))->setOnline(true);
                TabList->setTabIcon(TabList->getTabNumber(host),QIcon("icon/Chat/user.png"));
                TabList->setTabTextColor(TabList->getTabNumber(host), Qt::black);
                if(TabList->getTabNumber(host) == TabList->currentIndex())
                {
                        ChatTextInput->setEnabled(true);
            }
        }
}

QString GUIMainWindow::time()
{
        QString msg;
        msg.append("<font color=\"blue\">");
        msg.append(QTime::currentTime().toString());
        msg.append("</font>");
        return msg;
}

QString GUIMainWindow::userName(QHostAddress host)
{
        QString user_name;
        if((user_name = this->UserList->returnNameUser(host)) != "")
        {
                return user_name;
        }
        else
        {
                return host.toString();
        }
}

void GUIMainWindow::clearActiveChatPage()
{
        TabList->getActiveTab()->chat->clear();
}

void GUIMainWindow::setApperance()
{
        QPalette tmp;
        tmp = ChatTextInput->palette();
        tmp.setColor(QPalette::Base,Settings->getBackgroundColor());
        ChatTextInput->setPalette(tmp);
        ChatTextInput->setDefFontColor(Settings->getFontColor());
        ChatTextInput->setTextColor(Settings->getFontColor());
        tmp = UserList->palette();
        tmp.setColor(QPalette::Base,Settings->getBackgroundColor());
        tmp.setColor(QPalette::Text,Settings->getFontColor());
        UserList->setPalette(tmp);
        tmp = TabList->palette();
        tmp.setColor(QPalette::Base,Settings->getBackgroundColor());
        tmp.setColor(QPalette::Text,Settings->getFontColor());
        TabList->setPalette(tmp);
        if(Settings->getOpacityEnabled())
        {
                this->setAutoFillBackground(false);
                this->setAttribute(Qt::WA_NoSystemBackground, false);
                this->setWindowOpacity(Settings->getOpacity());
        }
        else
        {
                this->setWindowOpacity(1.0);
        }
        if(is_connect)
        {
                this->disconnectChat();
                this->connectChat();
        }
}

void GUIMainWindow::closeEvent(QCloseEvent *e)
{
   if(is_connect)     
        try
        {
                comm.bye();
        }
        catch(Exeptions & wyjatek)
        {
                        QMessageBox::warning(this,QString(tr("Wyjštek:")),wyjatek.getErrorMessage());
        }
        e->accept();
}

---