412 lines
17 KiB
C++
412 lines
17 KiB
C++
/***************************************************************************
|
|
* Copyright (c) 2015 Yorik van Havre <yorik@uncreated.net> *
|
|
* Copyright (c) 2016 WandererFan <wandererfan@gmail.com> *
|
|
* *
|
|
* This file is part of the FreeCAD CAx development system. *
|
|
* *
|
|
* This library is free software; you can redistribute it and/or *
|
|
* modify it under the terms of the GNU Library General Public *
|
|
* License as published by the Free Software Foundation; either *
|
|
* version 2 of the License, or (at your option) any later version. *
|
|
* *
|
|
* This library is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU Library General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU Library General Public *
|
|
* License along with this library; see the file COPYING.LIB. If not, *
|
|
* write to the Free Software Foundation, Inc., 59 Temple Place, *
|
|
* Suite 330, Boston, MA 02111-1307, USA *
|
|
* *
|
|
***************************************************************************/
|
|
|
|
#include "PreCompiled.h"
|
|
|
|
#ifndef _PreComp_
|
|
#include <iomanip>
|
|
#include <sstream>
|
|
#include <boost_regex.hpp>
|
|
#endif
|
|
|
|
#include <App/Property.h>
|
|
#include <Base/Console.h>
|
|
#include <Base/Tools.h>
|
|
|
|
#include <Mod/Spreadsheet/App/Cell.h>
|
|
#include <Mod/Spreadsheet/App/Sheet.h>
|
|
|
|
#include "DrawUtil.h"
|
|
#include "Preferences.h"
|
|
|
|
#include "DrawViewSpreadsheet.h"
|
|
|
|
using namespace TechDraw;
|
|
|
|
//===========================================================================
|
|
// DrawViewSpreadsheet
|
|
//===========================================================================
|
|
|
|
PROPERTY_SOURCE(TechDraw::DrawViewSpreadsheet, TechDraw::DrawViewSymbol)
|
|
|
|
DrawViewSpreadsheet::DrawViewSpreadsheet()
|
|
{
|
|
static const char *vgroup = "Spreadsheet";
|
|
|
|
ADD_PROPERTY_TYPE(Source ,(nullptr), vgroup, App::Prop_None, "Spreadsheet to view");
|
|
Source.setScope(App::LinkScope::Global);
|
|
ADD_PROPERTY_TYPE(CellStart ,("A1"), vgroup, App::Prop_None, "The top left cell of the range to display");
|
|
ADD_PROPERTY_TYPE(CellEnd ,("B2"), vgroup, App::Prop_None, "The bottom right cell of the range to display");
|
|
ADD_PROPERTY_TYPE(Font ,(Preferences::labelFont().c_str()),
|
|
vgroup, App::Prop_None, "The name of the font to use");
|
|
ADD_PROPERTY_TYPE(TextColor, (0.0f, 0.0f, 0.0f), vgroup, App::Prop_None, "The default color of the text and lines");
|
|
ADD_PROPERTY_TYPE(TextSize, (12.0), vgroup, App::Prop_None, "The size of the text");
|
|
ADD_PROPERTY_TYPE(LineWidth, (0.35), vgroup, App::Prop_None, "The thickness of the cell lines");
|
|
|
|
ADD_PROPERTY_TYPE(Owner, (nullptr), vgroup, (App::PropertyType)(App::Prop_None),
|
|
"Feature to which this sheet is attached");
|
|
|
|
EditableTexts.setStatus(App::Property::Hidden, true);
|
|
|
|
}
|
|
|
|
DrawViewSpreadsheet::~DrawViewSpreadsheet()
|
|
{
|
|
}
|
|
|
|
short DrawViewSpreadsheet::mustExecute() const
|
|
{
|
|
if (!isRestoring()) {
|
|
if (
|
|
Source.isTouched() ||
|
|
CellStart.isTouched() ||
|
|
CellEnd.isTouched() ||
|
|
Font.isTouched() ||
|
|
TextSize.isTouched() ||
|
|
TextColor.isTouched() ||
|
|
LineWidth.isTouched()
|
|
) {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return TechDraw::DrawView::mustExecute();
|
|
}
|
|
|
|
void DrawViewSpreadsheet::onChanged(const App::Property* prop)
|
|
{
|
|
TechDraw::DrawView::onChanged(prop);
|
|
}
|
|
|
|
App::DocumentObjectExecReturn *DrawViewSpreadsheet::execute()
|
|
{
|
|
App::DocumentObject* link = Source.getValue();
|
|
std::string scellstart = CellStart.getValue();
|
|
std::string scellend = CellEnd.getValue();
|
|
if (!link)
|
|
return new App::DocumentObjectExecReturn("No spreadsheet linked");
|
|
if (!link->isDerivedFrom<Spreadsheet::Sheet>())
|
|
return new App::DocumentObjectExecReturn("The linked object is not a spreadsheet");
|
|
if (scellstart.empty() || scellend.empty())
|
|
return new App::DocumentObjectExecReturn("Empty cell value");
|
|
|
|
Symbol.setValue(getSheetImage());
|
|
|
|
overrideKeepUpdated(false);
|
|
return TechDraw::DrawView::execute();
|
|
}
|
|
|
|
std::vector <std::string> DrawViewSpreadsheet::getAvailColumns()
|
|
{
|
|
// builds a list of available columns: A, B, ... Y, Z, AA, AB, ... ZY, ZZ.
|
|
const std::string alphabet [] {"A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"};
|
|
|
|
std::vector <std::string> availcolumns { std::begin (alphabet), std::end (alphabet) };
|
|
|
|
for (const std::string &left : alphabet)
|
|
for (const std::string &right : alphabet)
|
|
availcolumns.push_back(left + right);
|
|
|
|
return availcolumns;
|
|
}
|
|
|
|
std::string DrawViewSpreadsheet::getSVGHead()
|
|
{
|
|
return std::string("<svg\n") +
|
|
std::string(" xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\"\n") +
|
|
std::string(" xmlns:freecad=\"https://www.freecad.org/wiki/index.php?title=Svg_Namespace\">\n");
|
|
}
|
|
|
|
std::string DrawViewSpreadsheet::getSVGTail()
|
|
{
|
|
return "\n</svg>";
|
|
}
|
|
|
|
std::string DrawViewSpreadsheet::getSheetImage()
|
|
{
|
|
App::DocumentObject* link = Source.getValue();
|
|
link->recomputeFeature(); //make sure s/s is up to date
|
|
|
|
std::string scellstart = CellStart.getValue();
|
|
std::string scellend = CellEnd.getValue();
|
|
|
|
//s/s columns are A, B,C, ... ZX, ZY, ZZ
|
|
//lower case characters are not valid
|
|
transform(scellstart.begin(), scellstart.end(), scellstart.begin(), ::toupper);
|
|
transform(scellend.begin(), scellend.end(), scellend.begin(), ::toupper);
|
|
|
|
std::string colPart;
|
|
std::string rowPart;
|
|
boost::regex re{"([A-Z]*)([0-9]*)"};
|
|
boost::smatch what;
|
|
int iRowStart = 0, iRowEnd = 0;
|
|
std::string sColStart, sColEnd;
|
|
if (boost::regex_search(scellstart, what, re)) {
|
|
if (what.size() < 3) {
|
|
Base::Console().Error("%s - start cell (%s) is invalid\n", getNameInDocument(),
|
|
CellStart.getValue());
|
|
return std::string();
|
|
}
|
|
|
|
colPart = what[1];
|
|
sColStart = colPart;
|
|
rowPart = what[2];
|
|
try {
|
|
iRowStart = std::stoi(rowPart);
|
|
}
|
|
catch (...) {
|
|
Base::Console().Error("%s - start cell (%s) invalid row\n",
|
|
getNameInDocument(), rowPart.c_str());
|
|
return std::string();
|
|
}
|
|
}
|
|
|
|
if (boost::regex_search(scellend, what, re)) {
|
|
if (what.size() < 3) {
|
|
Base::Console().Error("%s - end cell (%s) is invalid\n", getNameInDocument(), CellEnd.getValue());
|
|
} else {
|
|
colPart = what[1];
|
|
sColEnd = colPart;
|
|
rowPart = what[2];
|
|
try {
|
|
iRowEnd = std::stoi(rowPart);
|
|
}
|
|
catch (...) {
|
|
Base::Console().Error("%s - end cell (%s) invalid row\n",
|
|
getNameInDocument(), rowPart.c_str());
|
|
return std::string();
|
|
}
|
|
}
|
|
}
|
|
|
|
const std::vector <std::string> availcolumns = getAvailColumns();
|
|
|
|
//validate range start column in sheet's available columns
|
|
int iAvailColStart = colInList(availcolumns, sColStart);
|
|
if (iAvailColStart < 0) { //not found range start column in availcolumns list
|
|
Base::Console().Error("DVS - %s - start Column (%s) is invalid\n",
|
|
getNameInDocument(), sColStart.c_str());
|
|
return std::string();
|
|
}
|
|
|
|
//validate range end column in sheet's available columns
|
|
int iAvailColEnd = colInList(availcolumns, sColEnd);
|
|
if (iAvailColEnd < 0) {
|
|
Base::Console().Error("DVS - %s - end Column (%s) is invalid\n",
|
|
getNameInDocument(), sColEnd.c_str());
|
|
return std::string();
|
|
}
|
|
|
|
//check for logical range
|
|
if ( (iAvailColStart > iAvailColEnd) ||
|
|
(iRowStart > iRowEnd) ) {
|
|
Base::Console().Error("%s - cell range is illogical\n", getNameInDocument());
|
|
return std::string();
|
|
}
|
|
|
|
// build row and column ranges
|
|
std::vector<std::string> validColNames;
|
|
std::vector<int> validRowNumbers;
|
|
|
|
int iCol = iAvailColStart;
|
|
for (; iCol <= iAvailColEnd; iCol++) {
|
|
validColNames.push_back(availcolumns.at(iCol));
|
|
}
|
|
|
|
int iRow = iRowStart;
|
|
for ( ; iRow <= iRowEnd ; iRow++) {
|
|
validRowNumbers.push_back(iRow);
|
|
}
|
|
|
|
// create the SVG code
|
|
std::stringstream result;
|
|
result << getSVGHead();
|
|
|
|
std::string ViewName = Label.getValue();
|
|
Base::Color c = TextColor.getValue();
|
|
result << "<g id=\"" << ViewName << "\">" << std::endl;
|
|
|
|
// fill the cells
|
|
float rowoffset = 0.0;
|
|
float coloffset = 0.0;
|
|
float cellheight = 100;
|
|
float cellwidth = 100;
|
|
std::string celltext;
|
|
Spreadsheet::Sheet* sheet = static_cast<Spreadsheet::Sheet*>(link);
|
|
std::vector<std::string> skiplist;
|
|
|
|
for (std::vector<std::string>::const_iterator col = validColNames.begin();
|
|
col != validColNames.end(); ++col) {
|
|
// create a group for each column
|
|
result << " <g id=\"" << ViewName << "_col" << (*col) << "\">" << std::endl;
|
|
for (std::vector<int>::const_iterator row = validRowNumbers.begin();
|
|
row != validRowNumbers.end(); ++row) {
|
|
// get cell size
|
|
std::stringstream srow;
|
|
srow << (*row);
|
|
App::CellAddress address((*col) + srow.str());
|
|
cellwidth = sheet->getColumnWidth(address.col());
|
|
cellheight = sheet->getRowHeight(address.row());
|
|
celltext = "";
|
|
Spreadsheet::Cell* cell = sheet->getCell(address);
|
|
// get the text
|
|
App::Property* prop = sheet->getPropertyByName(address.toString().c_str());
|
|
std::stringstream field;
|
|
if (prop && cell) {
|
|
if (prop->isDerivedFrom<App::PropertyQuantity>()) {
|
|
auto contentAsQuantity = static_cast<App::PropertyQuantity*>(prop)->getQuantityValue();
|
|
field << contentAsQuantity.getUserString();
|
|
} else if (prop->isDerivedFrom<App::PropertyFloat>() ||
|
|
prop->isDerivedFrom<App::PropertyInteger>()) {
|
|
std::string temp = cell->getFormattedQuantity();
|
|
DrawUtil::encodeXmlSpecialChars(temp);
|
|
field << temp;
|
|
} else if (prop->isDerivedFrom<App::PropertyString>()) {
|
|
std::string temp = static_cast<App::PropertyString*>(prop)->getValue();
|
|
DrawUtil::encodeXmlSpecialChars(temp);
|
|
field << temp;
|
|
} else {
|
|
Base::Console().Error("DVSS: Unknown property type\n");
|
|
}
|
|
celltext = field.str();
|
|
}
|
|
// get colors, style, alignment and span
|
|
int alignment = 0;
|
|
std::string bcolor = "none";
|
|
std::string fcolor = c.asHexString();
|
|
std::string textstyle;
|
|
if (cell) {
|
|
Base::Color f, b;
|
|
std::set<std::string> st;
|
|
int colspan, rowspan;
|
|
if (cell->getBackground(b)) {
|
|
bcolor = b.asHexString();
|
|
}
|
|
if (cell->getForeground(f)) {
|
|
fcolor = f.asHexString();
|
|
}
|
|
if (cell->getStyle(st)) {
|
|
for (std::set<std::string>::const_iterator i = st.begin(); i != st.end(); ++i) {
|
|
if ((*i) == "bold")
|
|
textstyle += "font-weight: bold; ";
|
|
else if ((*i) == "italic")
|
|
textstyle += "font-style: italic; ";
|
|
else if ((*i) == "underline")
|
|
textstyle += "text-decoration: underline; ";
|
|
}
|
|
}
|
|
if (cell->getSpans(rowspan, colspan)) {
|
|
for (int i=0; i<colspan; ++i) {
|
|
for (int j=0; j<rowspan; ++j) {
|
|
App::CellAddress nextcell(address.row()+j, address.col()+i);
|
|
if (i > 0)
|
|
cellwidth += sheet->getColumnWidth(nextcell.col());
|
|
if (j > 0)
|
|
cellheight += sheet->getRowHeight(nextcell.row());
|
|
if ( (i > 0) || (j > 0) )
|
|
skiplist.push_back(nextcell.toString());
|
|
}
|
|
}
|
|
}
|
|
cell->getAlignment(alignment);
|
|
}
|
|
// skip cell if found in skiplist
|
|
if (std::ranges::find(skiplist, address.toString()) == skiplist.end()) {
|
|
result << " <rect x=\"" << coloffset << "\" y=\"" << rowoffset << "\" width=\""
|
|
<< cellwidth << "\" height=\"" << cellheight << "\" style=\"fill:" << bcolor
|
|
<< ";stroke-width:" << LineWidth.getValue() / getScale()
|
|
<< ";stroke:" << c.asHexString() << ";\" />" << std::endl;
|
|
if (alignment & Spreadsheet::Cell::ALIGNMENT_LEFT)
|
|
result << " <text style=\"" << textstyle << "\" x=\""
|
|
<< coloffset + TextSize.getValue() / 2 << "\" y=\""
|
|
<< rowoffset + 0.75 * cellheight << "\" font-family=\"";
|
|
if (alignment & Spreadsheet::Cell::ALIGNMENT_HCENTER)
|
|
result << " <text text-anchor=\"middle\" style=\"" << textstyle << "\" x=\""
|
|
<< coloffset + cellwidth / 2 << "\" y=\""
|
|
<< rowoffset + 0.75 * cellheight << "\" font-family=\"";
|
|
if (alignment & Spreadsheet::Cell::ALIGNMENT_RIGHT)
|
|
result << " <text text-anchor=\"end\" style=\"" << textstyle << "\" x=\""
|
|
<< coloffset + (cellwidth - TextSize.getValue() / 2) << "\" y=\""
|
|
<< rowoffset + 0.75 * cellheight << "\" font-family=\"";
|
|
if ((alignment & Spreadsheet::Cell::ALIGNMENT_LEFT)
|
|
|| (alignment & Spreadsheet::Cell::ALIGNMENT_HCENTER)
|
|
|| (alignment & Spreadsheet::Cell::ALIGNMENT_RIGHT)) {
|
|
result << Font.getValue() << "\""
|
|
<< " font-size=\"" << TextSize.getValue() << "\""
|
|
<< " fill=\"" << fcolor << "\">" << celltext << "</text>" << std::endl;
|
|
}
|
|
if (!(alignment & Spreadsheet::Cell::ALIGNMENT_LEFT) &&
|
|
!(alignment & Spreadsheet::Cell::ALIGNMENT_RIGHT) &&
|
|
!(alignment & Spreadsheet::Cell::ALIGNMENT_HCENTER) ) {
|
|
// no horizontal alignment specified, so we will default to
|
|
// Spreadsheet::Cell::ALIGNMENT_LEFT
|
|
result << " <text style=\"" << textstyle << "\" x=\""
|
|
<< coloffset + TextSize.getValue() / 2 << "\" y=\""
|
|
<< rowoffset + 0.75 * cellheight << "\" font-family=\"";
|
|
result << Font.getValue() << "\""
|
|
<< " font-size=\"" << TextSize.getValue() << "\""
|
|
<< " fill=\"" << fcolor << "\">" << celltext << "</text>" << std::endl;
|
|
}
|
|
}
|
|
rowoffset += sheet->getRowHeight(address.row());
|
|
}
|
|
result << " </g>" << std::endl;
|
|
rowoffset = 0.0;
|
|
coloffset += cellwidth;
|
|
}
|
|
|
|
// close the containing group
|
|
result << "</g>" << std::endl;
|
|
|
|
result << getSVGTail();
|
|
|
|
return result.str();
|
|
|
|
}
|
|
|
|
//find index of column name "toFind" in "list" of column names
|
|
int DrawViewSpreadsheet::colInList(const std::vector<std::string>& list,
|
|
const std::string& toFind)
|
|
{
|
|
const auto match = std::ranges::find(list, toFind);
|
|
if (match == std::end(list)) {
|
|
return -1; // Error value
|
|
}
|
|
|
|
return match - std::begin(list);
|
|
}
|
|
|
|
// Python Drawing feature ---------------------------------------------------------
|
|
|
|
namespace App {
|
|
/// @cond DOXERR
|
|
PROPERTY_SOURCE_TEMPLATE(TechDraw::DrawViewSpreadsheetPython, TechDraw::DrawViewSpreadsheet)
|
|
template<> const char* TechDraw::DrawViewSpreadsheetPython::getViewProviderName() const {
|
|
return "TechDrawGui::ViewProviderSpreadsheet";
|
|
}
|
|
/// @endcond
|
|
|
|
// explicit template instantiation
|
|
template class TechDrawExport FeaturePythonT<TechDraw::DrawViewSpreadsheet>;
|
|
}
|