ctableview.cpp

Gambas is a graphical development environment based on a Basic interpreter, like Visual Basic. It us

  int ypos = VARG(ypos);

  ypos = ypos + WIDGET->contentsY();

  if (!WIDGET->horizontalHeader()->isHidden())
    ypos = ypos - WIDGET->horizontalHeader()->height();

  GB.ReturnInteger(WIDGET->rowAt(ypos));

END_PROPERTY

BEGIN_METHOD(CTABLEVIEW_column_at, GB_INTEGER xpos)

  int xpos = VARG(xpos);

  xpos = xpos + WIDGET->contentsX();

  if (!WIDGET->verticalHeader()->isHidden())
    xpos = xpos - WIDGET->verticalHeader()->width();

  GB.ReturnInteger(WIDGET->columnAt(xpos));

END_PROPERTY



#if 0
BEGIN_PROPERTY(CTABLEVIEW_table)

  if (READ_PROPERTY)
    GB.ReturnNewZeroString(TO_UTF8(WIDGET->definition()));
  else
    WIDGET->setDefinition(QSTRING_PROP());

END_PROPERTY
#endif


/***************************************************************************

  TableViewItem

***************************************************************************/


BEGIN_PROPERTY(CTABLEITEM_x)

  GB.ReturnInteger(WIDGET->columnPos(THIS->col) - WIDGET->contentsX() + WIDGET->clipper()->x());

END_PROPERTY


BEGIN_PROPERTY(CTABLEITEM_y)

  /*
  int p;

  p = WIDGET->rowPos(THIS->row) - WIDGET->contentsY() + WIDGET->frameWidth();
  if (!WIDGET->horizontalHeader()->isHidden())
    p += WIDGET->horizontalHeader()->height();

  GB.ReturnInteger(p);
  */

  GB.ReturnInteger(WIDGET->rowPos(THIS->row) - WIDGET->contentsY() + WIDGET->clipper()->y());

END_PROPERTY


BEGIN_PROPERTY(CTABLEITEM_width)

  GB.ReturnInteger(WIDGET->columnWidth(THIS->col) - 1);

END_PROPERTY


BEGIN_PROPERTY(CTABLEITEM_height)

  GB.ReturnInteger(WIDGET->rowHeight(THIS->row) - 1);

END_PROPERTY

#define CHECK_ITEM() \
  if (!ITEM) \
  { \
    GB.Error("No current item"); \
    return; \
  }

BEGIN_PROPERTY(CTABLEITEM_text)

  CHECK_ITEM();

  GB.ReturnNewZeroString(TO_UTF8(ITEM->text()));

END_PROPERTY


BEGIN_PROPERTY(CTABLEITEM_alignment)

  CHECK_ITEM();

  GB.ReturnInteger(ITEM->alignment());

END_PROPERTY


BEGIN_PROPERTY(CTABLEITEM_picture)

  CHECK_ITEM();

  GB.ReturnObject(THIS->picture);

END_PROPERTY


BEGIN_METHOD_VOID(CTABLEITEM_ensure_visible)

  WIDGET->ensureCellVisible(THIS->row, THIS->col);

END_METHOD


BEGIN_METHOD_VOID(CTABLEITEM_refresh)

  WIDGET->item()->setRow(-1);
  WIDGET->item()->setCol(-1);
  WIDGET->updateCell(THIS->row, THIS->col);

END_METHOD


/***************************************************************************

  TableViewData

***************************************************************************/

BEGIN_PROPERTY(CTABLEVIEW_data_text)

  if (READ_PROPERTY)
    GB.ReturnNewZeroString(TO_UTF8(WIDGET->item()->text()));
  else
    WIDGET->item()->setText(QSTRING_PROP());

END_PROPERTY


BEGIN_PROPERTY(CTABLEVIEW_data_picture)

  if (READ_PROPERTY)
    GB.ReturnObject(THIS->picture);
  else
  {
    GB.StoreObject(PROP(GB_OBJECT), &THIS->picture);
    WIDGET->item()->setPicture(PROP(GB_OBJECT));
  }

END_PROPERTY


BEGIN_PROPERTY(CTABLEVIEW_data_alignment)

  if (READ_PROPERTY)
    GB.ReturnInteger(WIDGET->item()->alignment());
  else
    WIDGET->item()->setAlignment(VPROP(GB_INTEGER));

END_PROPERTY


