---

AddressManagerFrame.cpp

/*
 * Purpose: AddressManager frame
 * Author:  Frank Buß
 * Created: 2002
 */

#include <wx/clipbrd.h>
#include <stdlib.h>

#include "AddressManager.h"
#include "AddressManagerFrame.h"
#include "dialogs.h"


static const wxUint32 g_admFileId = ('a' | ('d' << 8) | ('m' << 16));
static const wxUint32 g_admFileVersion = 1;


class AddEmptyRowGridCellTextEditor : public wxGridCellTextEditor
{
public:
    AddEmptyRowGridCellTextEditor(AddressManagerFrame& frame) : m_frame(frame) {}
    void BeginEdit(int row, int col, wxGrid* grid)
    {
        // add an empty row, if editing the a cell in the last line
        if (grid->GetRows() - 1 == row) grid->AppendRows(1, false);
        wxGridCellTextEditor::BeginEdit(row, col, grid);
        m_frame.setDirty();
    }
private:
    AddressManagerFrame& m_frame;
};

// AddressManagerFrame constructor
AddressManagerFrame::AddressManagerFrame(wxFrame *frame, const wxString& title,
                 const wxPoint& pos, const wxSize& size):
    wxFrame(frame, -1, title, pos, size)
{
    m_dirty = false;
    m_pGrid = new wxGrid(this, -1, wxPoint(0,0), wxSize(600, 400));
    m_pTable = new AddressGridTable();
    m_pGrid->SetTable(m_pTable);
    m_pGrid->RegisterDataType(wxGRID_VALUE_STRING,
        new wxGridCellStringRenderer,
        new AddEmptyRowGridCellTextEditor(*this));
    m_pGrid->DisableDragRowSize();
    m_pGrid->SetColLabelSize(m_pGrid->GetDefaultRowSize());
    m_pGrid->SetDefaultRowSize(20);

    wxAcceleratorEntry entries[6];
    entries[0].Set(wxACCEL_CTRL,  (int) 'S', wxID_SAVE);
    entries[1].Set(wxACCEL_CTRL,  (int) 'X', MENU_EDIT_CUT);
    entries[2].Set(wxACCEL_CTRL,  (int) 'C', MENU_EDIT_COPY);
    entries[3].Set(wxACCEL_CTRL,  (int) 'V', MENU_EDIT_PASTE);
    entries[4].Set(wxACCEL_CTRL,  (int) 'F', wxID_FIND);
    entries[5].Set(wxACCEL_CTRL,  (int) 'Q', MENU_FILE_EXIT);
    wxAcceleratorTable accel(6, entries);
    SetAcceleratorTable(accel);

    m_pGrid->UpdateDimensions();
    Refresh();

    wxCommandEvent dummy;
    OnMenuFileNew(dummy);
}

AddressManagerFrame::~AddressManagerFrame()
{
    delete m_pGrid;
    delete m_pTable;
}

BEGIN_EVENT_TABLE(AddressManagerFrame, wxFrame)
    EVT_MENU(wxID_ABOUT, AddressManagerFrame::OnAbout)
    EVT_MENU(wxID_NEW, AddressManagerFrame::OnMenuFileNew)
    EVT_MENU(wxID_OPEN, AddressManagerFrame::OnMenuFileOpen)
//    EVT_MENU(wxID_EXIT, AddressManagerFrame::OnMenuFileClose)
    EVT_MENU(wxID_SAVE, AddressManagerFrame::OnMenuFileSave)
    EVT_MENU(wxID_SAVEAS, AddressManagerFrame::OnMenuFileSaveAs)
    EVT_MENU(MENU_FILE_EXIT, AddressManagerFrame::OnMenuFileExit)
    EVT_MENU(MENU_EDIT_CUT, AddressManagerFrame::OnMenuEditCut)
    EVT_MENU(MENU_EDIT_COPY, AddressManagerFrame::OnMenuEditCopy)
    EVT_MENU(MENU_EDIT_PASTE, AddressManagerFrame::OnMenuEditPaste)
    EVT_MENU(wxID_FIND, AddressManagerFrame::OnMenuEditFind)
    EVT_MENU(MENU_TABLE_DOUBLET, AddressManagerFrame::OnMenuTableDoublet)
    EVT_MENU(MENU_TABLE_SORT, AddressManagerFrame::OnMenuTableSort)
    EVT_MENU(MENU_TABLE_CONFIG, AddressManagerFrame::OnMenuTableConfig)
    EVT_MENU(MENU_EXPORT_EMAIL, AddressManagerFrame::OnMenuExportEmail)
    EVT_MENU(MENU_EXPORT_SMS, AddressManagerFrame::OnMenuExportSMS)
    EVT_MENU(MENU_EXPORT_FAX, AddressManagerFrame::OnMenuExportFax)
    EVT_CLOSE(AddressManagerFrame::OnClose)

    EVT_SIZE(AddressManagerFrame::OnSize)
