File indexing completed on 2024-04-28 04:34:03
0001 /* This file is part of the TikZKit project. 0002 * 0003 * Copyright (C) 2013-2015 Dominik Haumann <dhaumann@kde.org> 0004 * 0005 * This library is free software; you can redistribute it and/or modify 0006 * it under the terms of the GNU Library General Public License as published 0007 * by the Free Software Foundation, either version 2 of the License, or 0008 * (at your option) any later version. 0009 * 0010 * This library is distributed in the hope that it will be useful, 0011 * but WITHOUT ANY WARRANTY; without even the implied warranty of 0012 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 0013 * GNU Library General Public License for more details. 0014 * 0015 * You should have received a copy of the GNU Library General Public License 0016 * along with this library; see the file COPYING.LIB. If not, see 0017 * <http://www.gnu.org/licenses/>. 0018 */ 0019 0020 #include "tikz.h" 0021 0022 #include <QDebug> 0023 0024 namespace tikz { 0025 0026 namespace { 0027 std::function<void(LogType, const QString &)> s_logFunc 0028 = [](LogType, const QString & text) { 0029 qDebug() << text; 0030 }; 0031 } 0032 0033 void setLogFunction(std::function<void(LogType, const QString &)> logFunc) 0034 { 0035 s_logFunc = logFunc; 0036 } 0037 0038 void unsetLogFunction() 0039 { 0040 s_logFunc = [](LogType, const QString & text) { 0041 qDebug() << text; }; 0042 } 0043 0044 void log(LogType level, const QString & text) 0045 { 0046 s_logFunc(level, text); 0047 } 0048 0049 QString toString(EntityType type) 0050 { 0051 switch (type) { 0052 case EntityType::Document : return QStringLiteral("Document"); 0053 case EntityType::Style : return QStringLiteral("Style"); 0054 case EntityType::Node : return QStringLiteral("Node"); 0055 case EntityType::Path : return QStringLiteral("Path"); 0056 default: break; 0057 } 0058 Q_ASSERT(false); 0059 return QString(); 0060 } 0061 0062 EntityType toEntityType(const QString & str) 0063 { 0064 if (str == QStringLiteral("Document")) { 0065 return EntityType::Document; 0066 } else if (str == QStringLiteral("Style")) { 0067 return EntityType::Style; 0068 } else if (str == QStringLiteral("Node")) { 0069 return EntityType::Node; 0070 } else if (str == QStringLiteral("Path")) { 0071 return EntityType::Path; 0072 } 0073 0074 Q_ASSERT(false); 0075 return EntityType::Document; 0076 } 0077 0078 QString toString(tikz::Unit unit) 0079 { 0080 switch (unit) { 0081 case Unit::Point: return "pt"; 0082 case Unit::Millimeter: return "mm"; 0083 case Unit::Centimeter: return "cm"; 0084 case Unit::Inch: return "in"; 0085 default: break; 0086 } 0087 0088 Q_ASSERT(false); 0089 return "cm"; 0090 } 0091 0092 template<> 0093 Unit toEnum<Unit>(const QString & unit) 0094 { 0095 if (unit == QStringLiteral("pt")) { 0096 return Unit::Point; 0097 } else if (unit == QStringLiteral("mm")) { 0098 return Unit::Millimeter; 0099 } else if (unit == QStringLiteral("cm")) { 0100 return Unit::Centimeter; 0101 } else if (unit == QStringLiteral("in")) { 0102 return Unit::Inch; 0103 } 0104 0105 Q_ASSERT(false); 0106 return Unit::Centimeter; 0107 } 0108 0109 QString toString(tikz::TextAlignment alignment) 0110 { 0111 switch (alignment) { 0112 case TextAlignment::NoAlign: return "none"; 0113 case TextAlignment::AlignLeft: return "left"; 0114 case TextAlignment::AlignCenter: return "center"; 0115 case TextAlignment::AlignRight: return "right"; 0116 case TextAlignment::AlignJustify: return "justify"; 0117 default: Q_ASSERT(false); 0118 } 0119 0120 return QString(); 0121 } 0122 0123 template<> 0124 TextAlignment toEnum<TextAlignment>(const QString & alignment) 0125 { 0126 if (alignment == "none") { 0127 return TextAlignment::NoAlign; 0128 } else if (alignment == "left") { 0129 return TextAlignment::AlignLeft; 0130 } else if (alignment == "center") { 0131 return TextAlignment::AlignCenter; 0132 } else if (alignment == "right") { 0133 return TextAlignment::AlignRight; 0134 } else if (alignment == "justify") { 0135 return TextAlignment::AlignJustify; 0136 } 0137 0138 Q_ASSERT(false); 0139 0140 return TextAlignment::NoAlign; 0141 } 0142 0143 QString toString(tikz::Shape shape) 0144 { 0145 switch (shape) { 0146 case Shape::NoShape: return QString(); 0147 case Shape::ShapeRectangle: return "rectangle"; 0148 case Shape::ShapeCircle: return "circle"; 0149 case Shape::ShapeDiamond: return "diamond"; 0150 case Shape::ShapeEllipse: return "ellipse"; 0151 default: Q_ASSERT(false); break; 0152 } 0153 0154 return QString(); 0155 } 0156 0157 template<> 0158 Shape toEnum<Shape>(const QString & shape) 0159 { 0160 if (shape.isEmpty()) { 0161 return Shape::NoShape; 0162 } else if (shape == "rectangle") { 0163 return Shape::ShapeRectangle; 0164 } else if (shape == "circle") { 0165 return Shape::ShapeCircle; 0166 } else if (shape == "diamond") { 0167 return Shape::ShapeDiamond; 0168 } else if (shape == "ellipse") { 0169 return Shape::ShapeEllipse; 0170 } 0171 0172 Q_ASSERT(false); 0173 0174 return tikz::Shape::NoShape; 0175 } 0176 0177 QString toString(tikz::PenStyle ps) 0178 { 0179 switch (ps) { 0180 case PenStyle::SolidLine: return "solid"; 0181 case PenStyle::DottedLine: return "dotted"; 0182 case PenStyle::DenselyDottedLine: return "densely dotted"; 0183 case PenStyle::LooselyDottedLine: return "loosely dotted"; 0184 case PenStyle::DashedLine: return "dashed"; 0185 case PenStyle::DenselyDashedLine: return "densely dashed"; 0186 case PenStyle::LooselyDashedLine: return "loosely dashed"; 0187 case PenStyle::DashDottedLine: return "dashdotted"; 0188 case PenStyle::DenselyDashDottedLine: return "densely dashdotted"; 0189 case PenStyle::LooselyDashDottedLine: return "loosely dashdotted"; 0190 case PenStyle::DashDotDottedLine: return "dashdotdotted"; 0191 case PenStyle::DenselyDashDotDottedLine: return "densely dashdotdotted"; 0192 case PenStyle::LooselyDashDotDottedLine: return "loosely dashdotdotted"; 0193 default: Q_ASSERT(false); 0194 } 0195 return QString(); 0196 } 0197 0198 template<> 0199 PenStyle toEnum<PenStyle>(const QString & penStyle) 0200 { 0201 if (penStyle == "solid") { 0202 return PenStyle::SolidLine; 0203 } else if (penStyle == "dotted") { 0204 return PenStyle::DottedLine; 0205 } else if (penStyle == "densely dotted") { 0206 return PenStyle::DenselyDottedLine; 0207 } else if (penStyle == "loosely dotted") { 0208 return PenStyle::LooselyDottedLine; 0209 } else if (penStyle == "dashed") { 0210 return PenStyle::DashedLine; 0211 } else if (penStyle == "densely dashed") { 0212 return PenStyle::DenselyDashedLine; 0213 } else if (penStyle == "loosely dashed") { 0214 return PenStyle::LooselyDashedLine; 0215 } else if (penStyle == "dashdotted") { 0216 return PenStyle::DashDottedLine; 0217 } else if (penStyle == "densely dashdotted") { 0218 return PenStyle::DenselyDashDottedLine; 0219 } else if (penStyle == "loosely dashdotted") { 0220 return PenStyle::LooselyDashDottedLine; 0221 } else if (penStyle == "dashdotdotted") { 0222 return PenStyle::DashDotDottedLine; 0223 } else if (penStyle == "densely dashdotdotted") { 0224 return PenStyle::DenselyDashDotDottedLine; 0225 } else if (penStyle == "loosely dashdotdotted") { 0226 return PenStyle::LooselyDashDotDottedLine; 0227 } 0228 0229 Q_ASSERT(false); 0230 0231 return PenStyle::SolidLine; 0232 } 0233 0234 QString toString(tikz::Arrow arrow) 0235 { 0236 switch (arrow) { 0237 case Arrow::NoArrow: return QString(); 0238 case Arrow::ToArrow: return "to"; 0239 case Arrow::ReversedToArrow: return "to reversed"; 0240 case Arrow::StealthArrow: return "stealth"; 0241 case Arrow::ReversedStealthArrow: return "stealth reversed"; 0242 case Arrow::LatexArrow: return "latex"; 0243 case Arrow::ReversedLatexArrow: return "latex reversed"; 0244 case Arrow::PipeArrow: return "|"; 0245 case Arrow::StealthTickArrow: return "stealth'"; 0246 case Arrow::ReversedStealthTickArrow: return "stealth' reversed"; 0247 default: Q_ASSERT(false); break; 0248 } 0249 0250 return QString(); 0251 } 0252 0253 template<> 0254 Arrow toEnum<Arrow>(const QString & arrow) 0255 { 0256 if (arrow.isEmpty()) { 0257 return Arrow::NoArrow; 0258 } else if (arrow == "to") { 0259 return Arrow::ToArrow; 0260 } else if (arrow == "to reversed") { 0261 return Arrow::ReversedToArrow; 0262 } else if (arrow == "stealth") { 0263 return Arrow::StealthArrow; 0264 } else if (arrow == "stealth reversed") { 0265 return Arrow::ReversedStealthArrow; 0266 } else if (arrow == "latex") { 0267 return Arrow::LatexArrow; 0268 } else if (arrow == "latex reversed") { 0269 return Arrow::ReversedLatexArrow; 0270 } else if (arrow == "|") { 0271 return Arrow::PipeArrow; 0272 } else if (arrow == "stealth'") { 0273 return Arrow::StealthTickArrow; 0274 } else if (arrow == "stealth' reversed") { 0275 return Arrow::ReversedStealthTickArrow; 0276 } 0277 0278 Q_ASSERT(false); 0279 0280 return Arrow::NoArrow; 0281 } 0282 0283 QString toString(tikz::PathType type) 0284 { 0285 switch (type) { 0286 case PathType::Invalid: Q_ASSERT(false); return "to"; 0287 case PathType::Line: return "to"; 0288 case PathType::HVLine: return "-|"; 0289 case PathType::VHLine: return "|-"; 0290 case PathType::BendCurve: return "bend"; 0291 case PathType::InOutCurve: return "in-out"; 0292 case PathType::BezierCurve: return "bezier"; 0293 case PathType::Ellipse: return "ellipse"; 0294 case PathType::Rectangle: return "rectangle"; 0295 case PathType::Grid: return "grid"; 0296 } 0297 0298 Q_ASSERT(false); 0299 0300 return QString(); 0301 } 0302 0303 template<> 0304 PathType toEnum<PathType>(const QString & type) 0305 { 0306 const PathType t 0307 = (type == "to") ? PathType::Line 0308 : (type == "-|") ? PathType::HVLine 0309 : (type == "|-") ? PathType::VHLine 0310 : (type == "bend") ? PathType::BendCurve 0311 : (type == "in-out") ? PathType::InOutCurve 0312 : (type == "bezier") ? PathType::BezierCurve 0313 : (type == "ellipse") ? PathType::Ellipse 0314 : (type == "rectangle") ? PathType::Rectangle 0315 : (type == "grid") ? PathType::Grid 0316 : PathType::Invalid; 0317 0318 Q_ASSERT(t != PathType::Invalid); 0319 0320 return t; 0321 } 0322 0323 } // namespace tikz 0324 0325 // kate: indent-width 4; replace-tabs on;