BEGIN_PROPERTY(CTABLEVIEW_data_background)

  if (READ_PROPERTY)
    GB.ReturnInteger(WIDGET->item()->background());
  else
    WIDGET->item()->setBackground(VPROP(GB_INTEGER) & 0xFFFFFF);

END_PROPERTY


BEGIN_PROPERTY(CTABLEVIEW_data_foreground)

  if (READ_PROPERTY)
    GB.ReturnInteger(WIDGET->item()->foreground());
  else
    WIDGET->item()->setForeground(VPROP(GB_INTEGER) & 0xFFFFFF);

END_PROPERTY


/***************************************************************************

  TableViewRows

***************************************************************************/

BEGIN_METHOD(CTABLEROWS_get, GB_INTEGER row)

  CTableView::checkRow(WIDGET, VARG(row));
  THIS->row = VARG(row);

  RETURN_SELF();

END_METHOD


BEGIN_PROPERTY(CTABLEROWS_count)

  if (READ_PROPERTY)
    GB.ReturnInteger(WIDGET->numRows());
  else
  {
    WIDGET->setNumRows(VPROP(GB_INTEGER));
    //CTableView::fillItems(WIDGET);
  }

END_PROPERTY


BEGIN_PROPERTY(CTABLEROWS_height)

  long row = THIS->row;

  if (READ_PROPERTY)
  {
    if (row < 0)
      row = 0;

    GB.ReturnInteger(WIDGET->rowHeight(row));
  }
  else
  {
    if (row < 0)
    {
      for (row = 0; row < WIDGET->numRows() - 1; row++)
        WIDGET->setRowHeight(row, VPROP(GB_INTEGER));
    }
    else
      WIDGET->setRowHeight(row, VPROP(GB_INTEGER));
  }

END_PROPERTY


BEGIN_PROPERTY(CTABLEROWS_width)

  if (WIDGET->verticalHeader()->isHidden())
    GB.ReturnInteger(0);
  else
    GB.ReturnInteger(WIDGET->verticalHeader()->width());

END_PROPERTY


BEGIN_PROPERTY(CTABLEROWS_resizable)

  if (READ_PROPERTY)
    GB.ReturnBoolean(WIDGET->verticalHeader()->isResizeEnabled());
  else
    WIDGET->verticalHeader()->setResizeEnabled(VPROP(GB_BOOLEAN));

END_PROPERTY


BEGIN_PROPERTY(CTABLEROWS_moveable)

  if (READ_PROPERTY)
    GB.ReturnBoolean(WIDGET->verticalHeader()->isMovingEnabled());
  else
    WIDGET->verticalHeader()->setMovingEnabled(VPROP(GB_BOOLEAN));

END_PROPERTY


BEGIN_PROPERTY(CTABLEROWS_text)

  if (READ_PROPERTY)
    GB.ReturnNewZeroString(TO_UTF8(WIDGET->verticalHeader()->label(THIS->row)));
  else
    WIDGET->verticalHeader()->setLabel(THIS->row, QSTRING_PROP());

END_PROPERTY


BEGIN_METHOD_VOID(CTABLEROWS_refresh)

  WIDGET->updateRow(THIS->row);

END_METHOD


BEGIN_METHOD_VOID(CTABLEROWS_selected)

  GB.ReturnBoolean(WIDGET->isRowSelected(THIS->row, true));

END_METHOD


/***************************************************************************

  TableViewCols

***************************************************************************/

BEGIN_METHOD(CTABLECOLS_get, GB_INTEGER col)

  CTableView::checkCol(WIDGET, VARG(col));
  THIS->col = VARG(col);

  RETURN_SELF();

END_METHOD


BEGIN_PROPERTY(CTABLECOLS_count)

  if (READ_PROPERTY)
    GB.ReturnInteger(WIDGET->numCols());
  else
  {
    WIDGET->setNumCols(VPROP(GB_INTEGER));
    //CTableView::fillItems(WIDGET);
  }

END_PROPERTY


BEGIN_PROPERTY(CTABLECOLS_width)

  long col = THIS->col;

  if (READ_PROPERTY)
  {
    if (col < 0)
      col = 0;

    GB.ReturnInteger(WIDGET->columnWidth(col));
  }
  else
  {
    if (col < 0)
    {
      for (col = 0; col < WIDGET->numCols() - 1; col++)
        WIDGET->setColumnWidth(col, VPROP(GB_INTEGER));
    }
    else
      WIDGET->setColumnWidth(col, VPROP(GB_INTEGER));
  }