END_EVENT_TABLE()

void AddressManagerFrame::OnAbout(wxCommandEvent& event)
{
    // save current edit cell, if neccessary
    m_pGrid->DisableCellEditControl();

    AddressManagerAboutDialog dialog(this);
    dialog.ShowModal();
}

void AddressManagerFrame::OnMenuFileNew(wxCommandEvent& event)
{
    // save current edit cell, if neccessary
    m_pGrid->DisableCellEditControl();

    if (m_dirty) {
        int result = wxMessageBox("Änderungen speichern?", "Address Manager", wxICON_QUESTION | wxYES_NO | wxCANCEL, this);
        if (result == wxCANCEL) return;
        if (result == wxYES) {
            if (!FileSaveImpl()) return;
        }
    }
    wxBusyCursor wait;
    m_pTable->Initialize();

    int width, height;
    GetSize(&width, &height);
    SetSize(width - 1, height - 1);
    SetSize(width, height);
    m_dirty = false;
}

void AddressManagerFrame::OnMenuFileOpen(wxCommandEvent& event)
{
    // save current edit cell, if neccessary
    m_pGrid->DisableCellEditControl();

    if (m_dirty) {
        int result = wxMessageBox("Änderungen speichern?", "Address Manager", wxICON_QUESTION | wxYES_NO | wxCANCEL, this);
        if (result == wxCANCEL) return;
        if (result == wxYES) {
            if (!FileSaveImpl()) return;
        }
    }
    wxFileDialog dialog(this, "Datei Öffnen", "", "", "Address Manager Dateien (*.adm)|*.adm", wxOPEN);
    if (dialog.ShowModal() == wxID_OK) {
        wxBusyCursor wait;
        m_currentFilename = dialog.GetPath();

        // open file; TODO: file locking
        wxFileInputStream fileInStream(m_currentFilename);
        wxDataInputStream in(fileInStream);

        // check if right file format and file is readable
        wxUint32 id = in.Read32();
        wxUint32 version = in.Read32();
        if (!in.IsOk() || id != g_admFileId || version > g_admFileVersion) {
            wxMessageDialog errorDialog(this, "Fehler beim Öffnen der Datei", "Address Manager", wxOK | wxICON_ERROR);
            errorDialog.ShowModal();
            return;
        }

        // read file
        bool end = false;
        while (!end) {
            wxUint32 tag = in.Read32();
            wxUint32 size = in.Read32();
            switch (tag) {
                case admTagGrid:
                    m_pTable->Initialize(in);
                    break;
                case admTagEnd:
                    end = true;
                    break;
                default:
                    fileInStream.SeekI(size, wxFromCurrent);
            }
        }

        // update view
        int width, height;
        m_dirty = false;
        GetSize(&width, &height);
        SetSize(width - 1, height - 1);
        SetSize(width, height);
        m_pGrid->SetFocus();

        // not modified
        m_dirty = false;
    }
}

void AddressManagerFrame::OnMenuFileClose(wxCommandEvent& event)
{
    // save current edit cell, if neccessary
    m_pGrid->DisableCellEditControl();
    // TODO
/*  if (m_grid) {
        delete m_grid;
        m_grid = NULL;
    }*/
}

bool AddressManagerFrame::FileSaveImpl()
{
    if (m_currentFilename.Length() == 0) {
        if (!FileSaveAsImpl()) return false;
    }
    wxBusyCursor wait;
    wxFileOutputStream fileOutStream(m_currentFilename);
    wxDataOutputStream out(fileOutStream);
    out.Write32(g_admFileId);
    out.Write32(g_admFileVersion);
    out.Write32(admTagGrid);
    out.Write32(0);
    off_t cur = fileOutStream.TellO();
    m_pTable->serialize(out);
    off_t end = fileOutStream.TellO();
    fileOutStream.SeekO(cur - 4);
    out.Write32(end - cur);
    fileOutStream.SeekO(end);
    out.Write32(admTagEnd);
    out.Write32(0);
    if (!fileOutStream.IsOk()) {
        wxMessageDialog errorDialog(this, "Fehler beim Speichern der Datei", "Address Manager", wxOK | wxICON_ERROR);
        errorDialog.ShowModal();
        return false;
    }
    m_dirty = false;
    return true;
}

