C++ TableItem类代码示例

void TableEditor::configureCell(int row, int col, Node * node)
{
   TableItem* item = (TableItem*) m_dataTable->item(row, col);
   if (!item)
     return;
   // Header (TH) or standard cell?
   item->setHeader(node->tag->name.lower() == "th");
   // Horizontal alignment
   Qt::AlignmentFlags flags;
   QString align = node->tag->attributeValue("align", true);
   if (align == "right")
     flags = Qt::AlignRight;
   else if (align == "center")
     flags = Qt::AlignHCenter;
   else if (align == "justify")
     flags = Qt::AlignJustify;
   else if (align.isEmpty() && item->header())
     flags = Qt::AlignHCenter;   // TH is centered by default
   else
     flags = Qt::AlignLeft;
   item->setAlignment(flags);
   // Vertical alignment
   QString valign = node->tag->attributeValue("valign", true);
   if (valign == "top")
     flags = Qt::AlignTop;
   else if (valign == "bottom")
     flags = Qt::AlignBottom;
   else flags = Qt::AlignVCenter;
   item->setVAlignment(flags);
}

bool
TableModel::setData(const QModelIndex &index,
                    const QVariant &value,
                    int role)
{
    if ( !index.isValid() ) {
        return false;
    }

    TableItem *itm = item(index);
    if (itm) {
        itm->setData(role, value);

        return true;
    }

    // don't create dummy table items for empty values
    if ( !value.isValid() ) {
        return false;
    }

    TableView *view = qobject_cast<TableView*>( QObject::parent() );
    if (!view) {
        return false;
    }

    itm = createItem();
    itm->setData(role, value);
    view->setItem(index.row(), index.column(), itm);

    return true;
}

ConstraintTable::ConstraintTable(QWidget * parent, ConstraintCanvas * c)
    : Q3Table(c->elements.count(), 4, parent)
{
    setSorting(true);
    setSelectionMode(NoSelection);
    setRowMovingEnabled(FALSE);

    horizontalHeader()->setLabel(0, TR("visible"));
    horizontalHeader()->setLabel(1, " ");
    horizontalHeader()->setLabel(2, TR("element"));
    horizontalHeader()->setLabel(3, TR("constraint"));
    setColumnStretchable(0, FALSE);
    setColumnStretchable(1, FALSE);

    int row;
    bool v = c->indicate_visible;
    Q3ValueList<BrowserNode *> & hv = c->hidden_visible;
    BrowserNodeList & elts = c->elements;
    BrowserNode * bn;
    QString yes = TR("  yes");
    QString empty;

    elts.sort();

    for (bn = elts.first(), row = 0; bn != 0; bn = elts.next(), row += 1) {
        if ((v) ? hv.findIndex(bn) != -1 : hv.findIndex(bn) == -1)
            setText(row, 0, yes);

        setPixmap(row, 1, *(bn->pixmap(0)));

        TableItem * ti;

        ti = new TableItem(this, Q3TableItem::Never, bn->full_name(TRUE));
        ti->setReplaceable(FALSE);
        setItem(row, 2, ti);

        QString s = toUnicode(bn->constraint());
        int n = s.count('\n');

        ti = new TableItem(this, Q3TableItem::Never, s);
        ti->setReplaceable(FALSE);
        setItem(row, 3, ti);

        if (n != 0) {
            // note : adjustRow(row) does nothing
            setRowHeight(row, rowHeight(row) * (n + 1));
        }
    }

    adjustColumn(0);
    adjustColumn(1);
    setColumnStretchable(2, TRUE);
    setColumnStretchable(3, TRUE);

    connect(this, SIGNAL(pressed(int, int, int, const QPoint &)),
            this, SLOT(button_pressed(int, int, int, const QPoint &)));
}

TableItem* TableItem::create(CCSize size)
{
	TableItem *instance = new TableItem();
	if (instance && instance->initWithSize(size)) {
		instance->autorelease();
		return instance;
	}
	CC_SAFE_DELETE(instance);
	return instance;
}

void
TableView::setHorizontalHeaderLabels(const QStringList &labels)
{
    TableItem *item = 0;

    for (int i = 0; i < _imp->model->columnCount() && i < labels.count(); ++i) {
        item = _imp->model->horizontalHeaderItem(i);
        if (!item) {
            item = _imp->model->createItem();
            setHorizontalHeaderItem(i, item);
        }
        item->setText( labels.at(i) );
    }
}