END_PROPERTY


BEGIN_PROPERTY(CTABLECOLS_height)

  if (WIDGET->horizontalHeader()->isHidden())
    GB.ReturnInteger(0);
  else
    GB.ReturnInteger(WIDGET->horizontalHeader()->height());

END_PROPERTY


BEGIN_PROPERTY(CTABLECOLS_resizable)

  if (READ_PROPERTY)
    GB.ReturnBoolean(WIDGET->horizontalHeader()->isResizeEnabled());
  else
    WIDGET->horizontalHeader()->setResizeEnabled(VPROP(GB_BOOLEAN));

END_PROPERTY


BEGIN_PROPERTY(CTABLECOLS_moveable)

  if (READ_PROPERTY)
    GB.ReturnBoolean(WIDGET->horizontalHeader()->isMovingEnabled());
  else
    WIDGET->horizontalHeader()->setMovingEnabled(VPROP(GB_BOOLEAN));

END_PROPERTY


BEGIN_PROPERTY(CTABLECOLS_text)

  if (READ_PROPERTY)
    GB.ReturnNewZeroString(TO_UTF8(WIDGET->horizontalHeader()->label(THIS->col)));
  else
    WIDGET->horizontalHeader()->setLabel(THIS->col, QSTRING_PROP());

END_PROPERTY


BEGIN_METHOD_VOID(CTABLECOLS_refresh)

  WIDGET->updateColumn(THIS->col);

END_METHOD

/***************************************************************************

  Descriptions

***************************************************************************/

GB_DESC CTableViewDataDesc[] =
{
  GB_DECLARE(".TableViewData", 0), GB_VIRTUAL_CLASS(),

  //GB_PROPERTY_READ("Row", "i", CTABLEITEM_row),
  //GB_PROPERTY_READ("Column", "i", CTABLEITEM_column),

  //GB_PROPERTY("Picture", "Picture", CTABLEITEM_picture),
  //GB_PROPERTY("Text", "s", CTABLEITEM_text),
  //GB_PROPERTY("Alignment", "i", CTABLEITEM_alignment),

  GB_PROPERTY("Text", "s", CTABLEVIEW_data_text),
  GB_PROPERTY("Picture", "Picture", CTABLEVIEW_data_picture),
  GB_PROPERTY("Alignment", "i", CTABLEVIEW_data_alignment),
  GB_PROPERTY("Background", "i", CTABLEVIEW_data_background),
  GB_PROPERTY("BackColor", "i", CTABLEVIEW_data_background),
  GB_PROPERTY("Foreground", "i", CTABLEVIEW_data_foreground),
  GB_PROPERTY("ForeColor", "i", CTABLEVIEW_data_foreground),

  GB_END_DECLARE
};

GB_DESC CTableItemDesc[] =
{
  GB_DECLARE(".TableViewCell", 0), GB_VIRTUAL_CLASS(),

  //GB_PROPERTY_READ("Row", "i", CTABLEITEM_row),
  //GB_PROPERTY_READ("Column", "i", CTABLEITEM_column),

  GB_PROPERTY_READ("Picture", "Picture", CTABLEITEM_picture),
  GB_PROPERTY_READ("Text", "s", CTABLEITEM_text),
  GB_PROPERTY_READ("Alignment", "i", CTABLEITEM_alignment),

  GB_PROPERTY_READ("X", "i", CTABLEITEM_x),
  GB_PROPERTY_READ("Y", "i", CTABLEITEM_y),
  GB_PROPERTY_READ("Left", "i", CTABLEITEM_x),
  GB_PROPERTY_READ("Top", "i", CTABLEITEM_y),
  GB_PROPERTY_READ("Width", "i", CTABLEITEM_width),
  GB_PROPERTY_READ("Height", "i", CTABLEITEM_height),
  GB_PROPERTY_READ("W", "i", CTABLEITEM_width),
  GB_PROPERTY_READ("H", "i", CTABLEITEM_height),

  //GB_METHOD("Clear", NULL, CTABLEITEM_clear, NULL),
  GB_METHOD("EnsureVisible", NULL, CTABLEITEM_ensure_visible, NULL),
  GB_METHOD("Refresh", NULL, CTABLEITEM_refresh, NULL),

  GB_END_DECLARE
};