void AddressManagerFrame::OnMenuFileSave(wxCommandEvent& event)
{
    // save current edit cell, if neccessary
    m_pGrid->DisableCellEditControl();

    FileSaveImpl();
}

bool AddressManagerFrame::FileSaveAsImpl()
{
    wxFileDialog dialog(this, "Datei Speichern unter", "", m_currentFilename, "Address Manager Dateien (*.adm)|*.adm", wxSAVE|wxOVERWRITE_PROMPT);
    if (dialog.ShowModal() == wxID_OK) {
        m_currentFilename = dialog.GetPath();

        // add extension, if missing (on Mac)
        size_t pos = m_currentFilename.Length() - 4;
        if (pos < 0) pos = 0;
        wxString ext = m_currentFilename.Mid(pos);
        if (ext.CmpNoCase(".adm") != 0) m_currentFilename += ".adm";

        // save file
        if (!FileSaveImpl()) return false;

        // notify that the file was saved
        return true;
    }

    // notify that the dialog was canceled
    return false;
}

void AddressManagerFrame::OnMenuFileSaveAs(wxCommandEvent& event)
{
    // save current edit cell, if neccessary
    m_pGrid->DisableCellEditControl();

    FileSaveAsImpl();
}

bool AddressManagerFrame::onExit()
{
    // save current edit cell, if neccessary
    m_pGrid->DisableCellEditControl();

    if (m_dirty) {
        int result = wxMessageBox("Änderungen speichern?", "Address Manager", wxICON_QUESTION | wxYES_NO | wxCANCEL, this);
        if (result == wxCANCEL) return false;
        if (result == wxYES) {
            if (!FileSaveImpl()) return false;
        }
    }
    return true;
}

void AddressManagerFrame::OnMenuFileExit(wxCommandEvent& event)
{
    // save current edit cell, if neccessary
    m_pGrid->DisableCellEditControl();

    if (onExit()) Close(true);
}

void AddressManagerFrame::OnMenuEditCut(wxCommandEvent& event)
{
    // save current edit cell, if neccessary
    m_pGrid->DisableCellEditControl();

    m_dirty = true;
    copy(true);
}

void AddressManagerFrame::copy(bool erase)
{
    // search first start
    int rowCount = m_pGrid->GetRows();
    int colCount = m_pGrid->GetCols();
    int startRow = -1;
    int startCol = -1;
    int row, col;
    for (row = 0; row < rowCount; row++) {
        for (col = 0; col < colCount; col++) {
            if (m_pGrid->IsInSelection(row, col)) {
                startRow = row;
                startCol = col;
                break;
            }
        }
        if (startRow != -1) break;
    }

    // search last end
    int endRow = -1;
    int endCol = -1;
    if (startRow != -1) {
        for (row = startRow; row < rowCount; row++) {
            for (col = startCol; col < colCount; col++) {
                if (m_pGrid->IsInSelection(row, col)) {
                    if (row > endRow) endRow = row;
                    if (col > endCol) endCol = col;
                }
            }
        }
    }

    // get cursor position, if no selection
    if (startRow == -1) {
        startRow = endRow = m_pGrid->GetGridCursorRow();
        startCol = endCol = m_pGrid->GetGridCursorCol();
    }

    // copy to clipboard
    wxBusyCursor wait;
    if (!wxTheClipboard->Open()) return;
    wxString text;
    bool firstRow = true;
    for (row = startRow; row <= endRow; row++) {
        if (firstRow) {
            firstRow = false;
        } else {
            text += "\n";
        }
        bool firstCol = true;
        for (col = startCol; col <= endCol; col++) {
            if (firstCol) {
                firstCol = false;
            } else {
                text += "\t";
            }
            text += m_pGrid->GetCellValue(row, col);
            if (erase) m_pGrid->SetCellValue(row, col, "");
        }
    }
    wxTheClipboard->SetData(new wxTextDataObject(text));
    wxTheClipboard->Close();
    if (erase) m_dirty = true;
}

void AddressManagerFrame::OnMenuEditCopy(wxCommandEvent& event)
{
    // save current edit cell, if neccessary
    m_pGrid->DisableCellEditControl();

    copy(false);
}

