---

AddressGridTable.cpp

/*
 * Purpose: Serializable wxGridTable
 * Author:  Frank Buß
 * Created: 2002
 */

#include "AddressGridTable.h"

#include "wx/arrimpl.cpp"
WX_DEFINE_OBJARRAY(StringArray);
WX_DEFINE_OBJARRAY(StringGrid);


void wxGridTableBaseWithNotifyMethods::RequestViewGetValues()
{
    wxGrid* pView = GetView();
    if (pView) {
        wxGridTableMessage msg(this, wxGRIDTABLE_REQUEST_VIEW_GET_VALUES);
        pView->ProcessTableMessage(msg);
    }
}

void wxGridTableBaseWithNotifyMethods::RequestViewSendValues()
{
    wxGrid* pView = GetView();
    if (pView) {
        wxGridTableMessage msg(this, wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES);
        pView->ProcessTableMessage(msg);
    }
}

void wxGridTableBaseWithNotifyMethods::NotifyRowsInserted(int pos, int numRows)
{
    wxGrid* pView = GetView();
    if (pView) {
        wxGridTableMessage msg(this, wxGRIDTABLE_NOTIFY_ROWS_INSERTED, pos, numRows);
        pView->ProcessTableMessage(msg);
    }
}

void wxGridTableBaseWithNotifyMethods::NotifyRowsAppended(int numRows)
{
    wxGrid* pView = GetView();
    if (pView) {
        wxGridTableMessage msg(this, wxGRIDTABLE_NOTIFY_ROWS_APPENDED, numRows);
        pView->ProcessTableMessage(msg);
    }
}

void wxGridTableBaseWithNotifyMethods::NotifyRowsDeleted(int pos, int numRows)
{
    wxGrid* pView = GetView();
    if (pView) {
        wxGridTableMessage msg(this, wxGRIDTABLE_NOTIFY_ROWS_DELETED, pos, numRows);
        pView->ProcessTableMessage(msg);
    }
}

void wxGridTableBaseWithNotifyMethods::NotifyColsInserted(int pos, int numCols)
{
    wxGrid* pView = GetView();
    if (pView) {
        wxGridTableMessage msg(this, wxGRIDTABLE_NOTIFY_COLS_INSERTED, pos, numCols);
        pView->ProcessTableMessage(msg);
    }
}

void wxGridTableBaseWithNotifyMethods::NotifyColsAppended(int numCols)
{
    wxGrid* pView = GetView();
    if (pView) {
        wxGridTableMessage msg(this, wxGRIDTABLE_NOTIFY_COLS_APPENDED, numCols);
        pView->ProcessTableMessage(msg);
    }
}

void wxGridTableBaseWithNotifyMethods::NotifyColsDeleted(int pos, int numCols)
{
    wxGrid* pView = GetView();
    if (pView) {
        wxGridTableMessage msg(this, wxGRIDTABLE_NOTIFY_COLS_DELETED, pos, numCols);
        pView->ProcessTableMessage(msg);
    }
}


//
// A basic grid table for string data. An object of this class will
// created by wxGrid if you don't specify an alternative table class.
//

//WX_DEFINE_OBJARRAY(StringGrid)

bool isEmpty(StringArray& row, size_t cols)
{
    for (size_t j = 0; j < cols; j++) if (row[j].Length()) return false;
    return true;
}

void AddressGridTable::serialize(wxDataOutputStream& out)
{
    // get number of cols and rows
    size_t cols = GetNumberCols();
    size_t rows = GetNumberRows();

    // count number of rows, where at least one cell has text
    size_t textRows = 0;
    size_t i;
    for (i = 0; i < rows; i++) {
        if (!isEmpty(m_data[i], cols)) textRows++;
    }

    // write number of cols and rows
    out.Write32(cols);
    out.Write32(textRows);

    // write column info
    wxGrid* pView = GetView();
    for (i = 0; i < cols; i++) {
        out.WriteString(GetColLabelValue(i));
        out.Write32(pView->GetColumnWidth(i));
    }

    // write all columns, where at least one cell has text
    for (i = 0; i < rows; i++) {
        if (!isEmpty(m_data[i], cols)) {
            for (size_t j = 0; j < cols; j++) out.WriteString(m_data[i][j]);
        }
    }
}