GB_DESC CTableRowDesc[] =
{
  GB_DECLARE(".TableViewRow", 0), GB_VIRTUAL_CLASS(),

  GB_PROPERTY("Height", "i", CTABLEROWS_height),
  GB_PROPERTY("H", "i", CTABLEROWS_height),
  GB_PROPERTY("Text", "s", CTABLEROWS_text),
  GB_PROPERTY("Title", "s", CTABLEROWS_text),
  GB_PROPERTY_READ("Selected", "b", CTABLEROWS_selected),
  GB_METHOD("Refresh", NULL, CTABLEROWS_refresh, NULL),

  GB_END_DECLARE
};


GB_DESC CTableColumnDesc[] =
{
  GB_DECLARE(".TableViewColumn", 0), GB_VIRTUAL_CLASS(),

  GB_PROPERTY("Width", "i", CTABLECOLS_width),
  GB_PROPERTY("W", "i", CTABLECOLS_width),
  GB_PROPERTY("Text", "s", CTABLECOLS_text),
  GB_PROPERTY("Title", "s", CTABLECOLS_text),
  GB_METHOD("Refresh", NULL, CTABLECOLS_refresh, NULL),

  GB_END_DECLARE
};


GB_DESC CTableRowsDesc[] =
{
  GB_DECLARE(".TableViewRows", 0), GB_VIRTUAL_CLASS(),

  GB_METHOD("_get", ".TableViewRow", CTABLEROWS_get, "(Row)i"),
  GB_PROPERTY("Count", "i", CTABLEROWS_count),
  GB_PROPERTY("Height", "i", CTABLEROWS_height),
  GB_PROPERTY("H", "i", CTABLEROWS_height),
  GB_PROPERTY_READ("Width", "i", CTABLEROWS_width),
  GB_PROPERTY_READ("W", "i", CTABLEROWS_width),
  GB_PROPERTY("Resizable", "b", CTABLEROWS_resizable),
  GB_PROPERTY("Moveable", "b", CTABLEROWS_moveable),

  GB_END_DECLARE
};


GB_DESC CTableColumnsDesc[] =
{
  GB_DECLARE(".TableViewColumns", 0), GB_VIRTUAL_CLASS(),

  GB_METHOD("_get", ".TableViewColumn", CTABLECOLS_get, "(Column)i"),
  GB_PROPERTY("Count", "i", CTABLECOLS_count),
  GB_PROPERTY("Width", "i", CTABLECOLS_width),
  GB_PROPERTY("W", "i", CTABLECOLS_width),
  GB_PROPERTY_READ("Height", "i", CTABLECOLS_height),
  GB_PROPERTY_READ("H", "i", CTABLECOLS_height),
  GB_PROPERTY("Resizable", "b", CTABLECOLS_resizable),
  GB_PROPERTY("Moveable", "b", CTABLECOLS_moveable),

  GB_END_DECLARE
};


