void testTypingValue(
SpinBoxType* sbox, QPushButton *okButton, const QString &value)
{
sbox->selectAll();
for (int i = 0; i < value.size(); ++i) {
const QChar valChar = value[i];
_keyClick(static_cast<QWidget *>(sbox), valChar.toAscii()); // ### always guaranteed to work?
if (sbox->hasAcceptableInput())
QVERIFY(okButton->isEnabled());
else
QVERIFY(!okButton->isEnabled());
}
}
inline static bool isQuoteMeta( QChar cUnicode )
{
#if 0 // it's not worth it, especially after seeing gcc's asm output ...
static const uchar iqm[] = {
0x00, 0x00, 0x00, 0x00, 0x94, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00
}; // \'"$
return (c < sizeof(iqm) * 8) && (iqm[c / 8] & (1 << (c & 7)));
#else
char c = cUnicode.toAscii();
return c == '\\' || c == '\'' || c == '"' || c == '$';
#endif
}
void EnhancedPathShape::modifyReference(const QString &reference, qreal value)
{
if (reference.isEmpty())
return;
QChar c = reference[0];
if (c.toAscii() == '$') {
bool success = false;
int modifierIndex = reference.mid(1).toInt(&success);
if (modifierIndex >= 0 && modifierIndex < m_modifiers.count())
m_modifiers[modifierIndex] = value;
}
}
void OmaSaunalahti::sendMessage(QNetworkAccessManager* manager, QString message) {
if (message.toAscii().length()==0)
return;
this->loggedIn = false;
connect(manager, SIGNAL(finished(QNetworkReply*)), SLOT(replyFinished(QNetworkReply*)));
this->message = message;
this->messageTime = QString("%0 %1").arg(QDate::currentDate().toString("dd.MM.yyyy")).arg(QTime::currentTime().toString("hh:mm:ss.zzz"));
QChar *messageChar = this->message.data();
while (!messageChar->isNull()) {
if (messageChar->isSpace()) {
QString chr = QString("%0").arg(QString::number( messageChar->toAscii(), 16 ).toUpper());
if (chr.length()==1)
chr = "%0" + chr;
this->message = this->message.replace(messageChar->toAscii(),chr);
}
++messageChar;
}
QUrl url = QUrl(this->server);
url.addQueryItem("username",this->username);
url.addQueryItem("login","Sisään");
url.addQueryItem("password",this->password);
QNetworkRequest request;
request.setUrl(url);
QNetworkReply *reply = manager->post(request,url.toString().split("?")[1].toAscii());
url.setEncodedQuery(QByteArray());
url.addQueryItem("sender",this->sender);
url.addQueryItem("recipients",this->receiver);
url.addQueryItem("text",this->message);
url.addQueryItem("size",QString("%0").arg(this->message.toAscii().length()));
url.addQueryItem("send","Lähetä");
connect(manager, SIGNAL(finished(QNetworkReply*)), SLOT(messageSent(QNetworkReply*)));
reply = manager->post(request,url.toString().split("?")[1].toAscii());
}
KoEnhancedPathParameter * KoEnhancedPathShape::parameter( const QString & text )
{
Q_ASSERT( ! text.isEmpty() );
ParameterStore::const_iterator parameterIt = m_parameters.constFind( text );
if( parameterIt != m_parameters.constEnd() )
return parameterIt.value();
else
{
KoEnhancedPathParameter *parameter = 0;
QChar c = text[0];
if( c.toAscii() == '$' || c.toAscii() == '?' )
parameter = new KoEnhancedPathReferenceParameter( text, this );
else
{
if( c.isDigit() )
{
bool success = false;
qreal constant = text.toDouble( &success );
if( success )
parameter = new KoEnhancedPathConstantParameter( constant, this );
}
else
{
Identifier identifier = KoEnhancedPathNamedParameter::identifierFromString( text );
if( identifier != IdentifierUnknown )
parameter = new KoEnhancedPathNamedParameter( identifier, this );
}
}
if( parameter )
m_parameters[text] = parameter;
return parameter;
}
}
void Settings::loadSettings(const QString & fileName, QByteArray * windowGeometry, QByteArray * windowState)
{
QString path = fileName;
if(fileName.isEmpty())
{
path = iniDefaultPath();
}
QSettings ini(path, QSettings::IniFormat);
for(ParametersMap::const_iterator iter = defaultParameters_.begin(); iter!=defaultParameters_.end(); ++iter)
{
const QString & key = iter.key();
QVariant value = ini.value(key, QVariant());
if(value.isValid())
{
QString str = value.toString();
if(str.contains(";") && str.size() != getParameter(key).toString().size())
{
// If a string list is modified, update the value
// (assuming that index < 10... one character for index)
QChar index = str.at(0);
str = getParameter(key).toString();
str[0] = index.toAscii();
value = QVariant(str);
printf("Updated list of parameter \"%s\"\n", key.toStdString().c_str());
}
setParameter(key, value);
}
}
if(windowGeometry)
{
QVariant value = ini.value("windowGeometry", QVariant());
if(value.isValid())
{
*windowGeometry = value.toByteArray();
}
}
if(windowState)
{
QVariant value = ini.value("windowState", QVariant());
if(value.isValid())
{
*windowState = value.toByteArray();
}
}
printf("Settings loaded from %s\n", path.toStdString().c_str());
}
QString ParseTokken(QTextStream &in) {
static QChar last;
QChar c;
QString sum;
in >> c;
switch (c.toAscii()) {
case '(':
case ';':
case ')':
case '[':
case ']':
case '\\':
return c;
}
return "";
}
bool Settings::RegistHotkey(QWidget *window,
QChar keyValue,
Qt::KeyboardModifiers keyMod)
{
#if WIN32
WId w_handle = window ? window->winId(): 0;
int modifiy = QtModToWinMod(keyMod);
return RegisterHotKey(w_handle, hotkey_id, modifiy, VkKeyScan
(keyValue.toAscii()));
#else //liunx or mac os are not implement...
Q_UNUSED(window);
Q_UNUSED(keyValue);
Q_UNUSED(keyMod);
return false;
#endif
}
QString encodeUnicode(const QString & unicode)
{
QString encoded;
for (int i = 0; i < unicode.length(); ++i)
{
QChar ch = unicode[i];
if (ch == ch.toAscii())
{
encoded += ch;
}
else
{
encoded += "\\u" + QString("%1").arg((ushort) ch.unicode(), (int) 4, (int) 16, QChar('0')).toUpper();
}
}
return encoded;
}
bool EPath::mountNetwork(QChar drive) {
// Mount network drive
QProcess net_use;
LAPP_ << "Mounting network path to " << drive.toAscii();
QString mount_command = QString("net use %1: \"%2\"").arg(drive).arg(m_path);
LDEBUG_ << "Executing: " << QSTR(mount_command);
net_use.start(mount_command);
net_use.waitForFinished();
if (net_use.exitCode() != 0)
return false;
m_remote_path_mounted = true;
m_usable_drive = drive;
return true;
}
void Settings::loadSettings(const QString & fileName)
{
QString path = fileName;
if(fileName.isEmpty())
{
path = iniPath();
}
if(!path.isEmpty())
{
QSettings ini(path, QSettings::IniFormat);
for(ParametersMap::const_iterator iter = defaultParameters_.begin(); iter!=defaultParameters_.end(); ++iter)
{
const QString & key = iter.key();
QVariant value = ini.value(key, QVariant());
if(value.isValid())
{
QString str = value.toString();
if(str.contains(";") && str.size() != getParameter(key).toString().size())
{
// If a string list is modified, update the value
// (assuming that index < 10... one character for index)
QChar index = str.at(0);
str = getParameter(key).toString();
str[0] = index.toAscii();
value = QVariant(str);
UINFO("Updated list of parameter \"%s\"", key.toStdString().c_str());
}
setParameter(key, value);
}
}
UINFO("Settings loaded from %s.", path.toStdString().c_str());
}
else
{
parameters_ = defaultParameters_;
UINFO("Settings set to defaults.");
}
if(cv::gpu::getCudaEnabledDeviceCount() == 0)
{
Settings::setFeature2D_SURF_gpu(false);
Settings::setFeature2D_Fast_gpu(false);
Settings::setFeature2D_ORB_gpu(false);
}
}
bool isVowell(QChar v){
if ( v > 'A' || v < 'z')
return false;
v = v.toLower();
switch (v.toAscii())
{
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
case 'y':
return true;
default:
break;
}
return false;
}
bool XLIFFHandler::characters(const QString &ch)
{
if (currentContext() == XC_ph) {
// handle the content of <ph> elements
for (int i = 0; i < ch.count(); ++i) {
QChar chr = ch.at(i);
if (accum.endsWith(QLatin1Char('\\')))
accum[accum.size() - 1] = QLatin1Char(charFromEscape(chr.toAscii()));
else
accum.append(chr);
}
} else {
QString t = ch;
t.replace(QLatin1String("\r"), QLatin1String(""));
accum.append(t);
}
return true;
}
QString TextUtils::sanitize(QString const& original)
{
QString result;
for (int i = 0; i < original.length(); i++)
{
QChar c = original.at(i);
uchar_t mychar = c.toAscii();
bool valid = sfn_chars[mychar/8] & ( 1 << (mychar % 8) );
if (valid) {
result.append(c);
} else {
result.append("_");
}
}
return result;
}
void Loader::keyPressEvent(QKeyEvent* e)
{
int key = e->key();
if(this->running == false)
return;
if(this->disableIO)
return;
if(e->matches((QKeySequence::Copy))) {
copy();
return;
}
if(e->matches((QKeySequence::Paste))) {
QClipboard *clip = QApplication::clipboard();
QString command = clip->text();
this->insertPlainText(command);
QByteArray barry(command.toAscii());
process->write(barry);
return;
}
switch(key)
{
case Qt::Key_Enter:
case Qt::Key_Return:
key = '\n';
break;
case Qt::Key_Backspace:
key = '\b';
break;
default:
if(key & Qt::Key_Escape)
return;
QChar c = e->text().at(0);
key = (int)c.toAscii();
break;
}
QByteArray barry;
barry.append((char)key);
process->write(barry);
}
QVariant Cell::computeFormula(const QString &formula, SpreadSheet *widget) const
{
QVariant result = QVariant::Invalid,
firstOperand = QVariant::Invalid,
secondOperand = QVariant::Invalid;
QString aux = formula;
int firstOp = firstOperatorPosition(aux);
if (firstOp == -1)
result = parseMember(aux, widget);
while (firstOp != -1)
{
if (result == QVariant::Invalid)
firstOperand = parseMember(aux.left(firstOp), widget);
else
firstOperand = result;
QChar firstOperator = aux[firstOp];
aux = aux.mid(firstOp+1);
firstOp = firstOperatorPosition(aux);
if (firstOp == -1)
secondOperand = parseMember(aux, widget);
else
secondOperand = parseMember(aux.left(firstOp), widget);
switch (firstOperator.toAscii())
{
case '+':
result = firstOperand.toDouble() + secondOperand.toDouble();
break;
case '-':
result = firstOperand.toDouble() - secondOperand.toDouble();
break;
case '*':
result = firstOperand.toDouble() * secondOperand.toDouble();
break;
case '/':
result = firstOperand.toDouble() / secondOperand.toDouble();
break;
}
}
return result;
}
qreal KoEnhancedPathShape::evaluateReference( const QString &reference )
{
if( reference.isEmpty() )
return 0.0;
QChar c = reference[0];
qreal res = 0.0;
switch( c.toAscii() )
{
// referenced modifier
case '$':
{
bool success = false;
int modifierIndex = reference.mid( 1 ).toInt( &success );
res = m_modifiers[modifierIndex];
}
break;
// referenced formula
case '?':
{
QString fname = reference.mid( 1 );
FormulaStore::const_iterator formulaIt = m_formulae.constFind( fname );
if( formulaIt != m_formulae.constEnd() )
{
KoEnhancedPathFormula * formula = formulaIt.value();
if( formula )
res = formula->evaluate();
}
}
break;
// maybe an identifier ?
default:
KoEnhancedPathNamedParameter p( reference, this );
res = p.evaluate();
break;
}
return res;
}
// convert character to attribute
CmdAttribute LatexCommands::getCharAttr(QChar ch)
{
CmdAttribute attr;
switch(ch.toAscii()) {
case 'a':
attr = CmdAttrAmsmath;
break;
case 'm':
attr = CmdAttrMath;
break;
case 'l':
attr = CmdAttrList;
break;
case 'v':
attr = CmdAttrVerbatim;
break;
case 't':
attr = CmdAttrTabular;
break;
case 'L':
attr = CmdAttrLabel;
break;
case 'R':
attr = CmdAttrReference;
break;
case 'C':
attr = CmdAttrCitations;
break;
case 'I':
attr = CmdAttrIncludes;
break;
case 'B':
attr = CmdAttrBibliographies;
break;
default:
KILE_DEBUG() << "\tLatexCommands error: unknown type of env/cmd: " << static_cast<char>(ch.unicode());
return CmdAttrNone;
}
return attr;
}
PlayerCommandParser::PlayerCommandParser( QString line ) throw( std::invalid_argument )
{
line = line.trimmed();
if (line.isEmpty()) throw invalid_argument( "Command string seems to be empty" );
qDebug() << line;
m_command = extractCommand( line ); //removes the command string from line
line = line.trimmed();
QMap<QChar, QString> const args = extractArgs( line );
QString const required = requiredArgs( m_command );
for (int i = 0; i < required.length(); ++i)
{
QChar const c = required[i];
if (!args.contains( c ))
throw invalid_argument( "Mandatory argument unspecified: " + c.toAscii() );
}
m_playerId = args['c'];
if (m_playerId.isEmpty())
throw invalid_argument( "Player ID cannot be zero length" );
switch (m_command)
{
case CommandStart:
m_track = extractTrack( args );
break;
case CommandBootstrap:
m_username = args['u'];
break;
case CommandInit:
m_applicationPath = args['f'];
default:
break;
}
}
int topMenu::sizeNickName(QString name)
{
QChar lyrics;
int ASCII = 0;
int space = 0;
space = 20;
for (int var = 0; var < name.length(); ++var)
{
lyrics = name.at(var).toAscii();
ASCII = lyrics.toAscii();
if(ASCII >= 65 && ASCII <= 90)
space += 9;
else
space += 7;
space--;
}
return space;
}
/* This function returns \a number rounded using \a precision as precision indicator.
The assumption is that the digit in position <code>precision+1</code> is used to work
out what rounding rule to apply. This means the <code>precision+1</code>. digit in \a number
must still be correct.
*/
QString roundDigits( const QString number, int precision ) {
QString rounded = number;
int point = number.indexOf( '.' ) ;
if ( point > -1 && point <= precision-1 ) {
bool up = (number.at(precision+1).isDigit() && number.at(precision+1) >= QChar('5') );
if ( !up ) {
return rounded;
}
for ( int i = precision; i>= 0 ; i-- ) {
if ( !up ) {
return rounded;
}
QChar current = rounded.at(i);
if ( !current.isDigit() ) {
continue;
}
QChar newCurrent = (current == QChar('9')) ? QChar('0') : QChar(current.toAscii()+1) ;
up = (newCurrent == QChar('0') );
rounded = rounded.replace( i , 1, newCurrent );
}
}
return rounded;
}
void renderCode128(OROPage * page, const QRectF & r, const QString & _str, ORBarcodeData * bc)
{
QVector<int> str;
int i = 0;
// create the list.. if the list is empty then just set a start code and move on
if(_str.isEmpty())
str.push_back(104);
else
{
int rank_a = 0;
int rank_b = 0;
int rank_c = 0;
QChar c;
for(i = 0; i < _str.length(); i++)
{
c = _str.at(i);
rank_a += (code128Index(c, SETA) != -1 ? 1 : 0);
rank_b += (code128Index(c, SETB) != -1 ? 1 : 0);
rank_c += (c >= '0' && c <= '9' ? 1 : 0);
}
if(rank_c == _str.length() && ((rank_c % 2) == 0 || rank_c > 4))
{
// every value in the is a digit so we are going to go with mode C
// and we have an even number or we have more than 4 values
i = 0;
if((rank_c % 2) == 1)
{
str.push_back(104); // START B
c = _str.at(0);
str.push_back(code128Index(c, SETB));
str.push_back(99); // MODE C
i = 1;
}
else
str.push_back(105); // START C
for(i = i; i < _str.length(); i+=2)
{
char a, b;
c = _str.at(i);
a = c.toAscii();
a -= 48;
c = _str.at(i+1);
b = c.toAscii();
b -= 48;
str.push_back(int((a * 10) + b));
}
}
else
{
// start in the mode that had the higher number of hits and then
// just shift into the opposite mode as needed
int set = ( rank_a > rank_b ? SETA : SETB );
str.push_back(( rank_a > rank_b ? 103 : 104 ));
int v = -1;
for(i = 0; i < _str.length(); i++)
{
c = _str.at(i);
v = code128Index(c, set);
if(v == -1)
{
v = code128Index(c, (set == SETA ? SETB : SETA));
if(v != -1)
{
str.push_back(98); // SHIFT
str.push_back(v);
}
}
else
str.push_back(v);
}
}
}
// calculate and append the checksum value to the list
int checksum = str.at(0);
for(i = 1; i < str.size(); i++)
checksum += (str.at(i) * i);
checksum = checksum % 103;
str.push_back(checksum);
// lets determine some core attributes about this barcode
qreal bar_width = bc->narrowBarWidth;
// this is are mandatory minimum quiet zone
qreal quiet_zone = bar_width * 10;
if(quiet_zone < 0.1)
quiet_zone = 0.1;
// what kind of area do we have to work with
qreal draw_width = r.width();
qreal draw_height = r.height();
// how long is the value we need to encode?
int val_length = str.size() - 2; // we include start and checksum in are list so
// subtract them out for our calculations
// L = (11C + 35)X
// L length of barcode (excluding quite zone) in units same as X and I
// C the number of characters in the value excluding the start/stop and checksum characters
// X the width of a bar (pixels in our case)
qreal L;
qreal C = val_length;
qreal X = bar_width;
L = (((11.0 * C) + 35.0) * X);
// now we have the actual width the barcode will be so can determine the actual
// size of the quiet zone (we assume we center the barcode in the given area
// what should we do if the area is too small????
// At the moment the way the code is written is we will always start at the minimum
// required quiet zone if we don't have enough space.... I guess we'll just have over-run
// to the right
//
// calculate the starting position based on the alignment option
// for left align we don't need to do anything as the values are already setup for it
if(bc->align == 1) // center
{
qreal nqz = (draw_width - L) / 2.0;
if(nqz > quiet_zone)
quiet_zone = nqz;
}
else if(bc->align > 1) // right
quiet_zone = draw_width - (L + quiet_zone);
// else if(align < 1) {} // left : do nothing
qreal pos = r.left() + quiet_zone;
qreal top = r.top();
QPen pen(Qt::NoPen);
QBrush brush(QColor("black"));
bool space = false;
int idx = 0, b = 0;
qreal w = 0.0;
for(i = 0; i < str.size(); i++)
{
// loop through each value and render the barcode
idx = str.at(i);
if(idx < 0 || idx > 105)
{
qDebug("Encountered a non-compliant element while rendering a 3of9 barcode -- skipping");
continue;
}
space = false;
for(b = 0; b < 6; b++, space = !space)
{
w = _128codes[idx].values[b] * bar_width;
if(!space)
{
ORORect * rect = new ORORect(bc);
rect->setPen(pen);
rect->setBrush(brush);
rect->setRect(QRectF(pos,top, w,draw_height));
page->addPrimitive(rect);
}
pos += w;
}
}
// we have to do the stop character seperatly like this because it has
// 7 elements in it's bar sequence rather than 6 like the others
int STOP_CHARACTER[]={ 2, 3, 3, 1, 1, 1, 2 };
space = false;
for(b = 0; b < 7; b++, space = !space)
{
w = STOP_CHARACTER[b] * bar_width;
if(!space)
{
ORORect * rect = new ORORect(bc);
rect->setPen(pen);
rect->setBrush(brush);
rect->setRect(QRectF(pos,top, w,draw_height));
page->addPrimitive(rect);
}
pos += w;
}
return;
}
static int getToken()
{
const char tab[] = "bfnrt\"\'\\";
const char backTab[] = "\b\f\n\r\t\"\'\\";
yyIdent.clear();
yyComment.clear();
yyString.clear();
while ( yyCh != EOF ) {
yyLineNo = yyCurLineNo;
if ( yyCh.isLetter() || yyCh.toLatin1() == '_' ) {
do {
yyIdent.append(yyCh);
yyCh = getChar();
} while ( yyCh.isLetterOrNumber() || yyCh.toLatin1() == '_' );
if (yyTok != Tok_Dot) {
switch ( yyIdent.at(0).toLatin1() ) {
case 'r':
if ( yyIdent == QLatin1String("return") )
return Tok_return;
break;
case 'c':
if ( yyIdent == QLatin1String("class") )
return Tok_class;
break;
case 'n':
if ( yyIdent == QLatin1String("null") )
return Tok_null;
break;
}
}
switch ( yyIdent.at(0).toLatin1() ) {
case 'T':
// TR() for when all else fails
if ( yyIdent == QLatin1String("TR") )
return Tok_tr;
break;
case 'p':
if( yyIdent == QLatin1String("package") )
return Tok_Package;
break;
case 't':
if ( yyIdent == QLatin1String("tr") )
return Tok_tr;
if ( yyIdent == QLatin1String("translate") )
return Tok_translate;
}
return Tok_Ident;
} else {
switch ( yyCh.toLatin1() ) {
case '/':
yyCh = getChar();
if ( yyCh == QLatin1Char('/') ) {
do {
yyCh = getChar();
if (yyCh == EOF)
break;
yyComment.append(yyCh);
} while (yyCh != QLatin1Char('\n'));
return Tok_Comment;
} else if ( yyCh == QLatin1Char('*') ) {
bool metAster = false;
bool metAsterSlash = false;
while ( !metAsterSlash ) {
yyCh = getChar();
if ( yyCh == EOF ) {
qFatal( "%s: Unterminated Java comment starting at"
" line %d\n",
qPrintable(yyFileName), yyLineNo );
return Tok_Comment;
}
yyComment.append( yyCh );
if ( yyCh == QLatin1Char('*') )
metAster = true;
else if ( metAster && yyCh == QLatin1Char('/') )
metAsterSlash = true;
else
metAster = false;
}
yyComment.chop(2);
yyCh = getChar();
return Tok_Comment;
}
break;
case '"':
yyCh = getChar();
while ( yyCh != EOF && yyCh != QLatin1Char('\n') && yyCh != QLatin1Char('"') ) {
if ( yyCh == QLatin1Char('\\') ) {
yyCh = getChar();
if ( yyCh == QLatin1Char('u') ) {
yyCh = getChar();
uint unicode(0);
for (int i = 4; i > 0; --i) {
unicode = unicode << 4;
if( yyCh.isDigit() ) {
unicode += yyCh.digitValue();
}
else {
int sub(yyCh.toLower().toAscii() - 87);
if( sub > 15 || sub < 10) {
qFatal( "%s:%d: Invalid Unicode",
qPrintable(yyFileName), yyLineNo );
}
unicode += sub;
}
yyCh = getChar();
}
yyString.append(QChar(unicode));
}
else if ( yyCh == QLatin1Char('\n') ) {
yyCh = getChar();
}
else {
yyString.append( QLatin1Char(backTab[strchr( tab, yyCh.toAscii() ) - tab]) );
yyCh = getChar();
}
} else {
yyString.append(yyCh);
yyCh = getChar();
}
}
if ( yyCh != QLatin1Char('"') )
qFatal( "%s:%d: Unterminated string",
qPrintable(yyFileName), yyLineNo );
yyCh = getChar();
return Tok_String;
case ':':
yyCh = getChar();
return Tok_Colon;
case '\'':
yyCh = getChar();
if ( yyCh == QLatin1Char('\\') )
yyCh = getChar();
do {
yyCh = getChar();
} while ( yyCh != EOF && yyCh != QLatin1Char('\'') );
yyCh = getChar();
break;
case '{':
yyCh = getChar();
return Tok_LeftBrace;
case '}':
yyCh = getChar();
return Tok_RightBrace;
case '(':
if (yyParenDepth == 0)
yyParenLineNo = yyCurLineNo;
yyParenDepth++;
yyCh = getChar();
return Tok_LeftParen;
case ')':
if (yyParenDepth == 0)
yyParenLineNo = yyCurLineNo;
yyParenDepth--;
yyCh = getChar();
return Tok_RightParen;
case ',':
yyCh = getChar();
return Tok_Comma;
case '.':
yyCh = getChar();
return Tok_Dot;
case ';':
yyCh = getChar();
return Tok_Semicolon;
case '+':
yyCh = getChar();
if (yyCh == QLatin1Char('+')) {
yyCh = getChar();
return Tok_PlusPlus;
}
if( yyCh == QLatin1Char('=') ){
yyCh = getChar();
return Tok_PlusEq;
}
return Tok_Plus;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
QByteArray ba;
ba += yyCh.toLatin1();
yyCh = getChar();
bool hex = yyCh == QLatin1Char('x');
if ( hex ) {
ba += yyCh.toLatin1();
yyCh = getChar();
}
while ( hex ? isxdigit(yyCh.toLatin1()) : yyCh.isDigit() ) {
ba += yyCh.toLatin1();
yyCh = getChar();
}
bool ok;
yyInteger = ba.toLongLong(&ok);
if (ok) return Tok_Integer;
break;
}
default:
yyCh = getChar();
}
}
}
return Tok_Eof;
}
QStringList KShell::splitArgs( const QString &args, Options flags, Errors *err)
{
QStringList ret;
bool firstword = flags & AbortOnMeta;
for (int pos = 0; ; ) {
QChar c;
do {
if (pos >= args.length())
goto okret;
c = args.unicode()[pos++];
} while (c.isSpace());
QString cret;
if ((flags & TildeExpand) && c == QLatin1Char('~')) {
int opos = pos;
for (; ; pos++) {
if (pos >= args.length())
break;
c = args.unicode()[pos];
if (c == QLatin1Char('/') || c.isSpace())
break;
if (isQuoteMeta( c )) {
pos = opos;
c = QLatin1Char('~');
goto notilde;
}
if ((flags & AbortOnMeta) && isMeta( c ))
goto metaerr;
}
QString ccret = homeDir( args.mid(opos, pos-opos) );
if (ccret.isEmpty()) {
pos = opos;
c = QLatin1Char('~');
goto notilde;
}
if (pos >= args.length()) {
ret += ccret;
goto okret;
}
pos++;
if (c.isSpace()) {
ret += ccret;
firstword = false;
continue;
}
cret = ccret;
}
// before the notilde label, as a tilde does not match anyway
if (firstword) {
if (c == QLatin1Char('_') ||
(c >= QLatin1Char('A') && c <= QLatin1Char('Z')) ||
(c >= QLatin1Char('a') && c <= QLatin1Char('z')))
{
int pos2 = pos;
QChar cc;
do {
if (pos2 >= args.length()) {
// Exactly one word
ret += args.mid(pos - 1);
goto okret;
}
cc = args.unicode()[pos2++];
} while (cc == QLatin1Char('_') ||
(cc >= QLatin1Char('A') && cc <= QLatin1Char('Z')) ||
(cc >= QLatin1Char('a') && cc <= QLatin1Char('z')) ||
(cc >= QLatin1Char('0') && cc <= QLatin1Char('9')));
if (cc == QLatin1Char('='))
goto metaerr;
}
}
notilde:
do {
if (c == QLatin1Char('\'')) {
int spos = pos;
do {
if (pos >= args.length())
goto quoteerr;
c = args.unicode()[pos++];
} while (c != QLatin1Char('\''));
cret += args.mid(spos, pos-spos-1);
} else if (c == QLatin1Char('"')) {
for (;;) {
if (pos >= args.length())
goto quoteerr;
c = args.unicode()[pos++];
if (c == QLatin1Char('"'))
break;
if (c == QLatin1Char('\\')) {
if (pos >= args.length())
goto quoteerr;
c = args.unicode()[pos++];
if (c != QLatin1Char('"') &&
c != QLatin1Char('\\') &&
!((flags & AbortOnMeta) &&
(c == QLatin1Char('$') ||
c == QLatin1Char('`'))))
cret += QLatin1Char('\\');
} else if ((flags & AbortOnMeta) &&
(c == QLatin1Char('$') ||
c == QLatin1Char('`')))
goto metaerr;
cret += c;
}
} else if (c == QLatin1Char('$') && pos < args.length() &&
args.unicode()[pos] == QLatin1Char('\'')) {
pos++;
for (;;) {
if (pos >= args.length())
goto quoteerr;
c = args.unicode()[pos++];
if (c == QLatin1Char('\''))
break;
if (c == QLatin1Char('\\')) {
if (pos >= args.length())
goto quoteerr;
c = args.unicode()[pos++];
switch (c.toAscii()) {
case 'a': cret += QLatin1Char('\a'); break;
case 'b': cret += QLatin1Char('\b'); break;
case 'e': cret += QLatin1Char('\033'); break;
case 'f': cret += QLatin1Char('\f'); break;
case 'n': cret += QLatin1Char('\n'); break;
case 'r': cret += QLatin1Char('\r'); break;
case 't': cret += QLatin1Char('\t'); break;
case '\\': cret += QLatin1Char('\\'); break;
case '\'': cret += QLatin1Char('\''); break;
case 'c':
if (pos >= args.length())
goto quoteerr;
cret += args.unicode()[pos++].toAscii() & 31;
break;
case 'x':
{
if (pos >= args.length())
goto quoteerr;
int hv = fromHex( args.unicode()[pos++] );
if (hv < 0)
goto quoteerr;
if (pos < args.length()) {
int hhv = fromHex( args.unicode()[pos] );
if (hhv > 0) {
hv = hv * 16 + hhv;
pos++;
}
cret += QChar( hv );
}
break;
}
default:
if (c.toAscii() >= '0' && c.toAscii() <= '7') {
char cAscii = c.toAscii();
int hv = cAscii - '0';
for (int i = 0; i < 2; i++) {
if (pos >= args.length())
break;
c = args.unicode()[pos];
if (c.toAscii() < '0' || c.toAscii() > '7')
break;
hv = hv * 8 + (c.toAscii() - '0');
pos++;
}
cret += QChar( hv );
} else {
cret += QLatin1Char('\\');
cret += c;
}
break;
}
} else
cret += c;
}
} else {
if (c == QLatin1Char('\\')) {
if (pos >= args.length())
goto quoteerr;
c = args.unicode()[pos++];
} else if ((flags & AbortOnMeta) && isMeta( c ))
goto metaerr;
cret += c;
}
if (pos >= args.length())
break;
c = args.unicode()[pos++];
} while (!c.isSpace());
ret += cret;
firstword = false;
}
okret:
if (err)
*err = NoError;
return ret;
quoteerr:
if (err)
*err = BadQuoting;
return QStringList();
metaerr:
if (err)
*err = FoundMeta;
return QStringList();
}
LNote Lilypond::scanNote()
{
QChar c = lookup();
int pitch = 48;
switch (c.toAscii()) {
case 'a': pitch += 9; break;
case 'b': pitch += 11; break;
case 'c': break;
case 'd': pitch += 2; break;
case 'e': pitch += 4; break;
case 'f': pitch += 5; break;
case 'g': pitch += 7; break;
}
++ci;
printf("scanNote pitch %d relpitch %d\n", pitch, relpitch);
if (relpitch > 0) {
if (pitch < relpitch) {
while ((relpitch - pitch) > 5)
pitch += 12;
}
else if (pitch > relpitch) {
while ((pitch - relpitch) > 5)
pitch -= 12;
}
}
int octave = 0;
for (;;) {
if (data[ci] == ' ' || data[ci] == '\n')
break;
if (data[ci] == '\'') {
++octave;
++ci;
}
else if (data[ci] == ',') {
--octave;
++ci;
}
else if (data[ci].isLetterOrNumber()) {
QString buffer;
while (data[ci].isLetterOrNumber())
buffer.append(data[ci++]);
int len = buffer.toInt();
switch(len) {
case 1: curLen = MScore::division * 4; break;
case 2: curLen = MScore::division * 2; break;
case 4: curLen = MScore::division; break;
case 8: curLen = MScore::division / 2; break;
case 16: curLen = MScore::division / 4; break;
case 32: curLen = MScore::division / 8; break;
case 64: curLen = MScore::division / 16; break;
default:
printf("illegal note len %d\n", len);
break;
}
}
else if (data[ci] == '.') {
curLen += (curLen / 2);
++ci;
}
}
pitch += octave * 12;
if (relpitch > 0)
relpitch = pitch;
return LNote(pitch, curLen);
}
QString ReplaceFN::parseReplacement(const int,
const DynamicContext::Ptr &context) const
{
// TODO what if there is no groups, can one rewrite to the replacement then?
const QString input(m_operands.at(2)->evaluateSingleton(context).stringValue());
QString retval;
retval.reserve(input.size());
const int len = input.length();
for(int i = 0; i < len; ++i)
{
const QChar ch(input.at(i));
switch(ch.toAscii())
{
case '$':
{
/* QRegExp uses '\' as opposed to '$' for marking sub groups. */
retval.append(QLatin1Char('\\'));
++i;
if(i == len)
{
context->error(errorAtEnd('$'), ReportContext::FORX0004, this);
return QString();
}
const QChar nextCh(input.at(i));
if(nextCh.isDigit())
retval.append(nextCh);
else
{
context->error(QtXmlPatterns::tr("In the replacement string, %1 must be "
"followed by at least one digit when not escaped.")
.arg(formatKeyword(QLatin1Char('$'))),
ReportContext::FORX0004, this);
return QString();
}
break;
}
case '\\':
{
++i;
if(i == len)
{
/* error, we've reached the end. */;
context->error(errorAtEnd('\\'), ReportContext::FORX0004, this);
}
const QChar nextCh(input.at(i));
if(nextCh == QLatin1Char('\\') || nextCh == QLatin1Char('$'))
{
retval.append(ch);
break;
}
else
{
context->error(QtXmlPatterns::tr("In the replacement string, %1 can only be used to "
"escape itself or %2, not %3")
.arg(formatKeyword(QLatin1Char('\\')))
.arg(formatKeyword(QLatin1Char('$')))
.arg(formatKeyword(nextCh)),
ReportContext::FORX0004, this);
return QString();
}
}
default:
retval.append(ch);
}
}
return retval;
}
//
// This method will convert the desired text into morse code bits:
//
void TorMorse::translateTextToBits(
QTextStream &stream)
{
morseCodeBits.clear();
QChar c;
while (!stream.atEnd())
{
stream >> c;
switch (c.toAscii())
{
case 'a':
case 'A':
dot(); dash(); break;
case 'b':
case 'B':
dash(); dot(); dot(); dot(); break;
case 'c':
case 'C':
dash(); dot(); dash(); dot(); break;
case 'd':
case 'D':
dash(); dot(); dot(); break;
case 'e':
case 'E':
dot(); break;
case 'f':
case 'F':
dot(); dot(); dash(); dot(); break;
case 'g':
case 'G':
dash(); dash(); dot(); break;
case 'h':
case 'H':
dot(); dot(); dot(); dot(); break;
case 'i':
case 'I':
dot(); dot(); break;
case 'j':
case 'J':
dot(); dash(); dash(); dash(); break;
case 'k':
case 'K':
dash(); dot(); dash(); break;
case 'l':
case 'L':
dot(); dash(); dot(); dot(); break;
case 'm':
case 'M':
dash(); dash(); break;
case 'n':
case 'N':
dash(); dot(); break;
case 'o':
case 'O':
dash(); dash(); dash(); break;
case 'p':
case 'P':
dot(); dash(); dash(); dot(); break;
case 'q':
case 'Q':
dash(); dash(); dot(); dash(); break;
case 'r':
case 'R':
dot(); dash(); dot(); break;
case 's':
case 'S':
dot(); dot(); dot(); break;
case 't':
case 'T':
dash(); break;
case 'u':
case 'U':
dot(); dot(); dash(); break;
case 'v':
case 'V':
dot(); dot(); dot(); dash(); break;
case 'w':
case 'W':
dot(); dash(); dash(); break;
case 'x':
case 'X':
dash(); dot(); dot(); dash(); break;
case 'y':
case 'Y':
dash(); dot(); dash(); dash(); break;
case 'z':
case 'Z':
dash(); dash(); dot(); dot(); break;
case '0':
dash(); dash(); dash(); dash(); dash(); break;
case '1':
dot(); dash(); dash(); dash(); dash(); break;
case '2':
dot(); dot(); dash(); dash(); dash(); break;
case '3':
dot(); dot(); dot(); dash(); dash(); break;
case '4':
dot(); dot(); dot(); dot(); dash(); break;
case '5':
dot(); dot(); dot(); dot(); dot(); break;
case '6':
dash(); dot(); dot(); dot(); dot(); break;
case '7':
dash(); dash(); dot(); dot(); dot(); break;
case '8':
dash(); dash(); dash(); dot(); dot(); break;
case '9':
dash(); dash(); dash(); dash(); dot(); break;
case '.':
dot(); dash(); dot(); dash(); dot(); dash(); break;
case ',':
dash(); dash(); dot(); dot(); dash(); dash(); break;
case '?':
dot(); dot(); dash(); dash(); dot(); dot(); break;
case '\'':
dot(); dash(); dash(); dash(); dash(); dot(); break;
case '!':
dash(); dot(); dash(); dot(); dash(); dash(); break;
case '/':
dash(); dot(); dot(); dash(); dot(); break;
case '(':
dash(); dot(); dash(); dash(); dot(); break;
case ')':
dash(); dot(); dash(); dash(); dot(); dash(); break;
case '&':
dot(); dash(); dot(); dot(); dot(); break;
case ':':
dash(); dash(); dash(); dot(); dot(); dot(); break;
case ';':
dash(); dot(); dash(); dot(); dash(); dot(); break;
case '=':
dash(); dot(); dot(); dot(); dash(); break;
case '+':
dot(); dash(); dot(); dash(); dot(); break;
case '-':
dash(); dot(); dot(); dot(); dot(); dash(); break;
case '_':
dot(); dot(); dash(); dash(); dot(); dash(); break;
case '"':
dot(); dash(); dot(); dot(); dash(); dot(); break;
case '$':
dot(); dot(); dot(); dash(); dot(); dot(); dash(); break;
case '@':
dot(); dash(); dash(); dot(); dash(); dot(); break;
case ' ':
// End of a word, so need to add 4 units to the 3-unit character gap:
fourUnitGap();
// Also, clear out any extra whitespace chars:
stream.skipWhiteSpace();
break;
default:
break;
}
// At the end of every character is a 3 unit gap:
threeUnitGap();
}
}
void CppSyntaxHighlighter::highlightBlock(const QString &text)
{
// states
const int StateStandard = 0;
const int StateCommentStart1 = 1;
const int StateCCommentStart2 = 2;
const int StateCppCommentStart2 = 3;
const int StateCComment = 4;
const int StateCppComment = 5;
const int StateCCommentEnd1 = 6;
const int StateCCommentEnd2 = 7;
const int StateStringStart = 8;
const int StateString = 9;
const int StateStringEnd = 10;
const int StateString2Start = 11;
const int StateString2 = 12;
const int StateString2End = 13;
const int StateNumber = 14;
const int StatePreProcessor = 15;
// tokens
const int InputAlpha = 0;
const int InputNumber = 1;
const int InputAsterix = 2;
const int InputSlash = 3;
const int InputParen = 4;
const int InputSpace = 5;
const int InputHash = 6;
const int InputQuotation = 7;
const int InputApostrophe = 8;
const int InputSep = 9;
static const uchar table[16][10] = {
{ StateStandard, StateNumber, StateStandard, StateCommentStart1, StateStandard, StateStandard, StatePreProcessor, StateStringStart, StateString2Start, StateStandard }, // StateStandard
{ StateStandard, StateNumber, StateCCommentStart2, StateCppCommentStart2, StateStandard, StateStandard, StatePreProcessor, StateStringStart, StateString2Start, StateStandard }, // StateCommentStart1
{ StateCComment, StateCComment, StateCCommentEnd1, StateCComment, StateCComment, StateCComment, StateCComment, StateCComment, StateCComment, StateCComment }, // StateCCommentStart2
{ StateCppComment, StateCppComment, StateCppComment, StateCppComment, StateCppComment, StateCppComment, StateCppComment, StateCppComment, StateCppComment, StateCppComment }, // CppCommentStart2
{ StateCComment, StateCComment, StateCCommentEnd1, StateCComment, StateCComment, StateCComment, StateCComment, StateCComment, StateCComment, StateCComment }, // StateCComment
{ StateCppComment, StateCppComment, StateCppComment, StateCppComment, StateCppComment, StateCppComment, StateCppComment, StateCppComment, StateCppComment, StateCppComment }, // StateCppComment
{ StateCComment, StateCComment, StateCCommentEnd1, StateCCommentEnd2, StateCComment, StateCComment, StateCComment, StateCComment, StateCComment, StateCComment }, // StateCCommentEnd1
{ StateStandard, StateNumber, StateStandard, StateCommentStart1, StateStandard, StateStandard, StatePreProcessor, StateStringStart, StateString2Start, StateStandard }, // StateCCommentEnd2
{ StateString, StateString, StateString, StateString, StateString, StateString, StateString, StateStringEnd, StateString, StateString }, // StateStringStart
{ StateString, StateString, StateString, StateString, StateString, StateString, StateString, StateStringEnd, StateString, StateString }, // StateString
{ StateStandard, StateStandard, StateStandard, StateCommentStart1, StateStandard, StateStandard, StatePreProcessor, StateStringStart, StateString2Start, StateStandard }, // StateStringEnd
{ StateString2, StateString2, StateString2, StateString2, StateString2, StateString2, StateString2, StateString2, StateString2End, StateString2 }, // StateString2Start
{ StateString2, StateString2, StateString2, StateString2, StateString2, StateString2, StateString2, StateString2, StateString2End, StateString2 }, // StateString2
{ StateStandard, StateStandard, StateStandard, StateCommentStart1, StateStandard, StateStandard, StatePreProcessor, StateStringStart, StateString2Start, StateStandard }, // StateString2End
{ StateNumber, StateNumber, StateStandard, StateCommentStart1, StateStandard, StateStandard, StatePreProcessor, StateStringStart, StateString2Start, StateStandard }, // StateNumber
{ StatePreProcessor, StateStandard, StateStandard, StateCommentStart1, StateStandard, StateStandard, StatePreProcessor, StateStringStart, StateString2Start, StateStandard } // StatePreProcessor
};
QString buffer;
QTextCharFormat emptyFormat;
int state = StateStandard;
const int previousState = previousBlockState();
if (previousState != -1)
state = previousState;
BlockData *blockData = static_cast<BlockData *>(currentBlockUserData());
if (blockData) {
blockData->parentheses.clear();
} else {
blockData = new BlockData;
setCurrentBlockUserData(blockData);
}
if (text.isEmpty()) {
setCurrentBlockState(previousState);
return;
}
int input = -1;
int i = 0;
bool lastWasBackSlash = false;
bool makeLastStandard = false;
static QString alphabeth = QString::fromLatin1("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
static QString mathChars = QString::fromLatin1("xXeE");
static QString numbers = QString::fromLatin1("0123456789");
bool questionMark = false;
bool resetLineState = true;
QChar lastChar;
QString firstWord;
forever {
QChar c = text.at(i);
if (lastWasBackSlash) {
input = InputSep;
} else {
switch (c.toAscii()) {
case '*':
input = InputAsterix;
break;
case '/':
input = InputSlash;
break;
case '(': case '[': case '{':
input = InputParen;
if (state == StateStandard
|| state == StateNumber
|| state == StatePreProcessor
|| state == StateCCommentEnd2
|| state == StateCCommentEnd1
|| state == StateString2End
|| state == StateStringEnd
)
blockData->parentheses << Parenthesis(Parenthesis::Open, c, i);
break;
case ')': case ']': case '}':
input = InputParen;
if (state == StateStandard
|| state == StateNumber
|| state == StatePreProcessor
|| state == StateCCommentEnd2
|| state == StateCCommentEnd1
|| state == StateString2End
|| state == StateStringEnd
) {
blockData->parentheses << Parenthesis(Parenthesis::Closed, c, i);
/* #####
if (c == '}') {
if (checkFunctionEnd(string, i))
resetLineState = false;
}
*/
}
break;
case '#':
input = InputHash;
break;
case '"':
input = InputQuotation;
break;
case '\'':
input = InputApostrophe;
break;
case ' ':
input = InputSpace;
if (firstWord == QLatin1String("function")
|| firstWord == QLatin1String("constructor")
|| firstWord == QLatin1String("class")
// || firstWord == QLatin1String("if")
// || firstWord == QLatin1String("for")
// || firstWord == QLatin1String("while")
// || firstWord == QLatin1String("else")
) {
// #### paragData->lineState = ParagData::FunctionStart;
resetLineState = false;
}
break;
case '1': case '2': case '3': case '4': case '5':
case '6': case '7': case '8': case '9': case '0':
if (alphabeth.contains(lastChar)
&& (!mathChars.contains(lastChar) || !numbers.contains(text.at(i - 1)))) {
input = InputAlpha;
} else {
if (input == InputAlpha && numbers.contains(lastChar))
input = InputAlpha;
else
input = InputNumber;
}
break;
case ':': {
input = InputAlpha;
QChar nextChar = ' ';
if (i < text.length() - 1)
nextChar = text.at(i + 1);
if (state == StateStandard && !questionMark &&
lastChar != ':' && nextChar != ':' && lastChar.isLetter()) {
for (int j = 0; j < i; ++j) {
if (format(j) == emptyFormat)
setFormat(j, 1, labelFormat);
}
}
break;
}
default: {
if ( c != QLatin1Char('\t') )
firstWord += c;
const QString s = firstWord.simplified();
if ( s == QLatin1String("private")
|| s == QLatin1String("protected")
|| s == QLatin1String("public")
|| s == QLatin1String("static")
)
firstWord.clear();
if (!questionMark && c == QLatin1Char('?'))
questionMark = true;
if (c.isLetter() || c == QLatin1Char('_'))
input = InputAlpha;
else
input = InputSep;
} break;
}
}
lastWasBackSlash = !lastWasBackSlash && c == QLatin1Char('\\');
if (input == InputAlpha)
buffer += c;
state = table[state][input];
switch (state) {
case StateStandard: {
setFormat(i, 1, emptyFormat);
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = false;
if (!buffer.isEmpty() && input != InputAlpha ) {
highlightKeyword(i, buffer);
buffer.clear();
}
} break;
case StateCommentStart1:
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = true;
buffer.clear();
break;
case StateCCommentStart2:
setFormat(i - 1, 2, commentFormat);
makeLastStandard = false;
buffer.clear();
break;
case StateCppCommentStart2:
setFormat(i - 1, 2, commentFormat);
makeLastStandard = false;
buffer.clear();
break;
case StateCComment:
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = false;
setFormat(i, 1, commentFormat);
buffer.clear();
break;
case StateCppComment:
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = false;
setFormat(i, 1, commentFormat);
buffer.clear();
break;
case StateCCommentEnd1:
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = false;
setFormat(i, 1, commentFormat);
buffer.clear();
break;
case StateCCommentEnd2:
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = false;
setFormat(i, 1, commentFormat);
buffer.clear();
break;
case StateStringStart:
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = false;
setFormat(i, 1, emptyFormat);
buffer.clear();
break;
case StateString:
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = false;
setFormat(i, 1, stringFormat);
buffer.clear();
break;
case StateStringEnd:
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = false;
setFormat(i, 1, emptyFormat);
buffer.clear();
break;
case StateString2Start:
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = false;
setFormat(i, 1, emptyFormat);
buffer.clear();
break;
case StateString2:
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = false;
setFormat(i, 1, stringFormat);
buffer.clear();
break;
case StateString2End:
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = false;
setFormat(i, 1, emptyFormat);
buffer.clear();
break;
case StateNumber:
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = false;
setFormat( i, 1, numberFormat);
buffer.clear();
break;
case StatePreProcessor:
if (makeLastStandard)
setFormat(i - 1, 1, emptyFormat);
makeLastStandard = false;
setFormat(i, 1, preProcessorFormat);
buffer = QString::null;
break;
}
lastChar = c;
i++;
if (i >= text.length())
break;
}
highlightKeyword(text.length(), buffer);
/*
if (resetLineState)
paragData->lineState = ParagData::InFunction;
string->setExtraData( paragData );
*/
if (state == StateCComment
|| state == StateCCommentEnd1
|| state == StateCCommentStart2
) {
state = StateCComment;
} else if (state == StateString) {
state = StateString;
} else if (state == StateString2) {
state = StateString2;
} else {
state = StateStandard;
}
if (blockData->parenthesisMatchStart != -1) {
for (int pos = blockData->parenthesisMatchStart;
pos < blockData->parenthesisMatchEnd; ++pos) {
QTextCharFormat fmt = format(pos);
fmt.merge(blockData->parenthesisMatchingFormat);
setFormat(pos, 1, fmt);
}
}
if (blockData->errorMarkerFormat.hasProperty(ErrorMarkerPropertyId)) {
for (int i = 0; i < text.length(); ++i) {
QTextCharFormat fmt = format(i);
fmt.merge(blockData->errorMarkerFormat);
setFormat(i, 1, fmt);
}
}
setCurrentBlockState(state);
}
void ConnectorOld::stringParser(QByteArray recv)
{
QString recvStr = codec->toUnicode(recv);
QChar category = recvStr[0]; // First symbol of string
QStringList message = recvStr.mid(1).split("\t"); // Remove first symbol & splitting
QString cmd;
switch (category.toAscii())
{
case 'R': // Authentification request
qDebug() << "CONN :: Auth_req:" << message;
emit authRequestRecv(message.at(0));
break;
case 'b': // Information
qDebug() << "CONN :: Inform:" << message;
emit infoMessage(message.at(0));
// Verify for success auth string
if (message.at(0).split(" ").count() == 7)
if (message.at(0).split(" ").at(2).at(8) == ',')
emit authSuccess();
break;
case 'd': // Board
cmd = message.at(0);
if (cmd == "channels") // Receved channel list
{
qDebug() << "CONN :: Board: channels recv";
message.pop_front(); // Remove command from message
emit boardChannelsRecv(parseBoardChannels(message.join("\t")));
}
else
{
if (cmd == "new") // New messages
{
qDebug() << "CONN :: Board: new messages avaible";
emit boardNewMessages();
}
else
{
if (cmd == "skins")
{
qDebug() << "CONN :: Board: \"skins\" cmd recv";
}
else
{
if (cmd == "admin")
{
qDebug() << "CONN :: Board: \"admin\" cmd recv";
}
else
{
qDebug() << "CONN :: Board: messages recv";
emit boardMessagesRecv(parseBoardMessages(message.join("\t")));
}
}
}
}
// qDebug() << "DBoard :: " << message;
break;
case 'c': // Chat
cmd = message.at(0);
message.pop_front(); // Remove command from message
if (cmd == "main")
{
qDebug() << "CONN :: Chat: channel message recv";
emit chatPublicMessage(message.at(0),
getUserIdByName(message.at(0), message.at(2)),
message.at(3));
}
else
{
if (cmd == "enter")
{
QString channelId = message.at(0);
if (QHostAddress().setAddress(channelId))
{
qDebug() << "CONN :: Host entered"
<< message.at(2) << "@" << channelId;
}
else
{
qDebug() << "CONN :: Chat: new user entered" << message.at(3);
emit chatUserEnter(channelId, parseEnteredUser(message));
}
}
else
{
if (cmd == "leave")
{
QString channelId = message.at(0);
if (QHostAddress().setAddress(channelId))
{
qDebug() << "CONN :: Host leave"
<< message.at(2) << "@" << channelId;
}
else
{
shared_ptr<ChatChannel> ch =
getChatInstance()->getChannel(channelId);
bool online; // Verify for user connect state
ch->getUser(message.at(2), &online);
if (online)
{
qDebug() << "CONN :: Chat: user leave" << message.at(3);
emit chatUserLeave(channelId, message.at(2));
}
}
}
else
{
if (cmd == "private")
{
qDebug() << "CONN :: Chat: new private message";
emit chatPrivateMessage(parseChatPrivate(message));
}
else
{
if (cmd == "infoGet")
{
qDebug() << "CONN :: Chat: \"infoGet\" cmd recv";
}
else
{
if (cmd == "channels")
{
qDebug() << "CONN :: Chat: channels recv";
emit chatChannelsRecv(parseChatChannels(message.join("\t")));
}
else
{
if (cmd == "userlist")
{
qDebug() << "CONN :: Chat: userlist recv";
emit chatUsersRecv(message.at(0), parseChatUsers(message));
}
else
{
if (cmd == "privateresived")
{
emit chatPrivateDelivered(
message.at(0), message.at(1), message.at(2));
}
else
qDebug() << "CONN ::" << cmd << message;
}
}
}
}
}
}
}
// qDebug() << "Chat :: " << message;
break;
default: // Uncategorised
qDebug() << "Unctg :: " << recvStr;
}
}
void PowerManagementConfigGui::onMessageReceived(const QString &response)
{
QStringList breakdown = response.split(",");
int size = breakdown.size();
if (size <= 0) return;
QChar command = breakdown[0].at(1);
// Check for ident response
if (command == 'E')
{
if (size != 4) return;
PowerManagementConfigUi.firmwareVersion->setText("Firmware version : " + breakdown[2]);
PowerManagementConfigUi.boardVersion->setText("Interface Board Version: " + breakdown[3]);
return;
}
QChar battery = breakdown[0].at(2);
QChar parameter = breakdown[0].at(2);
int controlByte = 0;
if (size > 1) controlByte = breakdown[1].simplified().toInt();
// Error Code
switch (command.toAscii())
{
// Show Measured Quiescent Current
case 'Q':
{
if (size < 2) break;
quiescentCurrent = breakdown[1].simplified();
int test = breakdown[2].simplified().toInt();
if (test < 6)
PowerManagementConfigUi.calibrateProgressBar->setValue(test+1);
else
{
PowerManagementConfigUi.quiescentCurrent
->setText(QString("%1 A").arg(quiescentCurrent.
toFloat()/256,0,'f',3));
this->setEnabled(true);
PowerManagementConfigUi.calibrateProgressBar->setVisible(false);
PowerManagementConfigUi.calibrateProgressBar->setValue(0);
}
break;
}
// Show measured battery resistance
case 'R':
{
if (size < 2) break;
QString batteryResistance = QString("%1 m").arg(breakdown[1]
.simplified().toFloat()/65.536,0,'f',0)
.append(QChar(0x03A9));
if (battery == '1')
PowerManagementConfigUi.battery1Resistance
->setText(batteryResistance);
else if (battery == '2')
PowerManagementConfigUi.battery2Resistance
->setText(batteryResistance);
else if (battery == '3')
PowerManagementConfigUi.battery3Resistance
->setText(batteryResistance);
break;
}
// Show battery type and capacity
case 'T':
{
if (size < 3) break;
int batteryType = breakdown[1].simplified().toInt();
int batteryCapacity = breakdown[2].simplified().toInt();
if (battery == '1')
{
PowerManagementConfigUi.battery1TypeCombo
->setCurrentIndex(batteryType);
PowerManagementConfigUi.battery1CapacitySpinBox
->setValue(batteryCapacity);
}
else if (battery == '2')
{
PowerManagementConfigUi.battery2TypeCombo
->setCurrentIndex(batteryType);
PowerManagementConfigUi.battery2CapacitySpinBox
->setValue(batteryCapacity);
}
else if (battery == '3')
{
PowerManagementConfigUi.battery3TypeCombo
->setCurrentIndex(batteryType);
PowerManagementConfigUi.battery3CapacitySpinBox
->setValue(batteryCapacity);
}
break;
}
// Show battery absorption phase voltage and current limits
case 'A':
{
if (size < 3) break;
float absorptionVoltage = breakdown[2].simplified().toFloat()/256;
float bulkCurrentScale = breakdown[1].simplified().toFloat();
if (battery == '1')
{
PowerManagementConfigUi.battery1AbsorptionVoltage
->setValue(absorptionVoltage);
float battery1Capacity = PowerManagementConfigUi.
battery1CapacitySpinBox->value();
PowerManagementConfigUi.battery1AbsorptionCurrent
->setValue(battery1Capacity/bulkCurrentScale);
}
else if (battery == '2')
{
PowerManagementConfigUi.battery2AbsorptionVoltage
->setValue(absorptionVoltage);
float battery2Capacity = PowerManagementConfigUi.
battery2CapacitySpinBox->value();
PowerManagementConfigUi.battery2AbsorptionCurrent
->setValue(battery2Capacity/bulkCurrentScale);
}
else if (battery == '3')
{
PowerManagementConfigUi.battery3AbsorptionVoltage
->setValue(absorptionVoltage);
float battery3Capacity = PowerManagementConfigUi.
battery3CapacitySpinBox->value();
PowerManagementConfigUi.battery3AbsorptionCurrent
->setValue(battery3Capacity/bulkCurrentScale);
}
break;
}
// Show battery float phase voltage and current limits
case 'F':
{
if (size < 3) break;
float floatVoltage = breakdown[2].simplified().toFloat()/256;
float floatCurrentScale = breakdown[1].simplified().toFloat();
if (battery == '1')
{
PowerManagementConfigUi.battery1FloatVoltage
->setValue(floatVoltage);
float battery1Capacity = PowerManagementConfigUi.
battery1CapacitySpinBox->value();
PowerManagementConfigUi.battery1FloatCurrent
->setValue(battery1Capacity/floatCurrentScale);
}
else if (battery == '2')
{
PowerManagementConfigUi.battery2FloatVoltage
->setValue(floatVoltage);
float battery2Capacity = PowerManagementConfigUi.
battery2CapacitySpinBox->value();
PowerManagementConfigUi.battery2FloatCurrent
->setValue(battery2Capacity/floatCurrentScale);
}
else if (battery == '3')
{
PowerManagementConfigUi.battery3FloatVoltage
->setValue(floatVoltage);
float battery3Capacity = PowerManagementConfigUi.
battery3CapacitySpinBox->value();
PowerManagementConfigUi.battery3FloatCurrent
->setValue(battery3Capacity/floatCurrentScale);
}
break;
}
/* Show control settings */
case 'D':
{
if (size < 2) break;
bool dataMessage = ((controlByte & (1<<3)) > 0);
if (dataMessage)
PowerManagementConfigUi.dataMessageCheckbox->setChecked(true);
else
PowerManagementConfigUi.dataMessageCheckbox->setChecked(false);
bool debugMessage = ((controlByte & (1<<4)) > 0);
if (debugMessage)
PowerManagementConfigUi.debugMessageCheckbox->setChecked(true);
else
PowerManagementConfigUi.debugMessageCheckbox->setChecked(false);
break;
}
// Show current time settings from the system
case 'H':
{
if (size < 2) break;
QDateTime systemTime =
QDateTime::fromString(breakdown[1].simplified(),Qt::ISODate);
PowerManagementConfigUi.date->setText(systemTime.date().toString("dd.MM.yyyy"));
PowerManagementConfigUi.time->setText(systemTime.time().toString("H.mm.ss"));
break;
}
// Operational State values for "reset missing" buttons.
case 'O':
{
int healthState = (controlByte >> 6) & 0x03;
if (battery == '1')
{
if (healthState == 0)
{
PowerManagementConfigUi.resetMissing1Button->
setStyleSheet("background-color:lightgreen;");
PowerManagementConfigUi.resetMissing1Button->setText("");
}
else if (healthState == 1)
{
PowerManagementConfigUi.resetMissing1Button->
setStyleSheet("background-color:orange;");
PowerManagementConfigUi.resetMissing1Button->setText("");
}
else if (healthState == 2)
{
PowerManagementConfigUi.resetMissing1Button->
setStyleSheet("background-color:white;");
PowerManagementConfigUi.resetMissing1Button->setText("X");
}
}
else if (battery == '2')
{
if (healthState == 0)
{
PowerManagementConfigUi.resetMissing2Button->
setStyleSheet("background-color:lightgreen;");
PowerManagementConfigUi.resetMissing2Button->setText("");
}
else if (healthState == 1)
{
PowerManagementConfigUi.resetMissing2Button->
setStyleSheet("background-color:orange;");
PowerManagementConfigUi.resetMissing2Button->setText("");
}
else if (healthState == 2)
{
PowerManagementConfigUi.resetMissing2Button->
setStyleSheet("background-color:white;");
PowerManagementConfigUi.resetMissing2Button->setText("X");
}
}
else if (battery == '3')
{
if (healthState == 0)
{
PowerManagementConfigUi.resetMissing3Button->
setStyleSheet("background-color:lightgreen;");
PowerManagementConfigUi.resetMissing3Button->setText("");
}
else if (healthState == 1)
{
PowerManagementConfigUi.resetMissing3Button->
setStyleSheet("background-color:orange;");
PowerManagementConfigUi.resetMissing3Button->setText("");
}
else if (healthState == 2)
{
PowerManagementConfigUi.resetMissing3Button->
setStyleSheet("background-color:white;");
PowerManagementConfigUi.resetMissing3Button->setText("X");
}
}
break;
}
// Show tracking parameters
case 't':
{
if (size < 3) break;
// Low voltage and critical voltage thresholds.
if (parameter == 'V')
{
float lowVoltage = (float)breakdown[1].simplified().toInt()/256;
float criticalVoltage = (float)breakdown[2].simplified().toInt()/256;
PowerManagementConfigUi.lowVoltageDoubleSpinBox
->setValue(lowVoltage);
PowerManagementConfigUi.criticalVoltageDoubleSpinBox
->setValue(criticalVoltage);
}
// Low SoC and critical SoC thresholds.
else if (parameter == 'S')
{
int lowSoC = (float)breakdown[1].simplified().toInt()/256;
int criticalSoC = (float)breakdown[2].simplified().toInt()/256;
PowerManagementConfigUi.lowSoCSpinBox
->setValue(lowSoC);
PowerManagementConfigUi.criticalSoCSpinBox
->setValue(criticalSoC);
}
/* Monitor strategy byte. Bit 0 is to allow charger and load on the same
battery; bit 1 is to maintain an isolated battery in normal conditions. */
else if (parameter == 's')
{
int monitorStrategy = (float)breakdown[1].simplified().toInt();
bool separateLoad = (monitorStrategy & 1) > 0;
PowerManagementConfigUi.loadChargeCheckBox
->setChecked(separateLoad);
bool preserveIsolation = (monitorStrategy & 2) > 0;
PowerManagementConfigUi.isolationMaintainCheckBox
->setChecked(preserveIsolation);
}
break;
}
// Show charger parameters
case 'c':
{
if (size < 3) break;
if (parameter == 'R')
{
int restTime = (float)breakdown[1].simplified().toInt();
int absorptionTime = (float)breakdown[2].simplified().toInt();
PowerManagementConfigUi.restTimeSpinBox
->setValue(restTime);
PowerManagementConfigUi.absorptionTimeSpinBox
->setValue(absorptionTime);
}
else if (parameter == 'D')
{
int dutyCycleMin = (float)breakdown[1].simplified().toInt()/256;
PowerManagementConfigUi.minimumDutyCycleSpinBox
->setValue(dutyCycleMin);
}
else if (parameter == 'F')
{
int floatTime = (float)breakdown[1].simplified().toInt();
int floatSoC = (float)breakdown[2].simplified().toInt()/256;
PowerManagementConfigUi.floatDelaySpinBox
->setValue(floatTime);
PowerManagementConfigUi.floatBulkSoCSpinBox
->setValue(floatSoC);
}
/* Charger strategy byte. Bit 0 is to suppress the absortion phase for EMI. */
else if (parameter == 's')
{
int chargerStrategy = (float)breakdown[1].simplified().toInt();
bool suppressAbsorptionPhase = (chargerStrategy & 1) > 0;
PowerManagementConfigUi.absorptionMuteCheckbox
->setChecked(suppressAbsorptionPhase);
}
break;
}
}
}