// splits a wxString into lines
// detects all possible line breaking charaters: \n, \r, \n\r or \r\n
class LineSplitter
{
public:
    LineSplitter(const wxString& text) : m_text(text), m_ofs(0)
    {
        m_len = text.Length();
    }

    bool extractNext()
    {
        if (m_ofs == m_len) return false;
        size_t end = m_ofs;
        while (end < m_len) {
            wxChar c = m_text[end];
            if (c == 10 || c == 13) {
                m_currentLine = m_text.Mid(m_ofs, end - m_ofs);
                if (end == m_len - 1) {
                    m_ofs = m_len;
                    return true;
                }
                if ((c == 10 && m_text[end + 1] == 13) ||
                    (c == 13 && m_text[end + 1] == 10))
                {
                    m_ofs = end + 2;
                    return true;
                }
                m_ofs = end + 1;
                return true;
            }
            end++;
        }
        m_currentLine = m_text.Mid(m_ofs, end - m_ofs);
        m_ofs = end;
        return true;
    }

    wxString getNext()
    {
        return m_currentLine;
    }

private:
    const wxString& m_text;
    wxString m_currentLine;
    size_t m_ofs;
    size_t m_len;
};


void AddressManagerFrame::OnMenuEditPaste(wxCommandEvent& event)
{
    // save current edit cell, if neccessary
    m_pGrid->DisableCellEditControl();

    wxBusyCursor wait;

    // search first start
    int rowCount = m_pGrid->GetRows();
    int colCount = m_pGrid->GetCols();
    int startRow = -1;
    int startCol = -1;
    int row, col;
    for (row = 0; row < rowCount; row++) {
        for (col = 0; col < colCount; col++) {
            if (m_pGrid->IsInSelection(row, col)) {
                startRow = row;
                startCol = col;
                break;
            }
        }
        if (startRow != -1) break;
    }

    // get cursor position, if no selection
    if (startRow == -1) {
        startRow = m_pGrid->GetGridCursorRow();
        startCol = m_pGrid->GetGridCursorCol();
    }

    // paste from clipboard
    if (!wxTheClipboard->Open()) return;
    if (!wxTheClipboard->IsSupported(wxDF_TEXT)) return;
    wxTextDataObject data;
    wxTheClipboard->GetData(data);
    wxString text = data.GetText();
    m_pGrid->BeginBatch();
    LineSplitter ls(text);
    while (ls.extractNext()) {
        if (startRow >= rowCount - 1) {
            m_pGrid->AppendRows(1, false);
            rowCount++;
        }
        wxString line = ls.getNext();
        unsigned lpos = 0;
        for (int col = startCol; col < colCount; col++) {
            unsigned lsearch = lpos;
            while (lsearch < line.Length()) {
                if (line[lsearch] == '\t') break;
                lsearch++;
            }
            wxString word = line.Mid(lpos, lsearch - lpos);
            m_pGrid->SetCellValue(startRow, col, word);
            lpos = lsearch;
            lpos++;
            if (lpos >= line.Length()) break;
        }
        startRow++;
    }
    m_pGrid->EndBatch();
    wxTheClipboard->Close();
    m_dirty = true;
}

bool substringMatch(const wxString& search, const wxString& value)
{
    int slen = search.Length();
    int vlen = value.Length();
    if (slen == 0 || vlen == 0) return false;

    for (int valueStart = 0; valueStart < vlen - 1; valueStart++) {
        int searchIndex = 0;
        for (int valueIndex = valueStart; valueIndex < vlen; valueIndex++) {
            if (wxTolower(search[searchIndex++]) != wxTolower(value[valueIndex])) break;
            if (searchIndex == slen) return true;
        }
    }
    return false;
}

void AddressManagerFrame::OnMenuEditFind(wxCommandEvent& event)
{
    // save current edit cell, if neccessary
    m_pGrid->DisableCellEditControl();

    // get search text
    wxTextEntryDialog dialog(this, "Suchen nach:", "Address Manager", m_lastSearchString, wxOK | wxCANCEL);
    if (dialog.ShowModal() != wxID_OK) return;
    m_lastSearchString = dialog.GetValue();

    // calulate next column to start from
    int row = m_pGrid->GetGridCursorRow();
    int rowCount = m_pGrid->GetRows();
    int colCount = m_pGrid->GetCols();
    int col = m_pGrid->GetGridCursorCol() + 1;
    if (col == colCount) {
        col = 0;
        row++;
        if (row == rowCount) row = 0;
    }

    // search
    for (; row < rowCount; row++) {
        for (; col < colCount; col++) {
            if (substringMatch(m_lastSearchString, m_pGrid->GetCellValue(row, col))) {
                m_pGrid->SetGridCursor(row, col);
                m_pGrid->MakeCellVisible(row, col);
                return;
            }
        }
        col = 0;
    }

    // if not found, search from start
    for (row = 0; row < rowCount; row++) {
        for (col = 0; col < colCount; col++) {
            if (substringMatch(m_lastSearchString, m_pGrid->GetCellValue(row, col))) {
                m_pGrid->SetGridCursor(row, col);
                m_pGrid->MakeCellVisible(row, col);
                return;
            }
        }
    }
}