GB_DESC CTableViewDesc[] =
{
  GB_DECLARE("TableView", sizeof(CTABLEVIEW)), GB_INHERITS("Control"),

  GB_CONSTANT("None", "i", 0),
  GB_CONSTANT("Horizontal", "i", 1),
  GB_CONSTANT("Vertical", "i", 2),
  GB_CONSTANT("Both", "i", 3),

  GB_CONSTANT("Single", "i", 1),
  GB_CONSTANT("Multi", "i", 2),

  GB_METHOD("_new", NULL, CTABLEVIEW_new, "(Parent)Container;"),
  GB_METHOD("_free", NULL, CTABLEVIEW_free, NULL),

  GB_PROPERTY_READ("Rows", ".TableViewRows", CTABLEVIEW_self),
  GB_PROPERTY_READ("Columns", ".TableViewColumns", CTABLEVIEW_self),

  GB_METHOD("_get", ".TableViewCell", CTABLEVIEW_get, "(Row)i(Column)i"),

  //GB_METHOD("Clear", NULL, CTABLEVIEW_clear, NULL),

  GB_PROPERTY("Row", "i", CTABLEVIEW_row),
  GB_PROPERTY("Column", "i", CTABLEVIEW_column),
  GB_METHOD("MoveTo", NULL, CTABLEVIEW_move_to, "(Row)i(Column)i"),
  GB_PROPERTY_READ("Current", ".TableViewCell", CTABLEVIEW_current),
  GB_PROPERTY("Grid", "b", CTABLEVIEW_grid),
  GB_PROPERTY("Border", "b", CTABLEVIEW_border),
  GB_PROPERTY("ScrollBar", "i<Scroll>", CTABLEVIEW_scrollbars),
  GB_PROPERTY("Header", "i<TableView,None,Vertical,Horizontal,Both>", CTABLEVIEW_header),
  GB_PROPERTY("Mode", "i<TableView,None,Single,Multi>", CTABLEVIEW_mode),

  GB_METHOD("RowAt", "i", CTABLEVIEW_row_at, "(Y)i"),
  GB_METHOD("ColumnAt", "i", CTABLEVIEW_column_at,"(X)i"),

  GB_PROPERTY("ScrollX", "i", CTABLEVIEW_scroll_x),
  GB_PROPERTY("ScrollY", "i", CTABLEVIEW_scroll_y),
  GB_PROPERTY_READ("ClientWidth", "i", CTABLEVIEW_client_width),
  GB_PROPERTY_READ("ClientW", "i", CTABLEVIEW_client_width),
  GB_PROPERTY_READ("ClientHeight", "i", CTABLEVIEW_client_height),
  GB_PROPERTY_READ("ClientH", "i", CTABLEVIEW_client_height),

  GB_PROPERTY_SELF("Data", ".TableViewData"),

  GB_METHOD("Refresh", NULL, CTABLEVIEW_refresh, "[(X)i(Y)i(Width)i(Height)i]"),

  GB_CONSTANT("_Properties", "s", CTABLEVIEW_PROPERTIES),
  GB_CONSTANT("_DefaultEvent", "s", "Click"),

  GB_EVENT("Change", NULL, NULL, &EVENT_Change),
  GB_EVENT("Activate", NULL, NULL, &EVENT_Activate),
  GB_EVENT("Click", NULL, NULL, &EVENT_Click),
  GB_EVENT("Scroll", NULL, NULL, &EVENT_Scroll),
  GB_EVENT("Data", NULL, "(Row)i(Column)i", &EVENT_Data),
  GB_EVENT("ColumnClick", NULL, "(Column)i", &EVENT_ColumnClick),
  GB_EVENT("RowClick", NULL, "(Row)i", &EVENT_RowClick),

  GB_END_DECLARE
};


/***************************************************************************

  class CTableView

***************************************************************************/

CTableView CTableView::manager;

bool CTableView::checkRow(QTable *table, long row)
{
  if (row < -1 || row >= table->numRows())
  {
    GB.Error("Bad row index");
    return true;
  }
  else
    return false;
}

bool CTableView::checkCol(QTable *table, long col)
{
  if (col < -1 || col >= table->numCols())
  {
    GB.Error("Bad column index");
    return true;
  }
  else
    return false;
}

bool CTableView::check(QTable *table, long row, long col)
{
  if (checkRow(table, row))
    return true;
  else if (checkCol(table, col))
    return true;
  else
    return false;
}

void CTableView::changed(void)
{
  MyTable *w = (MyTable *)sender();
  void *object = QT.GetObject((QWidget *)w);

  if (w->currentRow() < 0 || w->currentColumn() < 0)
    return;

  GB.Raise(object, EVENT_Change, 0);
}

void CTableView::activated(void)
{
  void *object = QT.GetObject((QWidget *)sender());
  GB.Raise(object, EVENT_Activate, 0);
}

void CTableView::clicked(void)
{
  void *object = QT.GetObject((QWidget *)sender());
  GB.Raise(object, EVENT_Click, 0);
}

static void send_scroll(void *param)
{
  GB.Raise(param, EVENT_Scroll, 0);
  GB.Unref(&param);
}

void CTableView::scrolled(void)
{
  void *object = QT.GetObject((QWidget *)sender());

  GB.Ref(object);
  GB.Post((void (*)())send_scroll, (long)object);
}

void CTableView::columnClicked(int col)
{
  void *object = QT.GetObject((QWidget *)sender());
  GB.Raise(object, EVENT_ColumnClick, 1, GB_T_INTEGER, col);
}

void CTableView::rowClicked(int row)
{
  void *object = QT.GetObject((QWidget *)sender());
  GB.Raise(object, EVENT_RowClick, 1, GB_T_INTEGER, row);
}