|
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
|
|
|
|
| #include <QPalette>
|
| #include <QPrintDialog>
|
| #include <QPrintPreviewDialog>
|
| #include <QPrinter>
|
| #include <QTextDocument>
|
|
|
|
|
| #include <App/Application.h>
|
| #include <App/DocumentObject.h>
|
| #include <App/Range.h>
|
| #include <Base/Tools.h>
|
| #include <Gui/Application.h>
|
| #include <Gui/Command.h>
|
| #include <Gui/CommandT.h>
|
| #include <Gui/Document.h>
|
| #include <Gui/FileDialog.h>
|
| #include <Gui/MainWindow.h>
|
| #include <Gui/PreferencePages/DlgSettingsPDF.h>
|
|
|
| #include <Mod/Spreadsheet/App/Sheet.h>
|
| #include <Mod/Spreadsheet/App/SheetPy.h>
|
|
|
| #include "LineEdit.h"
|
| #include "SpreadsheetDelegate.h"
|
| #include "SpreadsheetView.h"
|
| #include "ZoomableView.h"
|
| #include "qtcolorpicker.h"
|
| #include "ui_Sheet.h"
|
|
|
|
|
| using namespace SpreadsheetGui;
|
| using namespace Spreadsheet;
|
| using namespace Gui;
|
| using namespace App;
|
| namespace sp = std::placeholders;
|
|
|
|
|
|
|
| TYPESYSTEM_SOURCE_ABSTRACT(SpreadsheetGui::SheetView, Gui::MDIView)
|
|
|
| SheetView::SheetView(Gui::Document* pcDocument, App::DocumentObject* docObj, QWidget* parent)
|
| : MDIView(pcDocument, parent)
|
| , sheet(static_cast<Sheet*>(docObj))
|
| {
|
|
|
|
|
| model = new SheetModel(static_cast<Sheet*>(docObj));
|
|
|
| ui = new Ui::Sheet();
|
| QWidget* w = new QWidget(this);
|
| ui->setupUi(w);
|
| setCentralWidget(w);
|
|
|
| new ZoomableView(ui);
|
|
|
| delegate = new SpreadsheetDelegate(sheet);
|
| ui->cells->setModel(model);
|
| ui->cells->setItemDelegate(delegate);
|
| ui->cells->setSheet(sheet);
|
|
|
|
|
| connect(
|
| ui->cells->selectionModel(),
|
| &QItemSelectionModel::currentChanged,
|
| this,
|
| &SheetView::currentChanged
|
| );
|
|
|
| connect(
|
| qobject_cast<SheetViewHeader*>(ui->cells->horizontalHeader()),
|
| &SheetViewHeader::resizeFinished,
|
| this,
|
| &SheetView::columnResizeFinished
|
| );
|
| connect(ui->cells->horizontalHeader(), &QHeaderView::sectionResized, this, &SheetView::columnResized);
|
|
|
| connect(
|
| qobject_cast<SheetViewHeader*>(ui->cells->verticalHeader()),
|
| &SheetViewHeader::resizeFinished,
|
| this,
|
| &SheetView::rowResizeFinished
|
| );
|
| connect(ui->cells->verticalHeader(), &QHeaderView::sectionResized, this, &SheetView::rowResized);
|
|
|
| connect(delegate, &SpreadsheetDelegate::finishedWithKey, this, &SheetView::editingFinishedWithKey);
|
| connect(ui->cellContent, &ExpressionLineEdit::returnPressed, this, [this]() {
|
| confirmContentChanged(ui->cellContent->text());
|
| });
|
| connect(ui->cellAlias, &ExpressionLineEdit::editingFinished, this, [this]() {
|
| confirmAliasChanged(ui->cellAlias->text());
|
| });
|
| connect(ui->cellAlias, &LineEdit::textEdited, this, &SheetView::aliasChanged);
|
|
|
|
|
| columnWidthChangedConnection = sheet->columnWidthChanged.connect(
|
| std::bind(&SheetView::resizeColumn, this, sp::_1, sp::_2)
|
| );
|
| rowHeightChangedConnection = sheet->rowHeightChanged.connect(
|
| std::bind(&SheetView::resizeRow, this, sp::_1, sp::_2)
|
| );
|
|
|
|
|
| connect(model, &QAbstractItemModel::dataChanged, this, &SheetView::modelUpdated);
|
|
|
| QPalette palette = ui->cells->palette();
|
| palette.setColor(QPalette::Base, QColor(255, 255, 255));
|
| palette.setColor(QPalette::Text, QColor(0, 0, 0));
|
| ui->cells->setPalette(palette);
|
|
|
| QList<QtColorPicker*> bgList = Gui::getMainWindow()->findChildren<QtColorPicker*>(
|
| QStringLiteral("Spreadsheet_BackgroundColor")
|
| );
|
| if (!bgList.empty()) {
|
| bgList[0]->setCurrentColor(palette.color(QPalette::Base));
|
| }
|
|
|
| QList<QtColorPicker*> fgList = Gui::getMainWindow()->findChildren<QtColorPicker*>(
|
| QStringLiteral("Spreadsheet_ForegroundColor")
|
| );
|
| if (!fgList.empty()) {
|
| fgList[0]->setCurrentColor(palette.color(QPalette::Text));
|
| }
|
|
|
|
|
| ui->cellContent->setDocumentObject(sheet);
|
| ui->cellAlias->setDocumentObject(sheet);
|
|
|
| ui->cellContent->setPrefix('=');
|
| }
|
|
|
| SheetView::~SheetView()
|
| {
|
| Gui::Application::Instance->detachView(this);
|
| delete ui;
|
| delete model;
|
| delete delegate;
|
| }
|
|
|
| bool SheetView::onMsg(const char* pMsg, const char**)
|
| {
|
| if (strcmp("Undo", pMsg) == 0) {
|
| getGuiDocument()->undo(1);
|
| App::Document* doc = getAppDocument();
|
| if (doc) {
|
| doc->recompute();
|
| }
|
| return true;
|
| }
|
| else if (strcmp("Redo", pMsg) == 0) {
|
| getGuiDocument()->redo(1);
|
| App::Document* doc = getAppDocument();
|
| if (doc) {
|
| doc->recompute();
|
| }
|
| return true;
|
| }
|
| else if (strcmp("Save", pMsg) == 0) {
|
| getGuiDocument()->save();
|
| return true;
|
| }
|
| else if (strcmp("SaveAs", pMsg) == 0) {
|
| getGuiDocument()->saveAs();
|
| return true;
|
| }
|
| else if (strcmp("Std_Delete", pMsg) == 0) {
|
| std::vector<Range> ranges = selectedRanges();
|
| if (sheet->hasCell(ranges)) {
|
| Gui::Command::openCommand(QT_TRANSLATE_NOOP("Command", "Clear Cells"));
|
| std::vector<Range>::const_iterator i = ranges.begin();
|
| for (; i != ranges.end(); ++i) {
|
| FCMD_OBJ_CMD(sheet, "clear('" << i->rangeString() << "')");
|
| }
|
| Gui::Command::commitCommand();
|
| Gui::Command::doCommand(Gui::Command::Doc, "App.ActiveDocument.recompute()");
|
| }
|
| return true;
|
| }
|
| else if (strcmp("Cut", pMsg) == 0) {
|
| ui->cells->cutSelection();
|
| return true;
|
| }
|
| else if (strcmp("Copy", pMsg) == 0) {
|
| ui->cells->copySelection();
|
| return true;
|
| }
|
| else if (strcmp("Paste", pMsg) == 0) {
|
| ui->cells->pasteClipboard();
|
| return true;
|
| }
|
| else {
|
| return false;
|
| }
|
| }
|
|
|
| bool SheetView::onHasMsg(const char* pMsg) const
|
| {
|
| if (strcmp("Undo", pMsg) == 0) {
|
| App::Document* doc = getAppDocument();
|
| return doc && doc->getAvailableUndos() > 0;
|
| }
|
| if (strcmp("Redo", pMsg) == 0) {
|
| App::Document* doc = getAppDocument();
|
| return doc && doc->getAvailableRedos() > 0;
|
| }
|
| if (strcmp("Save", pMsg) == 0) {
|
| return true;
|
| }
|
| if (strcmp("SaveAs", pMsg) == 0) {
|
| return true;
|
| }
|
| if (strcmp("Cut", pMsg) == 0) {
|
| return true;
|
| }
|
| if (strcmp("Copy", pMsg) == 0) {
|
| return true;
|
| }
|
| if (strcmp("Paste", pMsg) == 0) {
|
| return true;
|
| }
|
| if (strcmp(pMsg, "Print") == 0) {
|
| return true;
|
| }
|
| if (strcmp(pMsg, "PrintPreview") == 0) {
|
| return true;
|
| }
|
| if (strcmp(pMsg, "PrintPdf") == 0) {
|
| return true;
|
| }
|
| else if (strcmp("AllowsOverlayOnHover", pMsg) == 0) {
|
| return true;
|
| }
|
|
|
| return false;
|
| }
|
|
|
| |
| |
|
|
| void SheetView::print()
|
| {
|
| QPrinter printer(QPrinter::ScreenResolution);
|
| printer.setPageOrientation(QPageLayout::Landscape);
|
| printer.setFullPage(true);
|
| QPrintDialog dlg(&printer, this);
|
| if (dlg.exec() == QDialog::Accepted) {
|
| print(&printer);
|
| }
|
| }
|
|
|
| void SheetView::printPreview()
|
| {
|
| QPrinter printer(QPrinter::ScreenResolution);
|
| printer.setPageOrientation(QPageLayout::Landscape);
|
| QPrintPreviewDialog dlg(&printer, this);
|
| connect(&dlg, &QPrintPreviewDialog::paintRequested, this, qOverload<QPrinter*>(&SheetView::print));
|
| dlg.exec();
|
| }
|
|
|
| void SheetView::print(QPrinter* printer)
|
| {
|
| #if 0
|
| ui->cells->render(printer);
|
| #endif
|
| std::unique_ptr<QTextDocument> document = std::make_unique<QTextDocument>();
|
| document->setHtml(ui->cells->toHtml());
|
| document->print(printer);
|
| }
|
|
|
| |
| |
|
|
| void SheetView::printPdf()
|
| {
|
| QString filename = FileDialog::getSaveFileName(
|
| this,
|
| tr("Export PDF"),
|
| QString(),
|
| QStringLiteral("%1 (*.pdf)").arg(tr("PDF file"))
|
| );
|
| if (!filename.isEmpty()) {
|
| QPrinter printer(QPrinter::ScreenResolution);
|
|
|
|
|
|
|
| printer.setPdfVersion(Gui::Dialog::DlgSettingsPDF::evaluatePDFVersion());
|
| printer.setPageOrientation(QPageLayout::Landscape);
|
| printer.setOutputFormat(QPrinter::PdfFormat);
|
| printer.setOutputFileName(filename);
|
| printer.setCreator(QString::fromStdString(App::Application::getNameWithVersion()));
|
| print(&printer);
|
| }
|
| }
|
|
|
| void SheetView::setCurrentCell(QString str)
|
| {
|
| Q_UNUSED(str);
|
| updateContentLine();
|
| updateAliasLine();
|
| }
|
|
|
| void SheetView::updateContentLine()
|
| {
|
| QModelIndex i = ui->cells->currentIndex();
|
|
|
| if (i.isValid()) {
|
| std::string str;
|
| if (const auto* cell = sheet->getCell(CellAddress(i.row(), i.column()))) {
|
| (void)cell->getStringContent(str);
|
| }
|
| ui->cellContent->setText(QString::fromUtf8(str.c_str()));
|
| ui->cellContent->setEnabled(true);
|
|
|
|
|
|
|
| ui->cellContent->setDocumentObject(sheet);
|
| }
|
| }
|
|
|
| void SheetView::updateAliasLine()
|
| {
|
| QModelIndex i = ui->cells->currentIndex();
|
|
|
| if (i.isValid()) {
|
| std::string str;
|
| if (const auto* cell = sheet->getCell(CellAddress(i.row(), i.column()))) {
|
| (void)cell->getAlias(str);
|
| }
|
| ui->cellAlias->setText(QString::fromUtf8(str.c_str()));
|
| ui->cellAlias->setEnabled(true);
|
|
|
|
|
|
|
| ui->cellAlias->setDocumentObject(sheet);
|
| }
|
| }
|
|
|
| void SheetView::columnResizeFinished()
|
| {
|
| if (newColumnSizes.empty()) {
|
| return;
|
| }
|
|
|
| blockSignals(true);
|
| for (auto& v : newColumnSizes) {
|
| sheet->setColumnWidth(v.first, v.second);
|
| }
|
| blockSignals(false);
|
| newColumnSizes.clear();
|
| }
|
|
|
| void SheetView::rowResizeFinished()
|
| {
|
| if (newRowSizes.empty()) {
|
| return;
|
| }
|
|
|
| blockSignals(true);
|
| for (auto& v : newRowSizes) {
|
| sheet->setRowHeight(v.first, v.second);
|
| }
|
| blockSignals(false);
|
| newRowSizes.clear();
|
| }
|
|
|
| void SheetView::modelUpdated(const QModelIndex& topLeft, const QModelIndex& bottomRight)
|
| {
|
| const QModelIndex& current = ui->cells->currentIndex();
|
|
|
| if (current < topLeft || bottomRight < current) {
|
| return;
|
| }
|
|
|
| updateContentLine();
|
| updateAliasLine();
|
| }
|
|
|
| void SheetView::columnResized(int col, int oldSize, int newSize)
|
| {
|
| Q_UNUSED(oldSize);
|
| newColumnSizes[col] = newSize;
|
| }
|
|
|
| void SheetView::rowResized(int row, int oldSize, int newSize)
|
| {
|
| Q_UNUSED(oldSize);
|
| newRowSizes[row] = newSize;
|
| }
|
|
|
| void SheetView::resizeColumn(int col, int newSize)
|
| {
|
| if (ui->cells->horizontalHeader()->sectionSize(col) != newSize) {
|
| ui->cells->setColumnWidth(col, newSize);
|
| }
|
| }
|
|
|
| void SheetView::resizeRow(int col, int newSize)
|
| {
|
| if (ui->cells->verticalHeader()->sectionSize(col) != newSize) {
|
| ui->cells->setRowHeight(col, newSize);
|
| }
|
| }
|
|
|
| void SheetView::editingFinishedWithKey(int key, Qt::KeyboardModifiers modifiers)
|
| {
|
| QModelIndex i = ui->cells->currentIndex();
|
|
|
| if (i.isValid()) {
|
| ui->cells->finishEditWithMove(key, modifiers);
|
| }
|
| }
|
|
|
| void SheetView::confirmAliasChanged(const QString& text)
|
| {
|
| bool aliasOkay = true;
|
|
|
| ui->cellAlias->setDocumentObject(sheet);
|
| if (text.length() != 0 && !sheet->isValidAlias(text.toStdString())) {
|
| aliasOkay = false;
|
| }
|
|
|
| QModelIndex i = ui->cells->currentIndex();
|
| if (const auto* cell = sheet->getNewCell(CellAddress(i.row(), i.column()))) {
|
| if (!aliasOkay) {
|
|
|
|
|
| std::string current_alias;
|
| (void)cell->getAlias(current_alias);
|
| if (text != QString::fromUtf8(current_alias.c_str())) {
|
| Base::Console().error("Unable to set alias: %s\n", text.toStdString().c_str());
|
| }
|
| }
|
| else {
|
| std::string address = CellAddress(i.row(), i.column()).toString();
|
| Gui::cmdAppObjectArgs(sheet, "setAlias('%s', '%s')", address, text.toStdString());
|
| Gui::cmdAppDocument(sheet->getDocument(), "recompute()");
|
| ui->cells->setFocus();
|
| }
|
| }
|
| }
|
|
|
|
|
| void SheetView::confirmContentChanged(const QString& text)
|
| {
|
| QModelIndex i = ui->cells->currentIndex();
|
| ui->cells->model()->setData(i, QVariant(text), Qt::EditRole);
|
| ui->cells->setFocus();
|
| }
|
|
|
| void SheetView::aliasChanged(const QString& text)
|
| {
|
|
|
|
|
| bool aliasOk = true;
|
| static auto originalStylesheet = ui->cellAlias->styleSheet();
|
| QString warningColor;
|
| if (qApp->styleSheet().contains(QLatin1String("dark"), Qt::CaseInsensitive)) {
|
| warningColor = QLatin1String("rgb(255,90,90)");
|
| }
|
| else {
|
| warningColor = QLatin1String("rgb(200,0,0)");
|
| }
|
|
|
| if (!text.isEmpty() && !sheet->isValidAlias(text.toStdString())) {
|
| aliasOk = false;
|
| }
|
|
|
| if (!aliasOk) {
|
|
|
| ui->cellAlias->setToolTip(QObject::tr("Alias contains invalid characters!"));
|
| ui->cellAlias->setStyleSheet(QLatin1String("color:") + warningColor);
|
| }
|
| else {
|
|
|
| ui->cellAlias->setToolTip(
|
| QObject::tr(
|
| "Refer to cell by alias, for example\nSpreadsheet.my_alias_name instead of "
|
| "Spreadsheet.B1"
|
| )
|
| );
|
| ui->cellAlias->setStyleSheet(originalStylesheet);
|
| }
|
| }
|
|
|
| void SheetView::currentChanged(const QModelIndex& current, const QModelIndex& previous)
|
| {
|
| Q_UNUSED(current);
|
| Q_UNUSED(previous);
|
| updateContentLine();
|
| updateAliasLine();
|
| }
|
|
|
| void SheetView::updateCell(const App::Property* prop)
|
| {
|
| try {
|
| if (prop == &sheet->Label) {
|
| QString cap = QString::fromUtf8(sheet->Label.getValue());
|
| setWindowTitle(cap);
|
| }
|
| CellAddress address;
|
|
|
| if (!sheet->getCellAddress(prop, address)) {
|
| return;
|
| }
|
|
|
| if (currentIndex().row() == address.row() && currentIndex().column() == address.col()) {
|
| updateContentLine();
|
| updateAliasLine();
|
| }
|
| }
|
| catch (...) {
|
|
|
| return;
|
| }
|
| }
|
|
|
| std::vector<Range> SheetView::selectedRanges() const
|
| {
|
| return ui->cells->selectedRanges();
|
| }
|
|
|
| QModelIndexList SheetView::selectedIndexes() const
|
| {
|
| return ui->cells->selectionModel()->selectedIndexes();
|
| }
|
|
|
| QModelIndexList SheetView::selectedIndexesRaw() const
|
| {
|
| return ui->cells->selectedIndexesRaw();
|
| }
|
|
|
| void SpreadsheetGui::SheetView::select(App::CellAddress cell, QItemSelectionModel::SelectionFlags flags)
|
| {
|
| ui->cells->selectionModel()->select(model->index(cell.row(), cell.col()), flags);
|
| }
|
|
|
| void SpreadsheetGui::SheetView::select(
|
| App::CellAddress topLeft,
|
| App::CellAddress bottomRight,
|
| QItemSelectionModel::SelectionFlags flags
|
| )
|
| {
|
| ui->cells->selectionModel()->select(
|
| QItemSelection(
|
| model->index(topLeft.row(), topLeft.col()),
|
| model->index(bottomRight.row(), bottomRight.col())
|
| ),
|
| flags
|
| );
|
| }
|
|
|
| void SheetView::deleteSelection()
|
| {
|
| ui->cells->deleteSelection();
|
| }
|
|
|
| QModelIndex SheetView::currentIndex() const
|
| {
|
| return ui->cells->currentIndex();
|
| }
|
|
|
| void SpreadsheetGui::SheetView::setCurrentIndex(App::CellAddress cell) const
|
| {
|
| ui->cells->setCurrentIndex(model->index(cell.row(), cell.col()));
|
| }
|
|
|
| PyObject* SheetView::getPyObject()
|
| {
|
| if (!pythonObject) {
|
| pythonObject = new SheetViewPy(this);
|
| }
|
|
|
| Py_INCREF(pythonObject);
|
| return pythonObject;
|
| }
|
|
|
| void SheetView::deleteSelf()
|
| {
|
| Gui::MDIView::deleteSelf();
|
| }
|
|
|
|
|
|
|
| void SheetViewPy::init_type()
|
| {
|
| behaviors().name("SheetViewPy");
|
| behaviors().doc("Python binding class for the Sheet view class");
|
|
|
| behaviors().supportRepr();
|
| behaviors().supportGetattr();
|
| behaviors().supportSetattr();
|
|
|
| add_varargs_method(
|
| "selectedRanges",
|
| &SheetViewPy::selectedRanges,
|
| "selectedRanges(): Get a list of all selected ranges"
|
| );
|
| add_varargs_method(
|
| "selectedCells",
|
| &SheetViewPy::selectedCells,
|
| "selectedCells(): Get a list of all selected cells"
|
| );
|
| add_varargs_method(
|
| "select",
|
| &SheetViewPy::select,
|
| "select(cell,flags): Select (or deselect) the given cell, applying "
|
| "QItemSelectionModel.SelectionFlags\nselect(topLeft,bottomRight,flags): Select (or "
|
| "deselect) the given range, applying QItemSelectionModel.SelectionFlags"
|
| );
|
| add_varargs_method(
|
| "currentIndex",
|
| &SheetViewPy::currentIndex,
|
| "currentIndex(): Get the current index"
|
| );
|
| add_varargs_method(
|
| "setCurrentIndex",
|
| &SheetViewPy::setCurrentIndex,
|
| "setCurrentIndex(cell): Set the current index to the named cell (e.g. 'A1')"
|
| );
|
|
|
| add_varargs_method("getSheet", &SheetViewPy::getSheet, "getSheet()");
|
| add_varargs_method("cast_to_base", &SheetViewPy::cast_to_base, "cast_to_base() cast to MDIView class");
|
| behaviors().readyType();
|
| }
|
|
|
| SheetViewPy::SheetViewPy(SheetView* mdi)
|
| : base(mdi)
|
| {}
|
|
|
| SheetViewPy::~SheetViewPy() = default;
|
|
|
| Py::Object SheetViewPy::repr()
|
| {
|
| if (!getSheetViewPtr()) {
|
| throw Py::RuntimeError("Cannot print representation of deleted object");
|
| }
|
|
|
| return Py::String("SheetView");
|
| }
|
|
|
|
|
|
|
|
|
|
|
| Py::Object SheetViewPy::getattr(const char* attr)
|
| {
|
| if (!getSheetViewPtr()) {
|
| std::ostringstream s_out;
|
| s_out << "Cannot access attribute '" << attr << "' of deleted object";
|
| throw Py::RuntimeError(s_out.str());
|
| }
|
| std::string name(attr);
|
| if (name == "__dict__" || name == "__class__") {
|
| Py::Dict dict_self(BaseType::getattr("__dict__"));
|
| Py::Dict dict_base(base.getattr("__dict__"));
|
| for (const auto& it : dict_base) {
|
| dict_self.setItem(it.first, it.second);
|
| }
|
| return dict_self;
|
| }
|
|
|
| try {
|
| return BaseType::getattr(attr);
|
| }
|
| catch (Py::AttributeError& e) {
|
| e.clear();
|
| return base.getattr(attr);
|
| }
|
| }
|
|
|
| SheetView* SheetViewPy::getSheetViewPtr()
|
| {
|
| return qobject_cast<SheetView*>(base.getMDIViewPtr());
|
| }
|
|
|
| Py::Object SheetViewPy::getSheet(const Py::Tuple& args)
|
| {
|
| if (!PyArg_ParseTuple(args.ptr(), "")) {
|
| throw Py::Exception();
|
| }
|
| return Py::asObject(new Spreadsheet::SheetPy(getSheetViewPtr()->getSheet()));
|
| }
|
|
|
| Py::Object SheetViewPy::cast_to_base(const Py::Tuple&)
|
| {
|
| return Gui::MDIViewPy::create(base.getMDIViewPtr());
|
| }
|
|
|
| Py::Object SheetViewPy::selectedRanges(const Py::Tuple& args)
|
| {
|
| if (!PyArg_ParseTuple(args.ptr(), "")) {
|
| throw Py::Exception();
|
| }
|
| SheetView* sheetView = getSheetViewPtr();
|
| std::vector<App::Range> ranges = sheetView->selectedRanges();
|
| Py::List list;
|
| for (const auto& range : ranges) {
|
| list.append(Py::String(range.rangeString()));
|
| }
|
|
|
| return list;
|
| }
|
|
|
| Py::Object SheetViewPy::selectedCells(const Py::Tuple& args)
|
| {
|
| if (!PyArg_ParseTuple(args.ptr(), "")) {
|
| throw Py::Exception();
|
| }
|
| SheetView* sheetView = getSheetViewPtr();
|
| QModelIndexList cells = sheetView->selectedIndexes();
|
| Py::List list;
|
| for (const auto& cell : cells) {
|
| list.append(Py::String(App::CellAddress(cell.row(), cell.column()).toString()));
|
| }
|
|
|
| return list;
|
| }
|
|
|
| Py::Object SheetViewPy::select(const Py::Tuple& _args)
|
| {
|
| SheetView* sheetView = getSheetViewPtr();
|
|
|
| Py::Sequence args(_args.ptr());
|
|
|
| const char* cell;
|
| const char* topLeft;
|
| const char* bottomRight;
|
| int flags = 0;
|
| if (args.size() == 2 && PyArg_ParseTuple(_args.ptr(), "si", &cell, &flags)) {
|
| sheetView->select(
|
| App::CellAddress(cell),
|
| static_cast<QItemSelectionModel::SelectionFlags>(flags)
|
| );
|
| }
|
| else if (args.size() == 3
|
| && PyArg_ParseTuple(_args.ptr(), "ssi", &topLeft, &bottomRight, &flags)) {
|
| sheetView->select(
|
| App::CellAddress(topLeft),
|
| App::CellAddress(bottomRight),
|
| static_cast<QItemSelectionModel::SelectionFlags>(flags)
|
| );
|
| }
|
| else {
|
| if (args.size() == 2) {
|
| throw Base::TypeError(
|
| "Expects the arguments to be a cell name (e.g. 'A1') and "
|
| "QItemSelectionModel.SelectionFlags"
|
| );
|
| }
|
| else if (args.size() == 3) {
|
| throw Base::TypeError(
|
| "Expects the arguments to be a cell name (e.g. 'A1'), a second "
|
| "cell name (e.g. 'B5'), and QItemSelectionModel.SelectionFlags"
|
| );
|
| }
|
| else {
|
| throw Base::TypeError(
|
| "Wrong arguments to select: specify either a cell, or two cells "
|
| "(for a range), and QItemSelectionModel.SelectionFlags"
|
| );
|
| }
|
| }
|
| return Py::None();
|
| }
|
|
|
| Py::Object SheetViewPy::currentIndex(const Py::Tuple& args)
|
| {
|
| if (!PyArg_ParseTuple(args.ptr(), "")) {
|
| throw Py::Exception();
|
| }
|
| SheetView* sheetView = getSheetViewPtr();
|
| auto index = sheetView->currentIndex();
|
| Py::String str(App::CellAddress(index.row(), index.column()).toString());
|
| return str;
|
| }
|
|
|
| Py::Object SheetViewPy::setCurrentIndex(const Py::Tuple& args)
|
| {
|
| SheetView* sheetView = getSheetViewPtr();
|
|
|
| const char* cell;
|
| if (PyArg_ParseTuple(args.ptr(), "s", &cell)) {
|
| sheetView->setCurrentIndex(App::CellAddress(cell));
|
| }
|
| return Py::None();
|
| }
|
|
|
|
|
| #include "moc_SpreadsheetView.cpp"
|
|
|
