mirrors/JKQtPlotter
1
0
Fork 0
mirror of https://github.com/jkriege2/JKQtPlotter.git synced 2024-12-26 10:31:39 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
1bf6c43134
JKQtPlotter/lib/jkqtcommon/jkqtpcsstools.cpp
jkriege2 868d6dcdf4 fixed several compile warnings
2024-01-23 13:09:37 +01:00

421 lines
16 KiB
C++
Raw Blame History

/*
Copyright (c) 2008-2024 Jan W. Krieger (<jan@jkrieger.de>)
This software is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License (LGPL) as published by
the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
This program 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 Lesser General Public License (LGPL) for more details.
You should have received a copy of the GNU Lesser General Public License (LGPL)
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "jkqtcommon/jkqtpcsstools.h"
#include "jkqtcommon/jkqtpstringtools.h"
#include "jkqtcommon/jkqtpcodestructuring.h"
#include <stdexcept>
#include <QMetaEnum>
#include <QSet>
#include <QVector>
JKQTPCSSParser::RawErrorTag_t JKQTPCSSParser::RawErrorTag={};
JKQTPCSSParser::Token JKQTPCSSParser::peekNextToken(int *endPos)
{
// on "RETURN" fromm this function: reset to current status and store the new pos in oldPos (if !=nullptr)
auto _final=JKQTPFinally(std::bind([&](JKQTPCSSParser* p, const Token oldToken, const int oldPos){
if (endPos) *endPos=p->pos;
p->CurrentToken=oldToken;
p->pos=oldPos;
}, this, CurrentToken, pos));
QChar ch('\0');
while(getCh(ch) && ch.isSpace()) {
}
static QString hexDigits="0123456789abcdefABCDEF";
if (ch==QChar('\0')) return Token(Token::END);
else if (ch==QChar(',')) return Token(Token::COMMA);
else if (ch==QChar('(')) return Token(Token::LBRACKET);
else if (ch==QChar(')')) return Token(Token::RBRACKET);
else if (ch==QChar('/')) return Token(Token::SLASH);
else if (ch==QChar('#')) {
QString hex;
while (peekCh(ch) && hexDigits.contains(ch)) {
getCh(ch);
hex+=ch;
}
if (hex.size()==0) throw std::runtime_error(QString("did not find HEX digits after a HASH '#' at pos.%1!").arg(pos).toStdString());
return Token(hex,Token::HEXSTRING);
} else if (ch.isDigit() || ch=='+' || ch=='-' || ch=='.') {
QString num=ch;
QString unit;
while (peekCh(ch) && (ch.isDigit() || ch=='.')) {
getCh(ch);
num+=ch;
}
if (ch.isLetter() || ch=='\xB0' || ch=='%') {
unit=ch;
getCh(ch);
while (peekCh(ch) && (ch.isLetter() || ch=='\xB0' || ch=='%')) {
getCh(ch);
unit+=ch;
}
}
return Token(num.toDouble(), unit);
} else if (ch.isLetter()) {
QString name=ch;
while (peekCh(ch) && (ch.isLetterOrNumber() ||ch=='-' || ch=='_'|| ch=='.')) {
getCh(ch);
name+=ch;
}
return Token(name);
} else {
throw std::runtime_error(QString("found unexpected character '%1' at pos.%2").arg(ch).arg(pos).toStdString());
}
return Token::END;
}
JKQTPCSSParser::Token JKQTPCSSParser::getToken()
{
int newpos=pos;
const auto newT=peekNextToken(&newpos);
pos=newpos;
return CurrentToken=newT;
}
JKQTPExpected<JKQTPCSSParser::NumberWithUnit, JKQTPCSSParser::GeneralError> JKQTPCSSParser::parseNumberWithUnit(bool get)
{
NumberWithUnit num = NumberWithUnit(0.0,"");
if (get) getToken();
if (CurrentToken.is(Token::TokenType::NUMBER)) {
num=NumberWithUnit(CurrentToken.NumberValue, CurrentToken.StringValue);
} else {
return {JKQTPUnexpected, UnexpectedTokenError(Token::NUMBER, CurrentToken, pos) };
}
return { num };
}
JKQTPExpected<QColor, JKQTPCSSParser::GeneralError> JKQTPCSSParser::parseColor(bool get)
{
QColor col=Qt::black;
if (get) getToken();
if (CurrentToken.is(Token::TokenType::HEXSTRING)) {
const QString hex=CurrentToken.StringValue;
if (hex.size()==3) {
const int r=QString(hex[0]).toInt(nullptr, 16);
const int g=QString(hex[1]).toInt(nullptr, 16);
const int b=QString(hex[2]).toInt(nullptr, 16);
col=QColor::fromRgb(r*16+r,g*16+g,b*16+b);
} else if (hex.size()==4) {
const int r=QString(hex[0]).toInt(nullptr, 16);
const int g=QString(hex[1]).toInt(nullptr, 16);
const int b=QString(hex[2]).toInt(nullptr, 16);
const int a=QString(hex[3]).toInt(nullptr, 16);
col=QColor::fromRgb(r*16+r,g*16+g,b*16+b,a*16+a);
} else if (hex.size()==6) {
col=QColor::fromRgb(hex.mid(0,2).toInt(nullptr, 16),hex.mid(2,2).toInt(nullptr, 16),hex.mid(4,2).toInt(nullptr, 16));
} else if (hex.size()==8) {
col=QColor::fromRgb(hex.mid(0,2).toInt(nullptr, 16),hex.mid(2,2).toInt(nullptr, 16),hex.mid(4,2).toInt(nullptr, 16),hex.mid(6,2).toInt(nullptr, 16));
} else {
return {JKQTPUnexpected, UnconvertobleError("#"+hex, "HEX-RGB value", pos) };
}
} else if (CurrentToken.is(Token::TokenType::NAME)) {
static QMap<QString,QPair<int,int>> rgbFuncs={
{"rgb", QPair<int,int>(3,4)},
{"rgba",QPair<int,int>(4,4)},
{"hsl",QPair<int,int>(3,4)},
{"hsv",QPair<int,int>(3,4)},
{"gray",QPair<int,int>(1,2)},
{"grey",QPair<int,int>(1,2)},
{"red",QPair<int,int>(1,2)},
{"green",QPair<int,int>(1,2)},
{"blue",QPair<int,int>(1,2)}
};
const QString func=CurrentToken.getNormString();
if (rgbFuncs.contains(func)) {
int nextPos=pos;
const auto nextT=peekNextToken(&nextPos);
if (nextT.is(Token::END)) {
getToken();
return jkqtp_lookupQColorName(func);
} else if (!nextT.is(Token::LBRACKET)) {
bool found=false;
col=jkqtp_lookupQColorName(func, false, &found);
if (!found) {
getToken();
return {JKQTPUnexpected, UnexpectedTokenError(func, Token::LBRACKET, CurrentToken, pos) };
} else return { col };
}
getToken();
const int minParams=rgbFuncs[func].first;
const int maxParams=rgbFuncs[func].second;
QList<double> params;
getToken();
while (CurrentToken.is(Token::NUMBER)) {
const auto num=parseNumberWithUnit(false);
if (!num.has_value()) return {JKQTPUnexpected, UnexpectedTermError(func, "number with unit", CurrentToken, pos) };
if (params.size()==0 && (func=="hsl" || func=="hsv")) params.append(num.value().normHueNumber());
else {
if ((minParams!=maxParams && params.size()==maxParams-1) || minParams==4) params.append(jkqtp_bounded(0.0,num.value().normNumber(),1.0));
else params.append(num.value().normRGBNumber());
}
getToken();
if (CurrentToken.is(Token::COMMA) || CurrentToken.is(Token::SLASH)) getToken();
}
if (!CurrentToken.is(Token::RBRACKET) && !CurrentToken.is(Token::END)) return {JKQTPUnexpected, UnexpectedTokenError(func, Token::RBRACKET, CurrentToken, pos) };
if (params.size()>=minParams && params.size()<=maxParams) {
if (func=="rgb" || func=="rgba") {
col=QColor::fromRgbF(params[0],params[1],params[2],params.value(3,1));
} else if (func=="hsl") {
col=QColor::fromHslF(params[0],params[1],params[2],params.value(3,1));
} else if (func=="hsv") {
col=QColor::fromHsvF(params[0],params[1],params[2],params.value(3,1));
} else if (func=="gray" || func=="grey") {
col=QColor::fromRgbF(params[0],params[0],params[0],params.value(1,1));
} else if (func=="red") {
col=QColor::fromRgbF(params[0],0.0,0.0,params.value(1,1));
} else if (func=="green") {
col=QColor::fromRgbF(0.0,params[0],0.0,params.value(1,1));
} else if (func=="blue") {
col=QColor::fromRgbF(0.0,0.0,params[0],params.value(1,1));
}
} else return {JKQTPUnexpected, WrongNumberOfArgumentError(func, params.size(), minParams, maxParams, pos) };
} else {
col=jkqtp_lookupQColorName(CurrentToken.StringValue);
}
} else {
return {JKQTPUnexpected, UnexpectedTokenError(Token::NUMBER, CurrentToken, pos) };
}
return { col };
}
JKQTPExpected<QGradient, JKQTPCSSParser::GeneralError> JKQTPCSSParser::parseGradient(bool get)
{
QGradient grad=QGradient();
if (get) getToken();
static QMap<QString,QGradient::Preset> s_GradientPresets = []() {
QMap<QString,QGradient::Preset> m;
for (int i=1; i<QGradient::Preset::NumPresets; i++) {
const QString id=QString(QMetaEnum::fromType<QGradient::Preset>().valueToKey(static_cast<QGradient::Preset>(i))).toLower().trimmed().simplified();
if (id.size()>0) m[id]=static_cast<QGradient::Preset>(i);
}
return m;
}();
const QString func=CurrentToken.StringValue.trimmed().simplified().toLower();
if (CurrentToken.is(Token::TokenType::NAME) && func=="linear-gradient") {
QGradientStops colorStops;
double alphaDeg=180; // 0 = bottom->top angle like clock-pointer
// 90 = left->right
// 180 = top->bottom
// 270 = right->left
getToken();
if (!CurrentToken.is(Token::LBRACKET)) return {JKQTPUnexpected, UnexpectedTokenError(func, Token::LBRACKET, CurrentToken, pos) };
getToken();
if (CurrentToken.isNormString("to")) {
QStringList capDir;
static QSet<QString> allowedDirs={"left","right","top","bottom"};
while (getToken().is(Token::NAME)) {
const QString ns=CurrentToken.getNormString();
if (allowedDirs.contains(ns)) {
capDir.append(ns);
} else {
return {JKQTPUnexpected, UnexpectedTermError(func, "direction specifier [left|right|top|bottom] after 'to'", CurrentToken, pos) };
}
}
if (capDir.size()==1 || (capDir.size()==2 && capDir[1].isEmpty())) {
if (capDir[0]=="left") alphaDeg=270;
else if (capDir[0]=="right") alphaDeg=90;
else if (capDir[0]=="top") alphaDeg=0;
else if (capDir[0]=="bottom") alphaDeg=180;
} else if (capDir.size()==2) {
if (capDir[0]=="top"||capDir[0]=="bottom") qSwap(capDir[0],capDir[1]);
if (capDir[0]=="left" && capDir[1]=="top") alphaDeg=270+45;
else if (capDir[0]=="left" && capDir[1]=="bottom") alphaDeg=270-45;
else if (capDir[0]=="right" && capDir[1]=="top") alphaDeg=90-45;
else if (capDir[0]=="right" && capDir[1]=="bottom") alphaDeg=90+45;
} else {
return {JKQTPUnexpected, GeneralError(func, "at most two directions allowed after 'to', but found "+QString::number(capDir.size()), pos) };
}
if (!CurrentToken.is(Token::COMMA)) return {JKQTPUnexpected, UnexpectedTokenError(func, Token::COMMA, CurrentToken, pos) };
//getToken();
} if (CurrentToken.is(Token::NUMBER)) {
auto angle=parseNumberWithUnit(false);
alphaDeg=angle.value().normNumber();
getToken();
}
// alphaDeg 0 90 180 270
// sin 0 1 0 -1
// cos 1 0 -1 0
// up right down left
const double dx=jkqtp_roundToDigits(0.5*sin(alphaDeg/180.0*M_PI),10);
const double dy=jkqtp_roundToDigits(-0.5*cos(alphaDeg/180.0*M_PI),10);
QLinearGradient lgrad(0.5-dx,0.5-dy,0.5+dx,0.5+dy);
lgrad.setCoordinateMode(QGradient::ObjectBoundingMode);
bool done=false;
while (!done) {
QGradientStop stop;
const auto col=parseColor(true);
if (!col.has_value()) return {JKQTPUnexpected, UnexpectedTermError(func, "color specifier", CurrentToken, pos) };
stop.second=col.value();
stop.first=-1;
getToken();
if (CurrentToken.is(Token::NUMBER)) {
if (CurrentToken.StringValue!="%") return {JKQTPUnexpected, UnexpectedTermError(func, "percentage value", CurrentToken, pos) };
stop.first=CurrentToken.NumberValue/100.0;
getToken();
}
colorStops<<stop;
if (CurrentToken.is(Token::RBRACKET) || CurrentToken.is(Token::END)) {
done=true;
}
}
if (colorStops.size()>0) {
// normalize colorStop positions
if (colorStops.first().first<0) colorStops.first().first=0;
if (colorStops.size()>1) {
if (colorStops.last().first<0) colorStops.last().first=1.0;
}
int i=1;
while (i<colorStops.size()) {
if(colorStops[i].first<0) {
const double lastStop=colorStops[i-1].first;
const int lastI=i-1;
while (colorStops[i].first<0) i++;
const double endStop=colorStops[i].first;
const int cnt=i-lastI-1;
const double delta=(endStop-lastStop)/static_cast<double>(cnt+1);
for (int j=lastI+1; j<i; j++) {
colorStops[j].first=lastStop+static_cast<double>(j-lastI)*delta;
}
}
i++;
}
lgrad.setStops(colorStops);
grad=lgrad;
}
} else if (CurrentToken.isNormStringAnyOf(s_GradientPresets.keys())) {
grad=QGradient(s_GradientPresets[CurrentToken.getNormString()]);
grad.setCoordinateMode(QGradient::ObjectBoundingMode);
} else {
return {JKQTPUnexpected, UnexpectedTermError("supported gradient-function [linear-gradient|] or predefined gradient name", CurrentToken, pos) };
}
return { grad };
}
JKQTPCSSParser::JKQTPCSSParser(const QString &text_):
CurrentToken(Token::TokenType::END), text(text_), pos(0)
{
}
QString JKQTPCSSParser::Token::toString(TokenType type)
{
switch(type) {
case END: return "END";
case NAME: return "NAME";
case NUMBER: return "NUMBER";
case HEXSTRING: return "HEXSTRING";
case LBRACKET: return "LBRACKET";
case RBRACKET: return "RBRACKET";
case COMMA: return "COMMA";
case SLASH: return "SLASH";
}
return "???";
}
JKQTPCSSParser::Token::Token():
type(TokenType::END), StringValue(""), NumberValue(0.0)
{
}
JKQTPCSSParser::Token::Token(TokenType type):
type(type), StringValue(""), NumberValue(0.0)
{
switch(type) {
case LBRACKET: StringValue="("; break;
case RBRACKET: StringValue=")"; break;
case COMMA: StringValue=","; break;
default: break;
}
}
JKQTPCSSParser::Token::Token(double num, const QString &unit_):
type(NUMBER), StringValue(unit_), NumberValue(num)
{
}
JKQTPCSSParser::Token::Token(const QString &str, TokenType type_):
type(type_), StringValue(str), NumberValue(0.0)
{
if (type_==NUMBER) NumberValue=str.toDouble();
if (type_==HEXSTRING) NumberValue=str.toInt(nullptr,16);
}
QString JKQTPCSSParser::Token::toString() const
{
QString s=toString(type);
if (type==NUMBER) s+= " ["+QString::number(NumberValue, 'f')+"]";
else if (StringValue.size()>0) s+= " ["+StringValue+"]";
return s;
}
JKQTPCSSParser::NumberWithUnit JKQTPCSSParser::readNumberWithUnit(const QString &prog)
{
JKQTPCSSParser parser(prog);
const auto res= parser.parseNumberWithUnit(true);
if (res.has_value()) return res.value();
else throw std::runtime_error(res.error().error.toStdString());
}
QColor JKQTPCSSParser::readColor(const QString &prog)
{
JKQTPCSSParser parser(prog);
const auto res= parser.parseColor(true);
if (res.has_value()) return res.value();
else throw std::runtime_error(res.error().error.toStdString());
}
QGradient JKQTPCSSParser::readGradient(const QString &prog)
{
JKQTPCSSParser parser(prog);
const auto res= parser.parseGradient(true);
if (res.has_value()) return res.value();
else throw std::runtime_error(res.error().error.toStdString());
}
Reference in New Issue View Git Blame Copy Permalink