How to add rows in StandardTableView component in C++

[Sonnvu]

I'm trying to populate data into the StandardTableView component and relating to disccusion #5298, it is advised to use VecModel::push to add new row to model. Is there a way to achieve that in C++?

MainWindow.slint code:

import { StandardTableView } from "std-widgets.slint";
component MainWindow inherits Rectangle {
    in-out property <[[StandardListViewItem]]> row_data: [
        [ { text: "Item 1.1" }, { text: "Item 1.2" }, { text: "Item 1.3" } ],
    ];
    callback add_row();

    StandardTableView {
        columns: [
            { title: @tr("Column 1") },
            { title: @tr("Column 2") },
            { title: @tr("Column 3") },
        ];
        rows: row_data;
    }
    Button {
        text: "Add Row";
        clicked => {root.add_row()}
    }
}

Cpp code:

int main(void)
{
    auto main_ui = MainWindow::create();
    main_ui->on_add_row([&] () {
        std::vector<std::vector<std::string> row_data;    // Trying to create model for StandardTableView's row but it's not the right type
        main_ui->set_row_data(row_data);
    })
    main_ui->run();
}

To push new entry into the row model for StandardTableView component, how can I create the right structure type for 'row_data' in C++?

Thanks!

[ogoffart]

I believe the row_data is supposed to be of the type std::shared_ptr<slint::Model<slint::StandardListViewItem>>>>

You can make one for example with
std::make_shared<slint::VecModel<slint::StandardListViewItem>>(.....)

[Sonnvu]

Thank you for your reply!

It seems that the type for row_data is still an issue as I try to populate the StandardTableView by creating the vector model row_data:
slint::VectorModel<slint::StandardListViewItem> row_data;

And share that model upfront:
auto row_data_model = std::make_shared<slint::VectorModel<slint::StandardListViewItem>>(row_data);
main_ui->set_row_data(row_data_model);

The error says

cannot convert std::shared_ptr<slint::VectorModel<slint::StandardListViewItem> > to const std::shared_ptr<slint::Model<std::shared_ptr<slint::Model<slint::StandardListViewItem> > > >&

The model slint::VectorModel<slint::StandardListViewItem> does work for the StandardListView component though

[jonathanffon]

The row_data can be defined with type std::vector<StandardListViewItem> and then converted by make_shared<VectorModel<StandardListViewItem>>(row_data). As to the table_data used in StandardTableView.rows, it should be defined with type std::vector<shared_ptr<Model<StandardListViewItem>>> and converted by make_shared<VectorModel<shared_ptr<Model<StandardListViewItem>>>>(table_data).

The definition and conversion is bizarre and far from straightforward.
Frustration overwhelmed me before I figure this out. The guys should really document more examples.

Anyway, in my project, the following snippet works.
The documents selected in a dialog will be added to StandardTableView.

// callback: add multiple documents
  ui->on_file_add([&] {
#ifdef _WIN32
    const char SLASH[] = "\\";
#else
    const char SLASH[] = "/";
#endif
    auto results =
        open_file("Add Documents", ".", {"All Files", "*"}, opt::multiselect).result();
    if (!results.empty()) {
      vector<SharedString> oldfnames;
      //  in-out property <[[StandardListViewItem]]> dt_files:[];  <==>
      //  StandardTableView.rows
      auto dt_files = ui->get_dt_files();
      typedef shared_ptr<Model<StandardListViewItem>> ModelRcLVI;
      vector<ModelRcLVI> table; // new table
      for (int i = 0; i < dt_files->row_count(); i++) {
        auto row = *dt_files->row_data(i);
        // push old rows in original StandardTableView to new table
        if (row->row_data(0)->text == "🔒") {
          table.push_back(*dt_files->row_data(i));
          SharedString fname =
              row->row_data(2)->text + SLASH + row->row_data(1)->text;
          oldfnames.push_back(fname);
        }
      }
      // add selected files to StandardTableView
      for (auto fnm : results) {
#ifdef _WIN32
        std::replace(fnm.begin(), fnm.end(), '/', '\\');
#endif
        std::cout << fnm << std::endl;
        auto it =
            std::find(oldfnames.begin(), oldfnames.end(), SharedString(fnm));
        if (it != oldfnames.end()) {
          continue;
        }
        size_t pos = fnm.find_last_of(SLASH);
        // row data: fileStatus, fileName, filePath
        vector<StandardListViewItem> row1 = {
            StandardListViewItem("🔒"),
            StandardListViewItem(SharedString(fnm.substr(pos + 1, fnm.size()))),
            StandardListViewItem(SharedString(fnm.substr(0, pos))),
        };
        auto row1_model = make_shared<VectorModel<StandardListViewItem>>(row1);
        table.push_back(row1_model);
      }
      auto table_model = make_shared<VectorModel<ModelRcLVI>>(table);
      ui->set_dt_files(table_model); // set new table
    }
  });

    in-out property <[[StandardListViewItem]]> dt_files:[];
    callback file-add();

        Menu {
            title: @tr("File");
            MenuItem {
                title: @tr("Add Documents");
                activated => {
                    file-add();
                }
            }
        }

        StandardTableView {
            columns: [
                { title: "♨", width:60px },
                { title: "name" },
                { title: "location" },
            ];
            rows: dt_files;
        }