static gboolean
plugin_init (GstPlugin *plugin)
{
    GQuark library_name_quark;
    GQuark component_name_quark;
    GQuark component_role_quark;
    GST_DEBUG_CATEGORY_INIT (gstomx_debug, "omx", 0, "gst-openmax");
    GST_DEBUG_CATEGORY_INIT (gstomx_util_debug, "omx_util", 0, "gst-openmax utility");
    GST_DEBUG_CATEGORY_INIT (gstomx_ppm, "omx_ppm", 0,
                             "gst-openmax performance");

    library_name_quark = g_quark_from_static_string ("library-name");
    component_name_quark = g_quark_from_static_string ("component-name");
    component_role_quark = g_quark_from_static_string ("component-role");

    g_omx_init ();

    {
        guint i;
        for (i = 0; element_table[i].name; i++)
        {
            TableItem *element;
            GType type;

            element = &element_table[i];
            type = element->get_type ();
            g_type_set_qdata (type, library_name_quark, (gpointer) element->library_name);
            g_type_set_qdata (type, component_name_quark, (gpointer) element->component_name);
            g_type_set_qdata (type, component_role_quark, (gpointer) element->component_role);

            if (!gst_element_register (plugin, element->name, element->rank, type))
            {
                g_warning ("failed registering '%s'", element->name);
                return FALSE;
            }
        }
    }

    return TRUE;
}

bool
TableModel::setHeaderData(int section,
                          Qt::Orientation orientation,
                          const QVariant &value,
                          int role)
{
    if ( (section < 0) ||
         ( (orientation == Qt::Horizontal) && ( (int)_imp->horizontalHeaderItems.size() <= section ) ) ) {
        return false;
    }

    TableItem *itm = 0;
    if (orientation == Qt::Horizontal) {
        itm = _imp->horizontalHeaderItems.at(section);
    }

    if (itm) {
        itm->setData(role, value);

        return true;
    }

    return false;
}

QVariant
TableModel::headerData(int section,
                       Qt::Orientation orientation,
                       int role) const
{
    if (section < 0) {
        return QVariant();
    }

    TableItem *itm = 0;
    if ( (orientation == Qt::Horizontal) && ( section < (int)_imp->horizontalHeaderItems.size() ) ) {
        itm = _imp->horizontalHeaderItems.at(section);
    } else {
        return QVariant(); // section is out of bounds
    }
    if (itm) {
        return itm->data(role);
    }
    if (role == Qt::DisplayRole) {
        return section + 1;
    }

    return QVariant();
}