void AddressManagerFrame::OnMenuTableDoublet(wxCommandEvent& event)
{
    // save current edit cell, if neccessary
    m_pGrid->DisableCellEditControl();

    unsigned rowCount = m_pGrid->GetRows();
    unsigned colCount = m_pGrid->GetCols();
    if (rowCount < 2) return;

    // get eMail index
    unsigned col;
    bool found = false;
    for (col = 0; col < colCount; col++) {
        wxString label = m_pGrid->GetColLabelValue(col);
        if (label.CmpNoCase("email") == 0) {
            found = true;
            break;
        }
    }
    if (!found) {
        wxMessageDialog errorDialog(this, "Doublettenableich nicht möglich, da es keine eMail-Tabellenspalte gibt.", "Address Manager", wxOK | wxICON_INFORMATION);
        errorDialog.ShowModal();
        return;
    }

    // get row to start from
    unsigned row = m_pGrid->GetGridCursorRow();

    // search
    for (; row < rowCount - 1; row++) {
        wxString value = m_pGrid->GetCellValue(row, col);
        if (value.Length() > 0 && value.CmpNoCase(m_pGrid->GetCellValue(row + 1, col)) == 0) {
            m_pGrid->SetGridCursor(row + 1, col);
            m_pGrid->MakeCellVisible(row + 1, col);
            m_pGrid->SelectBlock(row, 0, row + 1, colCount);
            return;
        }
    }

    // if not found, search from start
    for (row = 0; row < rowCount - 1; row++) {
        wxString value = m_pGrid->GetCellValue(row, col);
        if (value.Length() > 0 && value.CmpNoCase(m_pGrid->GetCellValue(row + 1, col)) == 0) {
            m_pGrid->SetGridCursor(row + 1, col);
            m_pGrid->MakeCellVisible(row + 1, col);
            m_pGrid->SelectBlock(row, 0, row + 1, colCount);
            return;
        }
    }
}

void AddressManagerFrame::OnMenuTableSort(wxCommandEvent& event)
{
    // save current edit cell, if neccessary
    m_pGrid->DisableCellEditControl();

    // copy column names
    ColumnFieldArray columns;
    columns.Add(NullColumnField());
    unsigned i = 0;
    for (i = 0; i < (unsigned) m_pGrid->GetCols(); i++) {
        columns.Add(ColumnField(m_pGrid->GetColLabelValue(i), i));
    }

    // ask user for sort order
    SortDialog dialog(this, columns);
    if (dialog.ShowModal() != wxID_OK) return;

    // get sort order
    wxBusyCursor wait;
    columns = dialog.getSortOrder();
    wxASSERT(columns.GetCount() > 0);
    int sortCol1 = -1;
    int sortCol2 = -1;
    int sortCol3 = -1;
    if (columns.GetCount() >= 1) sortCol1 = columns[0].getOldIndex();
    if (columns.GetCount() >= 2) sortCol2 = columns[1].getOldIndex();
    if (columns.GetCount() == 3) sortCol3 = columns[2].getOldIndex();
    m_pTable->Sort(sortCol1, sortCol2, sortCol3);

    m_dirty = true;

    int width, height;
    GetSize(&width, &height);
    SetSize(width - 1, height - 1);
    SetSize(width, height);
}

void AddressManagerFrame::OnMenuTableConfig(wxCommandEvent& event)
{
    // save current edit cell, if neccessary
    m_pGrid->DisableCellEditControl();

    // copy column names
    ColumnFieldArray columns;
    unsigned i = 0;
    for (i = 0; i < (unsigned) m_pGrid->GetCols(); i++) {
        columns.Add(ColumnField(m_pGrid->GetColLabelValue(i), i, m_pGrid->GetColumnWidth(i)));
    }

    // edit
    ColumnDialog dialog(this, columns);
    if (dialog.ShowModal() != wxID_OK) return;

    // get all columns, which are not deleted
    wxBusyCursor wait;
    columns = dialog.getNewColumns();

    // copy in new grid
    m_pTable->ChangeColumns(columns);

    m_dirty = true;

    int width, height;
    GetSize(&width, &height);
    SetSize(width - 1, height - 1);
    SetSize(width, height);
}