int AddressGridTable::GetNumberRows()
{
    return m_data.GetCount();
}

int AddressGridTable::GetNumberCols()
{
    return m_colLabels.GetCount();
}

wxString AddressGridTable::GetValue( int row, int col )
{
    wxASSERT_MSG( (row < GetNumberRows()) && (col < GetNumberCols()),
                  _T("invalid row or column index in AddressGridTable") );

    return m_data[row][col];
}

void AddressGridTable::SetValue( int row, int col, const wxString& value )
{
    wxASSERT_MSG( (row < GetNumberRows()) && (col < GetNumberCols()),
                  _T("invalid row or column index in AddressGridTable") );

    m_data[row][col] = value;
}

bool AddressGridTable::IsEmptyCell( int row, int col )
{
    wxASSERT_MSG( (row < GetNumberRows()) && (col < GetNumberCols()),
                  _T("invalid row or column index in AddressGridTable") );

    return (m_data[row][col] == wxEmptyString);
}

void AddressGridTable::Clear()
{
    int row, col;
    int numRows, numCols;

    numRows = m_data.GetCount();
    if ( numRows > 0 )
    {
        numCols = m_data[0].GetCount();

        for ( row = 0;  row < numRows;  row++ )
        {
            for ( col = 0;  col < numCols;  col++ )
            {
                m_data[row][col] = wxEmptyString;
            }
        }
    }
}


bool AddressGridTable::InsertRows( size_t pos, size_t numRows )
{
    size_t row, col;

    size_t curNumRows = m_data.GetCount();
    size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
                          ( GetView() ? GetView()->GetNumberCols() : 0 ) );

    if ( pos >= curNumRows )
    {
        return AppendRows( numRows );
    }

    StringArray sa;
    sa.Alloc( curNumCols );
    for ( col = 0;  col < curNumCols;  col++ )
    {
        sa.Add( wxEmptyString );
    }

    for ( row = pos;  row < pos + numRows;  row++ )
    {
        m_data.Insert( sa, row );
    }
    NotifyRowsInserted(pos, numRows);

    return TRUE;
}

bool AddressGridTable::AppendRows( size_t numRows )
{
    size_t row, col;

    size_t curNumRows = m_data.GetCount();
    size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
                          ( GetView() ? GetView()->GetNumberCols() : 0 ) );

    StringArray sa;
    if ( curNumCols > 0 )
    {
        sa.Alloc( curNumCols );
        for ( col = 0;  col < curNumCols;  col++ )
        {
            sa.Add( wxEmptyString );
        }
    }

    for ( row = 0;  row < numRows;  row++ )
    {
        m_data.Add( sa );
    }
    NotifyRowsAppended(numRows);

    return TRUE;
}

bool AddressGridTable::DeleteRows( size_t pos, size_t numRows )
{
    size_t n;

    size_t curNumRows = m_data.GetCount();

    if ( pos >= curNumRows )
    {
        wxString errmsg;
        errmsg.Printf(wxT("Called AddressGridTable::DeleteRows(pos=%d, N=%d)\nPos value is invalid for present table with %d rows"),
                      pos, numRows, curNumRows );
        wxFAIL_MSG( errmsg );
        return FALSE;
    }

    if ( numRows > curNumRows - pos )
    {
        numRows = curNumRows - pos;
    }

    if ( numRows >= curNumRows )
    {
        m_data.Empty();  // don't release memory just yet
    }
    else
    {
        for ( n = 0;  n < numRows;  n++ )
        {
            m_data.RemoveAt( pos );
        }
    }
    NotifyRowsDeleted(pos, numRows);

    return TRUE;
}

bool AddressGridTable::InsertCols( size_t pos, size_t numCols )
{
    size_t row, col;

    size_t curNumRows = m_data.GetCount();
    size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
                          ( GetView() ? GetView()->GetNumberCols() : 0 ) );

    if ( pos >= curNumCols )
    {
        return AppendCols( numCols );
    }

    for ( row = 0;  row < curNumRows;  row++ )
    {
        for ( col = pos;  col < pos + numCols;  col++ )
        {
            m_data[row].Insert( wxEmptyString, col );
        }
    }
    NotifyColsInserted(pos, numCols);

    return TRUE;
}