int main(int argc, char **argv)
{
  if (4 != argc)
  {
    fprintf(stderr, "./test_tablemgr [store_root] [raid_regex] [store_regex]\n");
    exit(-1);
  }

  ob_init_memory_pool();
  char *root = argv[1];
  char *raid = argv[2];
  char *store = argv[3];
  TableMgr tm;
  SSTableMgr &sstm = UPS.get_sstable_mgr();
  CommonSchemaManagerWrapper schema_mgr;
  tbsys::CConfig config;
  schema_mgr.parse_from_file("test_schema.ini", config);
  UPS.get_table_mgr().set_schemas(schema_mgr);

  common::ObRoleMgr role_mgr;
  common::ObSlaveMgr slave_mgr;
  role_mgr.set_role(ObRoleMgr::MASTER);
  int ret = slave_mgr.init(0, &UPS.get_ups_rpc_stub(), 1000000, 6000000, 4000000, 3);
  assert(OB_SUCCESS == ret);
  ret = UPS.get_log_mgr().init("./commitlog", 64 * 1024 * 1024, &slave_mgr, &role_mgr, 0);
  assert(OB_SUCCESS == ret);
  ret = UPS.get_log_mgr().replay_log(UPS.get_table_mgr());
  assert(OB_SUCCESS == ret);

  ret = tm.init();
  assert(OB_SUCCESS == ret);

  sstable::ObBlockCacheConf bc_conf;
  bc_conf.block_cache_memsize_mb = 100;
  sstable::ObBlockIndexCacheConf bic_conf;
  bic_conf.cache_mem_size = 100 * 1024 * 1024;
  ret = UPS.get_sstable_query().init(bc_conf, bic_conf);
  assert(OB_SUCCESS == ret);

  ret = sstm.init(root, raid, store);
  assert(OB_SUCCESS == ret);

  ret = sstm.reg_observer(&tm);
  assert(OB_SUCCESS == ret);

  sstm.load_new();
  tm.sstable_scan_finished(3);

  TableItem *ti = tm.get_active_memtable();
  assert(NULL != ti);
  fill_memtable(ti->get_memtable());
  tm.revert_active_memtable(ti);

  ret = tm.replay_freeze_memtable(SSTableID::get_id(11, 2, 2), SSTableID::get_id(11, 1, 1), 7);
  assert(OB_SUCCESS == ret);
  tm.log_table_info();

  ObVersionRange vg;
  vg.start_version_ = 10;
  vg.end_version_ = 10;
  vg.border_flag_.set_inclusive_start();
  vg.border_flag_.set_inclusive_end();
  uint64_t max_version = 0;
  ObList<ITableEntity*> tlist;
  ret = tm.acquire_table(vg, max_version, tlist);
  assert(OB_SUCCESS == ret);
  assert(10 == max_version);
  assert(3 == tlist.size());
  tm.revert_table(tlist);

  tm.try_dump_memtable();

  ti = tm.get_active_memtable();
  fill_memtable(ti->get_memtable());
  tm.revert_active_memtable(ti);
  uint64_t new_version = 0;
  uint64_t frozen_version = 0;
  uint64_t clog_id = 9;
  int64_t time_stamp = 0;
  bool major_version_changed = false;
  ret = tm.try_freeze_memtable(0, 0, 0, new_version, frozen_version, clog_id, time_stamp, major_version_changed);
  assert(OB_SUCCESS == ret);
  assert(new_version == SSTableID::get_id(12, 1, 1));
  assert(frozen_version == SSTableID::get_id(11, 2, 2));
  assert(major_version_changed);

  tm.try_dump_memtable();

  vg.start_version_ = 10;
  vg.end_version_ = 100;
  vg.border_flag_.set_inclusive_start();
  vg.border_flag_.set_inclusive_end();
  max_version = 0;
  ret = tm.acquire_table(vg, max_version, tlist);
  assert(OB_SUCCESS == ret);
  assert(12 == max_version);
  assert(6 == tlist.size());
  get_table(tlist);

  tm.log_table_info();
//.........这里部分代码省略.........

void
TableView::dropEvent(QDropEvent* e)
{
    //  QTreeView::dropEvent(e);

    DropIndicatorPosition position = dropIndicatorPosition();

    switch (position) {
    case QAbstractItemView::OnItem:
    case QAbstractItemView::OnViewport:
    default:

        return;

    case QAbstractItemView::AboveItem:
    case QAbstractItemView::BelowItem:
        break;
    }
    TableItem* into = itemAt( e->pos() );

    if ( !into || _imp->draggedItems.empty() ) {
        return;
    }
    Q_EMIT aboutToDrop();
    int targetRow = into->row();

    //We only support full rows
    assert(selectionBehavior() == QAbstractItemView::SelectRows);

    ///Remove the items
    std::map<int, std::map<int, TableItem*> > rowMoved;
    for (std::list<TableItem*>::iterator it = _imp->draggedItems.begin(); it != _imp->draggedItems.end(); ++it) {
        rowMoved[(*it)->row()][(*it)->column()] = *it;
        TableItem* taken = _imp->model->takeItem( (*it)->row(), (*it)->column() );
        assert(taken == *it);
        Q_UNUSED(taken);
    }
    /// remove the rows in reverse order so that indexes are still valid
    for (std::map<int, std::map<int, TableItem*> >::reverse_iterator it = rowMoved.rbegin(); it != rowMoved.rend(); ++it) {
        _imp->model->removeRows(it->first);
        if (it->first <= targetRow) {
            --targetRow;
        }
    }
    _imp->draggedItems.clear();
    ///insert back at the correct position

    int nRows = _imp->model->rowCount();
    switch (position) {
    case QAbstractItemView::AboveItem: {
        _imp->model->insertRows( targetRow, rowMoved.size() );
        break;
    }
    case QAbstractItemView::BelowItem: {
        ++targetRow;
        if (targetRow > nRows) {
            targetRow = nRows;
        }
        _imp->model->insertRows( targetRow, rowMoved.size() );
        break;
    }
    default:
        assert(false);

        return;
    }
    ;

    int rowIndex = targetRow;
    for (std::map<int, std::map<int, TableItem*> >::iterator it = rowMoved.begin(); it != rowMoved.end(); ++it, ++rowIndex) {
        for (std::map<int, TableItem*>::iterator it2 = it->second.begin(); it2 != it->second.end(); ++it2) {
            _imp->model->setItem(rowIndex, it2->first, it2->second);
        }
    }

    Q_EMIT itemDropped();
} // TableView::dropEvent

KeyValuesTable::KeyValuesTable(HaveKeyValueData * hv, QWidget * parent, bool isReadOnly)
    : StringTable(((hv == 0) ? 0 : hv->get_n_keys()) + ((isReadOnly) ? 0 : 1),
                  (isReadOnly) ? 2 : 3, parent, isReadOnly)
{
    horizontalHeader()->setLabel(0, TR("Key"));
    horizontalHeader()->setLabel(1, TR("Value"));

    if (!isReadOnly)
        horizontalHeader()->setLabel(2, TR("do"));

    int index;
    int sup = 0;
    if(hv)
        sup = hv->get_n_keys();

    if (isReadOnly)
    {
        for (index = 0; index < sup; index += 1)
        {
            TableItem * ti;

            ti = new TableItem(this, Q3TableItem::Never,
                               toUnicode(hv->get_key(index)));
            ti->setReplaceable(FALSE);
            setItem(index, 0, ti);

            QString s = toUnicode(hv->get_value(index));
            int n = s.count('\n');

            ti = new TableItem(this, Q3TableItem::Never, s);
            ti->setReplaceable(FALSE);
            setItem(index, 1, ti);

            if (n != 0)
            {
                // note : adjustRow(index) does nothing
                setRowHeight(index, rowHeight(index) * (n + 1));
            }
        }
    }
    else
    {
        props.setAutoDelete(TRUE);

        QStringList items;

        for (index = 0; index < sup; index += 1) {
            QString k = toUnicode(hv->get_key(index));
            QString v = toUnicode(hv->get_value(index));
            QStringList * psl = props[k];

            setText(index, 0, k);

            if (psl != 0)
                setItem(index, 1, new ComboItem(this, v, *psl, FALSE));

            if ((k.contains(':') == 2) &&
                    ProfiledStereotypes::enumerated(k, items)) {
                psl = new QStringList(items);
                props.insert(k, psl);
                setItem(index, 1, new ComboItem(this, v, *psl, FALSE));
            }
            else
                setItem(index, 1, new MLinesItem(this, v));

            setText(index, 2, QString());
            setRowStretchable(index, TRUE);
        }

        setText(index, 0, QString());
        setItem(index, 1, new MLinesItem(this, QString()));
        setText(index, 2, QString());
        setRowStretchable(index, TRUE);
    }

    horizontalHeader()->setResizeEnabled(TRUE, 0);  //setColumnStretchable (0, TRUE);
    setColumnStretchable(1, TRUE);

    if (! isReadOnly) {
        adjustColumn(2);
        setColumnStretchable(2, FALSE);
    }
}

void KeyValuesTable::updateThisFromNode(HaveKeyValueData *hv, bool isReadOnly)
{

    if (!isReadOnly)
    {
        if(numCols() == 2)
            insertColumns(2);
        horizontalHeader()->setLabel(2, TR("do"));
    }
    else
    {
        if(numCols() == 3)
            removeColumn(2);
    }

    int index;
    int sup = 0;
    if(hv)
        sup = hv->get_n_keys();
    int rowCount = numRows();
    for (index = rowCount - 1; index > sup; index -= 1)
        removeRow(index);

    if (isReadOnly)
    {
        for (index = 0; index < sup; index += 1)
        {
            TableItem * tiKey = nullptr;
            TableItem * tiValue = nullptr;
            QString s = toUnicode(hv->get_value(index));
            int n = s.count('\n');

            if(index == numRows() || numRows() == 0)
            {
                tiKey = new TableItem(this, Q3TableItem::Never,
                                      toUnicode(hv->get_key(index)));
                tiValue = new TableItem(this, Q3TableItem::Never, s);
                setItem(index, 0, tiKey);
                setItem(index, 1, tiValue);
            }
            else
            {
                tiKey = dynamic_cast<TableItem*>(item(index, 0));
                tiKey->setText(hv->get_key(index));
                tiValue = dynamic_cast<TableItem*>(item(index, 1));
                tiValue->setText(s);
            }
            tiKey->setReplaceable(FALSE);
            tiValue->setReplaceable(FALSE);


            if (n != 0)
            {
                // note : adjustRow(index) does nothing
                setRowHeight(index, rowHeight(index) * (n + 1));
            }
        }
    }
    else
    {
        props.setAutoDelete(TRUE);

        QStringList items;

        for (index = 0; index < sup; index += 1)
        {
            QString k = toUnicode(hv->get_key(index));
            QString v = toUnicode(hv->get_value(index));
            QStringList * psl = props[k];

            setText(index, 0, k);

            if (psl != 0)
                setItem(index, 1, new ComboItem(this, v, *psl, FALSE));

            if ((k.contains(':') == 2) &&
                    ProfiledStereotypes::enumerated(k, items)) {
                psl = new QStringList(items);
                props.insert(k, psl);
                setItem(index, 1, new ComboItem(this, v, *psl, FALSE));
            }
            else
                setItem(index, 1, new MLinesItem(this, v));

            setText(index, 2, QString());
            setRowStretchable(index, TRUE);
        }

        if(index == numRows())
            insertRows(numRows());
        setText(index, 0, QString());
        setItem(index, 1, new MLinesItem(this, QString()));
        setText(index, 2, QString());
        setRowStretchable(index, TRUE);
    }

    horizontalHeader()->setResizeEnabled(TRUE, 0);  //setColumnStretchable (0, TRUE);
    setColumnStretchable(1, TRUE);

    if (! isReadOnly) {
//.........这里部分代码省略.........