void AddressManagerFrame::OnMenuExportEmail(wxCommandEvent& event)
{
    // save current edit cell, if neccessary
    m_pGrid->DisableCellEditControl();

    unsigned rowCount = m_pGrid->GetRows();
    unsigned colCount = m_pGrid->GetCols();
    if (rowCount < 1) return;

    // get eMail index
    unsigned col;
    bool found = false;
    for (col = 0; col < colCount; col++) {
        wxString label = m_pGrid->GetColLabelValue(col);
        if (label.CmpNoCase("email") == 0) {
            found = true;
            break;
        }
    }
    if (!found) {
        wxMessageDialog errorDialog(this, "eMail-Export nicht möglich, da es keine eMail-Tabellenspalte gibt.", "Address Manager", wxOK | wxICON_INFORMATION);
        errorDialog.ShowModal();
        return;
    }

    // init array for testing for valid email characters
    bool validChars[256];
    unsigned i;
    for (i = 0; i <= 255; i++) validChars[i] = false;
    for (i = 'a'; i <= 'z'; i++) validChars[i] = true;
    for (i = 'A'; i <= 'Z'; i++) validChars[i] = true;
    for (i = '0'; i <= '9'; i++) validChars[i] = true;
    validChars['@'] = true;
    validChars['.'] = true;
    validChars['_'] = true;
    validChars['-'] = true;
    validChars['~'] = true;

    // open export file
#if defined(__WXMSW__)
    wxFileOutputStream fileOutStream("c:\\email-liste.txt");
#else
    wxFileOutputStream fileOutStream("Macintosh HD:email-liste.txt");
#endif
    wxTextOutputStream ostr(fileOutStream);

    // export
    int count = 0;
    for (unsigned row = 0; row < rowCount; row++) {
        wxString email = m_pGrid->GetCellValue(row, col);
        email.Trim(true);
        email.Trim(false);

        // check for valid emails
        unsigned atcount = 0;
        unsigned atposition = 0;
        if (email.Length() < 3) continue;
        for (unsigned i = 0; i < email.Length(); i++) {
            wxChar c = email[i];
            if (!validChars[c]) continue;
            if (c == '@') {
                atcount++;
                atposition = i;
                if (atcount > 1) continue;
            }
        }
        if (atcount != 1) continue;
        if (atposition == 0 || atposition == email.Length() - 1) continue;

        // write email
        ostr << "\t\t" << email << "\n";
        count++;
    }

    // show number of exported emails
    wxString msg;
    msg << "Es wurden " << count << " eMails exportiert.";
    wxMessageBox(msg, "Address Manager", wxICON_INFORMATION | wxOK, this);
}

void AddressManagerFrame::OnMenuExportSMS(wxCommandEvent& event)
{
    // save current edit cell, if neccessary
    m_pGrid->DisableCellEditControl();

    wxMessageBox("Noch nicht implementiert.", "Address Manager", wxICON_INFORMATION | wxOK, this);
}

void AddressManagerFrame::OnMenuExportFax(wxCommandEvent& event)
{
    // save current edit cell, if neccessary
    m_pGrid->DisableCellEditControl();

    wxMessageBox("Noch nicht implementiert.", "Address Manager", wxICON_INFORMATION | wxOK, this);
}

// Ensure that the grid's edit control always has the focus.
void AddressManagerFrame::OnActivate(wxActivateEvent& event)
{
    if (m_pGrid) m_pGrid->OnActivate(event.GetActive());
}

// hack: enable scrollbars, if neccessary
void AddressManagerFrame::OnSize( wxSizeEvent &event )
{
    wxFrame::OnSize(event);
    if (m_pGrid) {
        m_pGrid->UpdateDimensions();
        m_pGrid->Refresh();
    }
}


void AddressManagerFrame::OnClose(wxCloseEvent& event)
{
    // save current edit cell, if neccessary
    m_pGrid->DisableCellEditControl();

    // avoid if we can
    if (event.CanVeto()) {
        if (!onExit()) {
            event.Veto();
        } else {
            Destroy();
        }
    } else {
        Destroy();
    }
}

void AddressManagerFrame::setDirty()
{
    m_dirty = true;
}

---