bool AddressGridTable::AppendCols( size_t numCols )
{
    size_t row, n;

    size_t curNumRows = m_data.GetCount();

    for ( row = 0;  row < curNumRows;  row++ )
    {
        for ( n = 0;  n < numCols;  n++ )
        {
            m_data[row].Add( wxEmptyString );
        }
    }
    NotifyColsAppended(numCols);

    return TRUE;
}

bool AddressGridTable::DeleteCols( size_t pos, size_t numCols )
{
    size_t row, n;

    size_t curNumRows = m_data.GetCount();
    size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
                          ( GetView() ? GetView()->GetNumberCols() : 0 ) );

    if ( pos >= curNumCols )
    {
        wxString errmsg;
        errmsg.Printf( wxT("Called AddressGridTable::DeleteCols(pos=%d, N=%d)...\nPos value is invalid for present table with %d cols"),
                        pos, numCols, curNumCols );
        wxFAIL_MSG( errmsg );
        return FALSE;
    }

    if ( numCols > curNumCols - pos )
    {
        numCols = curNumCols - pos;
    }

    for ( row = 0;  row < curNumRows;  row++ )
    {
        if ( numCols >= curNumCols )
        {
            m_data[row].Clear();
        }
        else
        {
            for ( n = 0;  n < numCols;  n++ )
            {
                m_data[row].RemoveAt( pos );
            }
        }
    }
    NotifyColsDeleted(pos, numCols);

    return TRUE;
}

wxString AddressGridTable::GetColLabelValue( int col )
{
    if ( col > (int)(m_colLabels.GetCount()) - 1 )
    {
        // using default label
        //
        return wxGridTableBase::GetColLabelValue( col );
    }
    else
    {
        return m_colLabels[ col ];
    }
}

void AddressGridTable::SetColLabelValue( int col, const wxString& value )
{
    if ( col > (int)(m_colLabels.GetCount()) - 1 )
    {
        int n = m_colLabels.GetCount();
        int i;
        for ( i = n;  i <= col;  i++ )
        {
            m_colLabels.Add( wxGridTableBase::GetColLabelValue(i) );
        }
    }

    m_colLabels[col] = value;
}

void AddressGridTable::ClearAll()
{
    int rows = m_data.GetCount();
    m_data = StringGrid();
    NotifyRowsDeleted(0, rows);

    int cols = m_colLabels.GetCount();
    m_colLabels = StringArray();
    NotifyColsDeleted(0, cols);
}

void AddressGridTable::Initialize()
{
    ClearAll();
    m_colLabels.Add("eMail");
    m_colLabels.Add("Handy");
    m_colLabels.Add("SMS-Export");
    m_colLabels.Add("Fax");
    StringArray empty;
    empty.Add(wxEmptyString);
    empty.Add(wxEmptyString);
    empty.Add(wxEmptyString);
    empty.Add(wxEmptyString);
    m_data.Add(empty);
    NotifyColsAppended(4);
    NotifyRowsAppended(1);
}


void AddressGridTable::Initialize(wxDataInputStream& in)
{
    ClearAll();

    // read number of cols and rows
    size_t cols = in.Read32();
    size_t rows = in.Read32();

    // add columns for setting the column labels
    NotifyColsAppended(cols);

    // read column labels and widths
    size_t i;
    wxGrid* pView = GetView();
    for (i = 0; i < cols; i++) {
        m_colLabels.Add(in.ReadString());
        pView->SetColumnWidth(i, in.Read32());
    }

    // read rows
    m_data.Alloc(rows + 1);
    for (i = 0; i < rows; i++) {
        StringArray row;
        row.Alloc(cols);
        for (size_t j = 0; j < cols; j++) {
            row.Add(in.ReadString());
        }
        m_data.Add(row);
    }

    // add empty row
    StringArray empty;
    empty.Alloc(cols);
    for (i = 0; i < cols; i++) empty.Add(wxEmptyString);
    m_data.Add(empty);

    // tell the view how many rows were added
    NotifyRowsAppended(rows + 1);
}


