/*
  Copyright 2010 Grégory Soutadé

  This file is part of KissCount.

  KissCount is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  KissCount is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with KissCount.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "PreferencesPanel.h"

enum {ACCOUNT_NAME, ACCOUNT_NUMBER, ACCOUNT_SHARED, ACCOUNT_DEFAULT, ACCOUNT_DELETE, NUMBER_COLS_ACCOUNT};
enum {CATEGORY_NAME, CATEGORY_BACKGROUND_COLOR, CATEGORY_FOREGROUND_COLOR, CATEGORY_FONT, CATEGORY_DELETE, NUMBER_COLS_CATEGORY};

enum {CATEGORIES_GRID_ID=1, ACCOUNTS_GRID_ID, NAME_ID, CHANGE_NAME_ID, CHANGE_PASSWORD_ID, KILL_ME_ID, LANGUAGE_ID,
      OPERATION_ORDER_ID};

BEGIN_EVENT_TABLE(PreferencesPanel, wxPanel)
EVT_BUTTON(CHANGE_NAME_ID, PreferencesPanel::OnChangeName)
EVT_BUTTON(CHANGE_PASSWORD_ID, PreferencesPanel::OnChangePassword)
EVT_BUTTON(KILL_ME_ID, PreferencesPanel::OnKillMe)
EVT_GRID_CMD_CELL_CHANGE(CATEGORIES_GRID_ID, PreferencesPanel::OnCategoryModified)
EVT_GRID_CMD_CELL_CHANGE(ACCOUNTS_GRID_ID, PreferencesPanel::OnAccountModified)
EVT_COMBOBOX(OPERATION_ORDER_ID, PreferencesPanel::OnOperationOrderChange)
EVT_COMBOBOX(LANGUAGE_ID, PreferencesPanel::OnLanguageChange)
EVT_SHOW(PreferencesPanel::OnShow)
END_EVENT_TABLE()

PreferencesPanel::PreferencesPanel(KissCount* kiss, wxUI *parent) : wxPanel(&(*parent)), _kiss(kiss), _wxUI(parent)
{
    wxBoxSizer *vbox = new wxBoxSizer(wxVERTICAL);
    wxBoxSizer *hbox1 = new wxBoxSizer(wxHORIZONTAL);
    wxBoxSizer *hbox2 = new wxBoxSizer(wxHORIZONTAL);
    //wxBoxSizer *hbox = new wxBoxSizer(wxHORIZONTAL);
    wxStaticBox* staticUser, *staticAccount, *staticCategories, *staticLanguage, *staticOperationOrder;
    User* user = _kiss->GetUser();
    wxGridBagSizer *gridBagSizer;
    wxStaticText* label;
    wxButton* buttonChangeName, *buttonChangePassword, *killMe;
    wxStaticBoxSizer * staticBoxSizer;

    SetSizer(vbox);

    staticUser = new wxStaticBox(this, wxID_ANY, _("User"));
    staticAccount = new wxStaticBox(this, wxID_ANY, _("Accounts"));
    staticCategories = new wxStaticBox(this, wxID_ANY, _("Categories"));
    staticLanguage = new wxStaticBox(this, wxID_ANY, _("Language"));
    staticOperationOrder = new wxStaticBox(this, wxID_ANY, _("Operation order"));

    // User
    staticBoxSizer = new wxStaticBoxSizer (staticUser, wxVERTICAL);

    gridBagSizer = new wxGridBagSizer(10, 10);
    staticBoxSizer->Add(gridBagSizer);

    label = new wxStaticText(this, wxID_ANY, _("Name"));
    gridBagSizer->Add(label, wxGBPosition(0, 0));
    
    _name = new wxTextCtrl(this, NAME_ID, user->_name);
    gridBagSizer->Add(_name, wxGBPosition(0, 1));

    buttonChangeName = new wxButton(this, CHANGE_NAME_ID, _("Change Name"));
    buttonChangePassword = new wxButton(this, CHANGE_PASSWORD_ID, _("Change Password"));
    killMe = new wxButton(this, KILL_ME_ID, _("Kill me"));

    gridBagSizer->Add(buttonChangeName, wxGBPosition(1, 0));
    gridBagSizer->Add(buttonChangePassword, wxGBPosition(1, 1));
    gridBagSizer->Add(killMe, wxGBPosition(1, 2));

    vbox->Add(staticBoxSizer);
    vbox->Add(-1, 20);

    // Account
    staticBoxSizer = new wxStaticBoxSizer (staticAccount, wxVERTICAL);

    {
        int clicks[] = {ACCOUNT_SHARED, ACCOUNT_DEFAULT, ACCOUNT_DELETE};

        _accountsGrid = new wxMyGrid(this, ACCOUNTS_GRID_ID, clicks, 3);
    }

    InitAccounts(user);

    staticBoxSizer->Add(_accountsGrid);

    hbox1->Add(staticBoxSizer);
    hbox1->Add(-1, 20);

    // Categories
    staticBoxSizer = new wxStaticBoxSizer (staticCategories, wxVERTICAL);

    {
        int clicks[] = {CATEGORY_BACKGROUND_COLOR, CATEGORY_FOREGROUND_COLOR, CATEGORY_FONT, CATEGORY_DELETE};

        _categoriesGrid = new wxMyGrid(this, CATEGORIES_GRID_ID, clicks, 4);
    }

    staticBoxSizer->Add(_categoriesGrid);

    InitCategories(user);

    hbox1->Add(staticBoxSizer);
    hbox1->Add(-1, 20);

    vbox->Add(hbox1);
    vbox->Add(-1, 20);

    // Operation Order
    staticBoxSizer = new wxStaticBoxSizer (staticOperationOrder, wxVERTICAL);

    _operationOrder = new wxComboBox(this, OPERATION_ORDER_ID);
    _operationOrder->SetWindowStyle(wxCB_READONLY);

    staticBoxSizer->Add(_operationOrder);

    hbox2->Add(staticBoxSizer);
    hbox2->Add(-1, 20);

    InitOperationOrder(user);

    // Language
    staticBoxSizer = new wxStaticBoxSizer (staticLanguage, wxVERTICAL);

    _language = new wxBitmapComboBox(this, LANGUAGE_ID);
    _language->SetWindowStyle(wxCB_READONLY);

    staticBoxSizer->Add(_language);

    hbox2->Add(staticBoxSizer);
    hbox2->Add(-1, 20);

    InitLanguage(user);

    _language->Fit();

    vbox->Add(hbox2);

    Fit();
    SetMinSize(GetSize());

    Hide();
}

void PreferencesPanel::InitAccounts(User* user)
{
    std::vector<Account>::iterator it;
    int curLine = 0;
    Account account ;
    DEFAULT_FONT(font);

    _accountsGrid->CreateGrid(0, NUMBER_COLS_ACCOUNT);
    _accountsGrid->SetRowLabelSize(0);
    _accountsGrid->SetColLabelValue(ACCOUNT_NAME, _("Name"));
    _accountsGrid->SetColLabelValue(ACCOUNT_NUMBER, _("Number"));
    _accountsGrid->SetColLabelValue(ACCOUNT_SHARED, _("Shared"));
    _accountsGrid->SetColLabelValue(ACCOUNT_DEFAULT, _("Default"));
    _accountsGrid->SetColLabelValue(ACCOUNT_DELETE, _("Delete"));
    _accountsGrid->SetDefaultCellFont(font);

    for (it = user->_accounts.begin(); it != user->_accounts.end(); it++, curLine++)
    {
        _accountsGrid->AppendRows();

        _accountsGrid->SetCellValue(curLine, ACCOUNT_NAME, it->name);
        _accountsGrid->SetCellValue(curLine, ACCOUNT_NUMBER, it->number);

        _accountsGrid->SetCellRenderer(curLine, ACCOUNT_SHARED, new wxGridCellBoolRenderer ());
        _accountsGrid->SetCellEditor(curLine, ACCOUNT_SHARED, new wxGridCellFastBoolEditor ());
        _accountsGrid->SetCellRenderer(curLine, ACCOUNT_DEFAULT, new wxGridCellBoolRenderer ());
        _accountsGrid->SetCellEditor(curLine, ACCOUNT_DEFAULT, new wxGridCellFastBoolEditor ());
        _accountsGrid->SetCellRenderer(curLine, ACCOUNT_DELETE, new wxGridCellBoolRenderer ());
        _accountsGrid->SetCellEditor(curLine, ACCOUNT_DELETE, new wxGridCellBoolEditor ());
        _accountsGrid->SetCellValue(curLine, ACCOUNT_SHARED, (it->shared)?wxT("1"):wxT("0"));
        _accountsGrid->SetCellValue(curLine, ACCOUNT_DEFAULT, (it->_default)?wxT("1"):wxT("0"));
      
        _accountsGrid->SetCellAlignment(curLine, ACCOUNT_SHARED, wxALIGN_CENTRE, wxALIGN_CENTRE);
        _accountsGrid->SetCellAlignment(curLine, ACCOUNT_DEFAULT, wxALIGN_CENTRE, wxALIGN_CENTRE);
        _accountsGrid->SetCellAlignment(curLine, ACCOUNT_DELETE, wxALIGN_CENTRE, wxALIGN_CENTRE);
    }

    _accountsGrid->AutoSizeColumns(true);    
    _accountsGrid->AppendRows();

    _accountsGrid->SetReadOnly(curLine, ACCOUNT_SHARED, true);
    _accountsGrid->SetReadOnly(curLine, ACCOUNT_DEFAULT, true);
    _accountsGrid->SetReadOnly(curLine, ACCOUNT_DELETE, true);
}

#define SET_ROW_COLOR(row, backcolor, forecolor)  for(int i=0; i<NUMBER_COLS_CATEGORY; i++) \
    {									\
        _categoriesGrid->SetCellBackgroundColour(row, i, backcolor);        \
        _categoriesGrid->SetCellTextColour(row, i, forecolor);        \
    }

#define SET_ROW_FONT(row, font)  for(int i=0; i<NUMBER_COLS_CATEGORY; i++) \
    {									\
        _categoriesGrid->SetCellFont(row, i, font);        \
    }

void PreferencesPanel::InitCategories(User* user)
{
    std::vector<Category>::iterator it;
    int curLine = 0;
    DEFAULT_FONT(font);
    
    _categoriesGrid->CreateGrid(0, NUMBER_COLS_CATEGORY);
    _categoriesGrid->SetRowLabelSize(0);
    _categoriesGrid->SetDefaultCellFont(font);

    _categoriesGrid->SetColLabelValue(CATEGORY_NAME, _("Name"));
    _categoriesGrid->SetColLabelValue(CATEGORY_BACKGROUND_COLOR, _("Background color"));
    _categoriesGrid->SetColLabelValue(CATEGORY_FOREGROUND_COLOR, _("Foreground color"));
    _categoriesGrid->SetColLabelValue(CATEGORY_FONT, _("Font"));
    _categoriesGrid->SetColLabelValue(CATEGORY_DELETE, _("Delete"));

    for (it=user->_categories.begin(); it!=user->_categories.end(); it++, curLine++)
    {
        _categoriesGrid->AppendRows();
	
        _categoriesGrid->SetCellValue(curLine, CATEGORY_NAME, it->name);
        SET_ROW_COLOR(curLine, it->backcolor, it->forecolor);
        if (curLine)
	{
            _categoriesGrid->SetCellRenderer(curLine, CATEGORY_DELETE, new wxGridCellBoolRenderer ());
            _categoriesGrid->SetCellEditor(curLine, CATEGORY_DELETE, new wxGridCellBoolEditor ());
	}

        _categoriesGrid->SetCellRenderer(curLine, CATEGORY_BACKGROUND_COLOR, new wxGridCellButtonRenderer (wxT("...")));
        _categoriesGrid->SetCellRenderer(curLine, CATEGORY_FOREGROUND_COLOR, new wxGridCellButtonRenderer (wxT("...")));
        _categoriesGrid->SetCellRenderer(curLine, CATEGORY_FONT, new wxGridCellButtonRenderer (wxT("...")));
        _categoriesGrid->SetCellEditor(curLine, CATEGORY_BACKGROUND_COLOR, new wxGridCellButtonEditor (wxT("...")));
        _categoriesGrid->SetCellEditor(curLine, CATEGORY_FOREGROUND_COLOR, new wxGridCellButtonEditor (wxT("...")));
        _categoriesGrid->SetCellEditor(curLine, CATEGORY_FONT, new wxGridCellButtonEditor (wxT("...")));

        if (it->font.Length())
        {
            wxFont font = user->GetCategoryFont(it->id);
            SET_ROW_FONT(curLine, font);
        }
    }

    _categoriesGrid->SetReadOnly(0, CATEGORY_NAME, true);
    _categoriesGrid->SetReadOnly(0, CATEGORY_DELETE, true);
    _categoriesGrid->AutoSizeColumns(true);    

    _categoriesGrid->AppendRows();
    _categoriesGrid->SetReadOnly(curLine, CATEGORY_BACKGROUND_COLOR, true);
    _categoriesGrid->SetReadOnly(curLine, CATEGORY_FOREGROUND_COLOR, true);
    _categoriesGrid->SetReadOnly(curLine, CATEGORY_FONT, true);
    _categoriesGrid->SetReadOnly(curLine, CATEGORY_DELETE, true);
    SET_ROW_COLOR(curLine, OWN_GREEN, *wxBLACK);
}

void PreferencesPanel::InitLanguage(User* user)
{
    int i, select=0;

    for (i=0; i<NB_SUPPORTED_LANGUAGES; i++)
    {
        _language->Append(languages[i].name, wxBitmap(languages[i].icon));
        if (languages[i].language == _wxUI->_language)
            select = i;
    }

    _language->Select(select);
}

void PreferencesPanel::InitOperationOrder(User* user)
{
    _operationOrder->Append(_("Ascending"));
    _operationOrder->Append(_("Descending"));

    if (user->_preferences[wxT("operation_order")] == wxT("ASC"))
        _operationOrder->Select(0);
    else
        _operationOrder->Select(1);
}

void PreferencesPanel::OnAccountModified(wxGridEvent& event)
{
    int op_complete = 2;
    wxString value ;
    Account new_account, account;
    User* user = _kiss->GetUser();
    int row = event.GetRow();
    int col = event.GetCol();
    static bool inModification = false ;
    int i;

    if (inModification) return;

    inModification = true;

    value = _accountsGrid->GetCellValue(row, ACCOUNT_NAME);
    if (value.Length())
    {
        new_account.name = value;
        op_complete--;
    }
  
    value = _accountsGrid->GetCellValue(row, ACCOUNT_NUMBER);
    if (value.Length())
    {
        new_account.number = value;
        op_complete--;
    }

    value = _accountsGrid->GetCellValue(row, ACCOUNT_SHARED);
    if (value.Length() && value != wxT("0"))
        new_account.shared = true;
    else
        new_account.shared = false;

    value = _accountsGrid->GetCellValue(row, ACCOUNT_DEFAULT);
    if (value.Length() && value != wxT("0"))
        new_account._default = true;
    else
        new_account._default = false;

    if (col == ACCOUNT_DEFAULT)
    {
        new_account.id = user->_accounts[row].id;

        for (i=0; i<user->GetAccountsNumber(); i++)
	{
            if (i != row)
	    {
                account = user->_accounts[i];
                if (account._default)
		{
                    account._default = false;
                    _kiss->UpdateAccount(account);
                    _accountsGrid->SetCellValue(i, ACCOUNT_DEFAULT, wxT(""));
                    break;
		}
	    }

            _kiss->UpdateAccount(new_account);
	}
    }

    // Account modification
    if (user->GetAccountsNumber() && row < user->GetAccountsNumber())
    {
        new_account.id = user->_accounts[row].id;

        if (col == ACCOUNT_DELETE)
	{
            if (user->_accounts.size() == 1)
	    {
                wxMessageBox(_("It must be at least one account !"), _("Error"), wxICON_ERROR | wxOK);
                _accountsGrid->SetCellValue(row, col, wxT("0"));
                return;
	    }
            wxMessageDialog dialog(_wxUI, _("Are you sure want to delete ")+new_account.name, wxT("KissCount"), wxYES_NO);
            if (dialog.ShowModal() == wxID_NO)
	    {
                _accountsGrid->SetCellValue(row, col, wxT("0"));
	    }
            else
	    {
                _accountsGrid->DeleteRows(row, 1);
                _kiss->DeleteAccount(new_account);
	    }

            _wxUI->Layout();
            inModification = false;
            _wxUI->NeedReload();
            return;
	}

        if (user->GetAccountId(new_account.name) != new_account.id)
	{
            wxMessageBox(_("Account ")+new_account.name+_(" already exists"), _("Error"), wxICON_ERROR | wxOK );
            _accountsGrid->SetCellValue(row, ACCOUNT_NAME, user->_accounts[row].name);
            inModification = false;
            return ;
	}

        _kiss->UpdateAccount(new_account);
    }
    // New account
    else
    {
        if (op_complete) 
	{
            inModification = false;
            return ;
	}

        if (user->GetAccountId(new_account.name) != wxT("0"))
	{
            wxMessageBox(_("Account ")+new_account.name+_(" already exists"), _("Error"), wxICON_ERROR | wxOK );
            inModification = false;
            return ;
	}

        _accountsGrid->SetCellRenderer(row, ACCOUNT_SHARED, new wxGridCellBoolRenderer ());
        _accountsGrid->SetCellEditor(row, ACCOUNT_SHARED, new wxGridCellFastBoolEditor ());
        _accountsGrid->SetCellRenderer(row, ACCOUNT_DEFAULT, new wxGridCellBoolRenderer ());
        _accountsGrid->SetCellEditor(row, ACCOUNT_DEFAULT, new wxGridCellFastBoolEditor ());
        _accountsGrid->SetCellRenderer(row, ACCOUNT_DELETE, new wxGridCellBoolRenderer ());
        _accountsGrid->SetCellEditor(row, ACCOUNT_DELETE, new wxGridCellBoolEditor ());
        _accountsGrid->SetCellAlignment(row, ACCOUNT_SHARED, wxALIGN_CENTRE, wxALIGN_CENTRE);
        _accountsGrid->SetCellAlignment(row, ACCOUNT_DEFAULT, wxALIGN_CENTRE, wxALIGN_CENTRE);
        _accountsGrid->SetCellAlignment(row, ACCOUNT_DELETE, wxALIGN_CENTRE, wxALIGN_CENTRE);

        _accountsGrid->SetReadOnly(row, ACCOUNT_SHARED, false);
        _accountsGrid->SetReadOnly(row, ACCOUNT_DEFAULT, false);
        _accountsGrid->SetReadOnly(row, ACCOUNT_DELETE, false);

        if (!user->GetAccountsNumber())
	{
            new_account._default = true;
            _accountsGrid->SetCellValue(row, ACCOUNT_DEFAULT, wxT("1"));
	}
      
        _accountsGrid->AutoSizeColumns(true);    
        _accountsGrid->AppendRows();

        _accountsGrid->SetReadOnly(row+1, ACCOUNT_SHARED, true);
        _accountsGrid->SetReadOnly(row+1, ACCOUNT_DEFAULT, true);
        _accountsGrid->SetReadOnly(row+1, ACCOUNT_DELETE, true);

        _kiss->AddAccount(new_account);
    }
  
    _wxUI->Layout();
    _wxUI->NeedReload();
    inModification = false;
}

void PreferencesPanel::OnCategoryModified(wxGridEvent& event)
{
    int op_complete = 1;
    wxString value;
    User* user = _kiss->GetUser();
    int row = event.GetRow();
    int col = event.GetCol();
    static bool inModification = false ;
    Category new_cat;

    if (inModification) return;

    inModification = true;

    if (event.GetCol() == CATEGORY_BACKGROUND_COLOR)
    {
        wxColourData color;
        color.SetColour(wxColor(user->_categories[row].backcolor));
        wxColourDialog dial(this, &color);

        if (dial.ShowModal() == wxID_OK)
        {
            user->_categories[row].backcolor = dial.GetColourData().GetColour();
            _kiss->UpdateCategory(user->_categories[row]);
            
            SET_ROW_COLOR(row, user->_categories[row].backcolor, user->_categories[row].forecolor);
            _wxUI->NeedReload();
        }

        inModification = false ;
        return ;
    }

    if (event.GetCol() == CATEGORY_FOREGROUND_COLOR)
    {
        wxColourData color;
        color.SetColour(wxColor(user->_categories[row].forecolor));
        wxColourDialog dial(this, &color);

        if (dial.ShowModal() == wxID_OK)
        {
            user->_categories[row].forecolor = dial.GetColourData().GetColour();
            _kiss->UpdateCategory(user->_categories[row]);
            
            SET_ROW_COLOR(row, user->_categories[row].backcolor, user->_categories[row].forecolor);
            _wxUI->NeedReload();
        }

        inModification = false ;
        return ;
    }

    if (event.GetCol() == CATEGORY_FONT)
    {
        wxFontData font;
        font.SetInitialFont(_kiss->ExtractFont(user->_categories[row].font));
        wxFontDialog dial(this, font);

        if (dial.ShowModal() == wxID_OK)
        {
            font = dial.GetFontData();

            user->_categories[row].font = _kiss->CompactFont(font.GetChosenFont());
            _kiss->UpdateCategory(user->_categories[row]);
            
            SET_ROW_FONT(row, font.GetChosenFont());
            _wxUI->NeedReload();
        }

        inModification = false ;
        return ;
    }

    value = _categoriesGrid->GetCellValue(row, CATEGORY_NAME);
    if (value.Length())
    {
        new_cat.name = value;
        op_complete--;
    }

    new_cat.backcolor = _categoriesGrid->GetCellBackgroundColour(row, col);
    new_cat.forecolor = _categoriesGrid->GetCellTextColour(row, col);
    new_cat.font = wxT("");
    new_cat.parent = wxT("0");

    // Categories modification
    if (user->GetCategoriesNumber() && row < user->GetCategoriesNumber())
    {
        new_cat.id = user->_categories[row].id;
        if (col == CATEGORY_DELETE)
	{
            wxMessageDialog dialog(_wxUI, _("Are you sure want to delete : \n")+new_cat.name, wxT("KissCount"), wxYES_NO);
            if (dialog.ShowModal() == wxID_NO)
	    {
                _categoriesGrid->SetCellValue(row, col, wxT("0"));
	    }
            else
	    {
                _categoriesGrid->DeleteRows(row, 1);
                _kiss->DeleteCategory(user->_categories[row]);
	    }

            _wxUI->Layout();
            _wxUI->NeedReload();
            inModification = false;
            return;
	}

        if (user->GetCategoryId(new_cat.name) != new_cat.id)
	{
            wxMessageBox(_("Category ")+new_cat.name+_(" already exists"), _("Error"), wxICON_ERROR | wxOK );
            _categoriesGrid->SetCellValue(row, CATEGORY_NAME, user->_categories[row].name);
            inModification = false;
            return ;
	}

        _kiss->UpdateCategory(new_cat);
    }
    // New category
    else
    {
        if (op_complete) 
	{
            inModification = false;
            return ;
	}
      
        if (user->GetCategoryId(new_cat.name) != wxT("0"))
	{
            wxMessageBox(_("Category ")+new_cat.name+_(" already exists"), _("Error"), wxICON_ERROR | wxOK );
            inModification = false;
            return ;
	}

        _kiss->AddCategory(new_cat);
        _categoriesGrid->SetReadOnly(row, CATEGORY_BACKGROUND_COLOR, false);
        _categoriesGrid->SetReadOnly(row, CATEGORY_FOREGROUND_COLOR, false);
        _categoriesGrid->SetReadOnly(row, CATEGORY_FONT, false);
        _categoriesGrid->SetReadOnly(row, CATEGORY_DELETE, false);
        _categoriesGrid->SetCellRenderer(row, CATEGORY_DELETE, new wxGridCellBoolRenderer ());
        _categoriesGrid->SetCellEditor(row, CATEGORY_DELETE, new wxGridCellBoolEditor ());

        row++;
        _categoriesGrid->AppendRows();
        _categoriesGrid->SetReadOnly(row, CATEGORY_BACKGROUND_COLOR, true);
        _categoriesGrid->SetReadOnly(row, CATEGORY_FOREGROUND_COLOR, true);
        _categoriesGrid->SetReadOnly(row, CATEGORY_FONT, true);
        _categoriesGrid->SetReadOnly(row, CATEGORY_DELETE, true);
        SET_ROW_COLOR(row, OWN_GREEN, *wxBLACK);
    }

    _wxUI->Layout();
    _wxUI->NeedReload();

    inModification = false;

    return;
}

void PreferencesPanel::OnChangeName(wxCommandEvent& event)
{ 
    User* user = _kiss->GetUser();
    wxString name = _name->GetLineText(0);

    if (name == user->_name)
        return;

    if (!name.size())
    {
        wxMessageBox(_("Invalid name"), _("Error"), wxICON_ERROR | wxOK);
        return;
    }

    if (_kiss->UserExists(name))
    {
        wxMessageBox(_("User ") + name + _(" already exists"), _("Error"), wxICON_ERROR | wxOK);
        return;
    }

    _kiss->ChangeName(name);

    wxMessageBox(_("Name changed"), wxT("KissCount"), wxICON_INFORMATION | wxOK);
    _wxUI->NeedReload();
    _wxUI->SetTitle(_kiss->GetUser()->_name + wxT(" - ") +_("Preferences"));
}

void PreferencesPanel::OnChangePassword(wxCommandEvent& event)
{  
    PasswordDialog p(_kiss, _wxUI);
    p.ShowModal();
}

void PreferencesPanel::OnOperationOrderChange(wxCommandEvent& event)
{
    if (_operationOrder->GetCurrentSelection() == 0)
        _kiss->SetOperationOrder(wxT("ASC"));
    else
        _kiss->SetOperationOrder(wxT("DESC"));

    _wxUI->NeedReload();
}

void PreferencesPanel::OnLanguageChange(wxCommandEvent& event)
{
    wxLanguage language = languages[_language->GetSelection()].language;
    if (_wxUI->SetLanguage(language) || language == wxLANGUAGE_ENGLISH)
    {
        _wxUI->NeedReload();
        _kiss->SetLanguage(language);
        wxMessageBox(_("Language successfully changed, please go to another panel"), _("KissCount"), wxICON_INFORMATION | wxOK);
    }
    else
        wxMessageBox(_("Language not changed"), _("KissCount"), wxICON_ERROR | wxOK);
}

void PreferencesPanel::OnShow(wxShowEvent& event)
{
    _wxUI->SetTitle(_kiss->GetUser()->_name + _(" - ") + _("Preferences"));
}

void PreferencesPanel::OnKillMe(wxCommandEvent& event)
{  
    User* user = _kiss->GetUser();

    wxMessageDialog dialog(_wxUI, _("Are you sure want to delete ")+user->_name+_(" profil ?"), wxT("KissCount"), wxYES_NO);
    if (dialog.ShowModal() == wxID_NO)
    {
        return;
    }

    _kiss->KillMe();
}