int gSortCol1;
int gSortCol2;
int gSortCol3;
StringGrid* gSortGrid;
wxUint32* gSortArray;

int compare(const void *arg1, const void *arg2)
{
    wxUint32 index1 = *((wxUint32*)arg1);
    wxUint32 index2 = *((wxUint32*)arg2);
    wxString& value1 = (*gSortGrid)[index1][gSortCol1];
    wxString& value2 = (*gSortGrid)[index2][gSortCol1];
    if (value1.Length() == 0) return 1;
    if (value2.Length() == 0) return -1;
    int cmp = value1.CmpNoCase(value2);
    if (cmp != 0) return cmp;
    if (gSortCol2 < 0) return cmp;
    wxString& value3 = (*gSortGrid)[index1][gSortCol2];
    wxString& value4 = (*gSortGrid)[index2][gSortCol2];
    if (value3.Length() == 0) return 1;
    if (value4.Length() == 0) return -1;
    cmp = value3.CmpNoCase(value4);
    if (cmp != 0) return cmp;
    if (gSortCol3 < 0) return cmp;
    wxString& value5 = (*gSortGrid)[index1][gSortCol3];
    wxString& value6 = (*gSortGrid)[index2][gSortCol3];
    if (value5.Length() == 0) return 1;
    if (value6.Length() == 0) return -1;
    return value5.CmpNoCase(value6);
}

void AddressGridTable::Sort(int col1, int col2, int col3)
{
    gSortCol1 = col1;
    gSortCol2 = col2;
    gSortCol3 = col3;

    // create index array for sorting
    unsigned rowCount = GetNumberRows();
    gSortArray = new wxUint32[rowCount];
    size_t i;
    for (i = 0; i < rowCount; i++) gSortArray[i] = i;

    // sort array
    gSortGrid = &m_data;
    qsort((void *)gSortArray, rowCount, sizeof(wxUint32), compare);

    // copy in new grid
    unsigned colCount = GetNumberCols();
    unsigned newCount = 0;
    StringGrid newGrid = StringGrid();
    newGrid.Alloc(rowCount);
    for (i = 0; i < rowCount; i++)
    {
        unsigned len = 0;
        for (unsigned j = 0; j < colCount; j++) {
            wxString& value = m_data[gSortArray[i]][j];
            len += value.Length();
        }
        if (len > 0) {
            newGrid.Add(m_data[gSortArray[i]]);
            newCount++;
        }
    }
    delete [] gSortArray;

    // set new grid
    m_data = newGrid;

    // update view
    NotifyRowsDeleted(0, rowCount);
    NotifyRowsAppended(newCount);
}


void AddressGridTable::ChangeColumns(ColumnFieldArray& columns)
{
    // get number of cols and rows
    size_t cols = columns.GetCount();
    size_t rows = GetNumberRows();

    // create new empty data grid
    StringGrid newGrid = StringGrid();
    StringArray newColLabels;
    newGrid.Alloc(rows);
    StringArray empty;
    empty.Alloc(cols);
    size_t i;
    for (i = 0; i < cols; i++) empty.Add(wxEmptyString);
    for (i = 0; i < rows; i++) newGrid.Add(empty);

    // fill with old values
    for (i = 0; i < cols; i++)
    {
        // create new column
        int oldIndex = columns[i].getOldIndex();
        newColLabels.Add(columns[i].getName());

        // copy old values, if it is not a new column
        if (!columns[i].isNew()) {
            for (size_t j = 0; j < rows; j++) {
                newGrid[j][i] = m_data[j][oldIndex];
            }
        }
    }

    // set new grid
    ClearAll();
    m_data = newGrid;
    m_colLabels = newColLabels;

    // update view
    NotifyColsAppended(cols);
    NotifyRowsAppended(rows);

    // restore old column widths
    wxGrid* pView = GetView();
    for (i = 0; i < cols; i++)
    {
        if (!columns[i].isNew()) {
            pView->SetColumnWidth(i, columns[i].getOldWidth());
        }
    }
}

---