//---------------------------------------------------------------------------
// getWordItems
//
//! Construct a list of word items to be inserted into a word list, based on
//! the results of a list of searches.
//
//! @param searchSpecs the list of search specifications
//! @return a list of word items
//---------------------------------------------------------------------------
QList<WordTableModel::WordItem>
WordVariationDialog::getWordItems(const QList<SearchSpec>& searchSpecs) const
{
QList<WordTableModel::WordItem> wordItems;
QMap<QString, QString> wordMap;
QListIterator<SearchSpec> lit (searchSpecs);
while (lit.hasNext()) {
QStringList wordList = wordEngine->search(lexicon, lit.next(), false);
QStringListIterator wit (wordList);
while (wit.hasNext()) {
QString str = wit.next();
wordMap.insert(str.toUpper(), str);
}
}
QMapIterator<QString, QString> mit (wordMap);
while (mit.hasNext()) {
mit.next();
QString value = mit.value();
QList<QChar> wildcardChars;
for (int i = 0; i < value.length(); ++i) {
QChar c = value[i];
if (c.isLower())
wildcardChars.append(c);
}
QString wildcard;
if (!wildcardChars.isEmpty()) {
qSort(wildcardChars.begin(), wildcardChars.end(),
Auxil::localeAwareLessThanQChar);
foreach (const QChar& c, wildcardChars)
wildcard.append(c.toUpper());
}
wordItems.append(WordTableModel::WordItem(
mit.key(), WordTableModel::WordNormal, wildcard));
}
void Scanner::consumeRegexpModifiers()
{
QChar ch = m_src.peek();
while (ch.isLetter() && ch.isLower()) {
m_src.move();
ch = m_src.peek();
}
}
static QString charFilterRegExp(QString const & filter)
{
QString re;
for (int i = 0; i < filter.length(); ++i) {
QChar c = filter[i];
if (c.isLower())
re += ".*[" + QRegExp::escape(c) + QRegExp::escape(c.toUpper()) + "]";
else
re += ".*" + QRegExp::escape(c);
}
return re;
}
bool is_a_vowel(QChar single_letter)
{
// Make sure we are dealing with lowercase letters.
single_letter = single_letter.toLower();
if (!single_letter.isLower()) return FALSE;
if (single_letter == 'a') return TRUE;
if (single_letter == 'e') return TRUE;
if (single_letter == 'i') return TRUE;
if (single_letter == 'o') return TRUE;
if (single_letter == 'u') return TRUE;
return (FALSE);
}
static bool isAllCaps(const QString &s)
{
for(int n = 0; n < s.length(); ++n)
{
QChar c = s[n];
// non-letters are allowed, so what we really check against is
// lowercase
if(c.isLower())
return false;
}
return true;
}
// There is probably a better way with QChar, but I can't find it.
int letter_to_number (QChar let)
{
// Make sure we are dealing with lowercase letters.
let = let.toLower();
if (!let.isLower()) return 0;
for (int i = 0; i < 26; i++)
{
letters_and_numbers *ln_ptr =& lowercase_and_numbers[i];
if (ln_ptr->let == let) return (ln_ptr->num);
}
/* all else - just return zero*/
return 0;
}
void Autocorrect::fixTwoUppercaseChars()
{
if (! m_fixTwoUppercaseChars) return;
if (m_word.length() <= 2) return;
if (m_twoUpperLetterExceptions.contains(m_word.trimmed()))
return;
QChar firstChar = m_word.at(0);
QChar secondChar = m_word.at(1);
if (secondChar.isUpper()) {
QChar thirdChar = m_word.at(2);
if (firstChar.isUpper() && thirdChar.isLower())
m_word.replace(1, 1, secondChar.toLower());
}
}
void
MorseCodeDecoderNode::add(QString code, QChar character, int level)
{
if (level == code.size()) {
if (m_character == QChar('\0') && character.isLower())
m_character = character;
} else {
QChar part = code[level];
MorseCodeDecoderNode * branch;
if (part == '.') {
if (!m_dot_branch)
m_dot_branch = new MorseCodeDecoderNode();
branch = m_dot_branch;
}
else {
if (!m_dash_branch)
m_dash_branch = new MorseCodeDecoderNode();
branch = m_dash_branch;
}
branch->add(code, character, level+1);
}
}
QVariant Cell::parseMember(const QString &formula, SpreadSheet *widget) const
{
int fOp = firstOperatorPosition(formula);
if (fOp == -1)
fOp = formula.length();
QChar first = formula.at(0);
QRegExp importedData("([\\w\\s]+:[A-Z][1-9][0-9]*)");
QRegExp cellId("([A-Z][1-9][0-9]*)");
//paranteza
if (first=='(')
{
int end = 0;
int open_p_count = 0;
int closed_p_count = 0;
for (int c=0; c<formula.length(); c++)
{
if (formula.at(c) == '(')
open_p_count++;
else if (formula.at(c) == ')')
closed_p_count++;
if (open_p_count == closed_p_count)
{
end = c;
break;
}
}
return computeFormula(formula.mid(1,end-1), widget);
}
//numar 0 sau 0.0
else if (first.isDigit())
{
QString s = formula.left(fOp);
if (s.count('.') <= 1)
{
bool ok;
double x = s.toDouble(&ok);
if (ok)
return x;
}
emit invalidFormula(QString("Invalid number or number format in %1").arg(s));
return "#####";
}
//tabela:identificator
else if (formula.indexOf(importedData) == 0)
{
int idx = 0;
QHash<QString,QString> matches = QHash<QString,QString>();
while ((idx = formula.indexOf(importedData, idx)) != -1)
{
QString match = formula.mid(idx, importedData.matchedLength());
int delim = match.indexOf(':');
QString table = match.left(delim);
QString id = match.mid(delim+1);
matches.insertMulti(table, id);
idx += importedData.matchedLength();
}
QString result = widget->getLinkData(formula, matches);
if (isValidFormula(result))
return display(result);
else
return result;
}
//celula A2
else if (cellId.exactMatch(formula))
{
QVariant cellVal = getCellValue(formula,widget);
if (cellVal == "#####")
emit invalidFormula(QString("Invalid cell data in %1").arg(formula));
return cellVal;
}
//functie nume_functie(A1;A2;A3)
else if (first.isLower())
{
QStringList simple_function_names;
QStringList cond_function_names;
QStringList parameters;
simple_function_names << "sum" << "avg" << "count";
cond_function_names << "if" << "countif";
QString s = formula.left(fOp);
QString params = s.mid(s.lastIndexOf('(')+1,
s.indexOf(')')-s.lastIndexOf('(')-1);
if (s.count('(') == s.count(')'))
parameters = params.split(';');
else
{
emit invalidFormula(QString("Invalid paranthesis number ").append(s));
return "#####";
}
s = formula.left(formula.indexOf('('));
if (simple_function_names.contains(s))
{
QVariantList values;
QListIterator<QString> it(parameters);
while (it.hasNext())
{
QString str = it.next();
QVariant val = parseMember(str, widget);
if (val != "#####")
values.append(val);
}
if (s == "sum")
{
double tmp = 0;
bool ok = true;
QListIterator<QVariant> valIt(values);
while (valIt.hasNext())
{
QVariant aux = valIt.next();
tmp += aux.toDouble(&ok);
if (!ok)
{
emit invalidFormula(QString("Not a number: ").append(aux.toString()));
return "#####";
}
}
return tmp;
}
else if (s == "avg")
{
double tmp = 0;
bool ok = true;
QListIterator<QVariant> valIt(values);
while (valIt.hasNext())
{
QVariant aux = valIt.next();
tmp += aux.toDouble(&ok);
if (!ok)
{
emit invalidFormula(QString("Not a number: ").append(aux.toString()));
return "#####";
}
}
tmp /= parameters.length();
return tmp;
}
else if (s == "count")
{
return values.length();
}
}
else if (cond_function_names.contains(s))
{
int param_no = parameters.length();
if (param_no < 2)
{
emit invalidFormula(QString("Invalid parameter number: %1").arg(param_no));
return "#####";
}
if (s == "if")
{
//if(A1<5;"Picat";n)
//if(A1<5;4)
QRegExp pattern("^(([\\w\\s]+:)?[A-Z][1-9][0-9]*"
"(<|<=|>|>=|<>|=)"
"((([\\w\\s]+:)?[A-Z][1-9][0-9]*)|(\\d+(\\.\\d+)?)))$");
QString condition = parameters.at(0);
if (pattern.exactMatch(condition) && param_no <= 3)
{
int length = 1;
int opPos = condition.indexOf(QRegExp("(<|>|=)"));
if (condition.indexOf(QRegExp("(<=|>=|<>)")) > -1)
length = 2;
QString op = condition.mid(opPos,length);
bool ok1, ok2;
double firstOperand = parseMember(condition.left(opPos), widget).toDouble(&ok1);
double secondOperand = parseMember(condition.mid(opPos+length), widget).toDouble(&ok2);
if (!ok1 || !ok2)
{
emit invalidFormula(QString("Invalid condition parameters: %1").arg(condition));
return "#####";
}
if (param_no == 2)
return compareMembers(param_no, op,
firstOperand, secondOperand,
parameters.at(1), "#####");
else if (param_no == 3)
return compareMembers(param_no, op,
firstOperand, secondOperand,
parameters.at(1), parameters.at(2));
}
else
{
emit invalidFormula(QString("Invalid formula syntax: ").append(condition));
return "#####";
}
}
else if (s == "countif")
{
//countif(A1;A2...An;>5)
if (param_no > 2)
{
int count = 0;
int length = 1;
QString condition = parameters.last();
int opPos = condition.indexOf(QRegExp("(<|>|=)"));
if (condition.indexOf(QRegExp("(<=|>=|<>)")) > -1)
length = 2;
if (opPos == -1)
{
emit invalidFormula(QString("Invalid condition syntax: ").append(condition));
return "#####";
}
QString op = condition.mid(opPos,length);
bool ok;
double firstOperand;
double secondOperand = parseMember(condition.mid(opPos+length), widget).toDouble(&ok);
if (!ok)
{
emit invalidFormula(QString("Invalid second operand: %1").
arg(condition.mid(opPos+length)));
return "#####";
}
for (int i=0; i<param_no-1; i++)
{
firstOperand = parseMember(parameters.at(i), widget).toDouble(&ok);
if (!ok)
{
emit invalidFormula(QString("Invalid operand: %1").
arg(parameters.at(i)));
return "#####";
}
if (compareMembers(op, firstOperand, secondOperand))
count++;
}
return count;
}
}
}
else
{
emit invalidFormula("Invalid formula");
return "#####";
}
}
return formula;
}
int Lexer::nextTokenKind()
{
int token = Parser::Token_INVALID;
if (m_curpos >= m_contentSize) {
m_tokenBegin = -1;
m_tokenEnd = -1;
createNewline(m_curpos);
return 0;
}
QChar* it = m_content.data();
it += m_curpos;
m_tokenBegin = m_curpos;
if (it->isSpace())
{
token = Parser::Token_WHITESPACE;
while (m_curpos < m_contentSize && it->isSpace())
{
if (it->unicode() == '\n')
{
createNewline(m_curpos);
}
it++;
m_curpos++;
}
m_curpos--;
}
else if (it->isDigit())
{
QRegExp regex("\\d+\\.\\d+|\\d+\\.\\d+|\\d+\\.\\d+e-?\\d+|\\d+\\.\\d+e-?\\d+|[\\dABCDEF]+#\\d{1,2}|\\d+");
if ( regex.indexIn(m_content, m_curpos) != -1)
{
kDebug() << "Matched: " << regex.cap();
m_curpos += regex.matchedLength() - 1;
token = Parser::Token_INTEGER_LITERAL;
}
}
else if (it->unicode() == '-')
{
if ((it + 1)->unicode() == '>')
{
m_curpos++;
token = Parser::Token_LEADS_TO;
}
else if ((it + 1)->unicode() == '-')
{
m_curpos++;
token = Parser::Token_LIST_DIFFERENCE;
}
else
{
token = Parser::Token_MINUS;
}
}
else if (it->unicode() == '+')
{
if ((it + 1)->unicode() == '+')
{
m_curpos++;
token = Parser::Token_LIST_ADDITION;
}
else
{
token = Parser::Token_PLUS;
}
}
else if (it->unicode() == '$' && processCharLiteral(it + 1))
{
token = Parser::Token_CHAR_LITERAL;
}
else if (it->unicode() == '}')
{
token = Parser::Token_RBRACE;
if (state() == Tuple)
{
popState();
}
}
else if (it->unicode() == '_')
{
token = Parser::Token_UNDERLINE;
}
else if (it->unicode() == '{')
{
token = Parser::Token_LBRACE;
pushState(Tuple);
}
else if (it->unicode() == ')')
{
token = Parser::Token_RPAREN;
}
else if (it->unicode() == '(')
{
token = Parser::Token_LPAREN;
}
else if (it->unicode() == ']')
{
token = Parser::Token_RBRACKET;
}
else if (it->unicode() == '[')
{
token = Parser::Token_LBRACKET;
}
else if (it->unicode() == ',')
{
token = Parser::Token_COMMA;
}
else if (it->unicode() == '#')
{
token = Parser::Token_POUND_SIGN;
}
else if (it->unicode() == '!')
{
token = Parser::Token_EXCLAMATION;
}
else if (it->unicode() == '<')
{
if ( (it + 1)->unicode() == '-')
{
m_curpos += 1;
token = Parser::Token_LIST_COMPREHENSION_LEADS_TO;
}
else if ( (it + 1)->unicode() == '<' )
{
m_curpos += 1;
token = Parser::Token_BINARY_OPEN;
}
else
{
token = Parser::Token_IS_SMALLER;
}
}
else if (it->unicode() == '>')
{
if ((it + 1)->unicode() == '=')
{
m_curpos++;
token = Parser::Token_IS_GREATER_OR_EQUAL;
}
else if ( (it + 1)->unicode() == '>' )
{
m_curpos += 1;
token = Parser::Token_BINARY_CLOSE;
}
else
{
token = Parser::Token_IS_GREATER;
}
}
else if (it->unicode() == '?')
{
token = Parser::Token_QUESTION;
}
else if (it->unicode() == '%')
{
token = Parser::Token_COMMENT;
while (it->unicode() != '\n')
{
m_curpos++;
it++;
}
createNewline(m_curpos);
}
else if (it->unicode() == '/')
{
if ((it + 1)->unicode() == '=')
{
token = Parser::Token_IS_NOT_EQUAL;
}
else
{
token = Parser::Token_FORWARD_SLASH;
}
}
else if (it->unicode() == '*')
{
token = Parser::Token_MUL;
}
else if (it->unicode() == '|')
{
if ((it + 1)->unicode() == '|')
{
m_curpos++;
token = Parser::Token_DOUBLE_PIPE;
}
else
{
token = Parser::Token_PIPE;
}
}
else if (it->unicode() == ':')
{
if ( (it + 1)->unicode() == ':')
{
m_curpos += 1;
token = Parser::Token_DOUBLE_COLON;
}
else
{
token = Parser::Token_COLON;
}
}
else if (it->unicode() == '.')
{
token = Parser::Token_DOT;
}
else if (it->unicode() == ';')
{
token = Parser::Token_SEMICOLON;
}
else if (it->unicode() == '\'')
{
token = Parser::Token_ATOM_LITERAL;
it++;
m_curpos++;
int startPos = m_curpos;
while (m_curpos < m_contentSize
&& (it->unicode() != '\'')) {
if (it->unicode() == '\n') createNewline(m_curpos);
it++;
m_curpos++;
}
// if the string is never terminated, make sure we don't overflow the boundaries
if ( m_curpos == m_contentSize ) {
--m_curpos;
}
}
else if (it->unicode() == '"')
{
token = Parser::Token_STRING_LITERAL;
it++;
m_curpos++;
while (m_curpos < m_contentSize
&& (it->unicode() != '\"')) {
if (it->unicode() == '\n') createNewline(m_curpos);
it++;
m_curpos++;
}
// if the string is never terminated, make sure we don't overflow the boundaries
if ( m_curpos == m_contentSize ) {
--m_curpos;
}
}
else if (it->unicode() == '=')
{
if ((it + 1)->unicode() == '=')
{
m_curpos++;
token = Parser::Token_IS_EQUAL;
}
else if ((it + 1)->unicode() == '<') {
m_curpos++;
token = Parser::Token_IS_SMALLER_OR_EQUAL;
}
else if ((it + 1)->unicode() == ':' && (it + 2)->unicode() == '=')
{
m_curpos += 2;
token = Parser::Token_EXACT_EQUATIONAL;
}
else if ((it + 1)->unicode() == '/' && (it + 2)->unicode() == '=')
{
m_curpos += 2;
token = Parser::Token_EXACT_NOT_EQUATIONAL;
}
else
{
token = Parser::Token_ASSIGN;
}
}
else if (it->isLetter() && it->isUpper())
{
QString name;
while (m_curpos < m_contentSize && (isValidVariableIdentifier(it))) {
name.append(*it);
it++;
m_curpos++;
}
m_curpos--;
token = Parser::Token_VARIABLE;
}
else if (it->isLetter() && it->isLower())
{
QString name;
while (m_curpos < m_contentSize && (isValidVariableIdentifier(it))) {
name.append(*it);
it++;
m_curpos++;
}
m_curpos--;
if (name == "after") {
token = Parser::Token_AFTER;
} else if (name == "begin") {
token = Parser::Token_BEGIN;
} else if (name == "case") {
token = Parser::Token_CASE;
} else if (name == "if") {
token = Parser::Token_IF;
} else if (name == "catch") {
token = Parser::Token_CATCH;
} else if (name == "cond") {
token = Parser::Token_COND;
} else if (name == "end") {
token = Parser::Token_END;
} else if (name == "fun") {
token = Parser::Token_FUN;
} else if (name == "let") {
token = Parser::Token_LET;
} else if (name == "of") {
token = Parser::Token_OF;
} else if (name == "catch") {
token = Parser::Token_CATCH;
} else if (name == "receive") {
token = Parser::Token_RECEIVE;
} else if (name == "when") {
token = Parser::Token_WHEN;
} else if (name == "div") {
token = Parser::Token_INT_DIV;
} else if (name == "rem") {
token = Parser::Token_INT_REM;
} else if (name == "or") {
token = Parser::Token_OR;
} else if (name == "xor") {
token = Parser::Token_XOR;
} else if (name == "bor") {
token = Parser::Token_BIT_OR;
} else if (name == "bxor") {
token = Parser::Token_BIT_XOR;
} else if (name == "query") {
token = Parser::Token_QUERY;
} else if (name == "bsl") {
token = Parser::Token_SL;
} else if (name == "bsr") {
token = Parser::Token_SR;
} else if (name == "and") {
token = Parser::Token_AND;
} else if (name == "band") {
token = Parser::Token_BIT_AND;
} else if (name == "not") {
token = Parser::Token_NOT;
} else if (name == "bnot") {
token = Parser::Token_BIT_NOT;
} else if (name == "orelse") {
token = Parser::Token_ORELSE;
} else if (name == "andalso") {
token = Parser::Token_ANDALSO;
} else if (name == "module") {
token = Parser::Token_MODULE_DIRECTIVE;
} else if (name == "include") {
token = Parser::Token_INCLUDE_DIRECTIVE;
} else if (name == "export") {
token = Parser::Token_EXPORT_DIRECTIVE;
} else if (name == "file") {
token = Parser::Token_FILE_DIRECTIVE;
} else if (name == "record") {
token = Parser::Token_RECORD_DIRECTIVE;
} else if (name == "include") {
token = Parser::Token_INCLUDE_DIRECTIVE;
} else if (name == "behaviour"){
token = Parser::Token_BEHAVIOUR_DIRECTIVE;
} else if (name == "define"){
token = Parser::Token_DEFINE_DIRECTIVE;
}
else
{
token = Parser::Token_ATOM_LITERAL;
}
}
m_tokenEnd = m_curpos;
m_curpos++;
return token;
}
bool Chord::parse(QString text)
{
if (text.isEmpty())
{
return false;
}
QRegExp beforeMatcher( "^(" + IGNORE_BEFORE_PATTERN + ")" );
if (beforeMatcher.indexIn( text ) == 0 )
{
int n = beforeMatcher.matchedLength();
m_before = text.left(n);
text = text.mid(n);
}
QRegExp afterMatcher( "(" + IGNORE_AFTER_PATTERN + ")$" );
if ( afterMatcher.indexIn( text ) >= 0 )
{
int n = afterMatcher.matchedLength();
m_after = text.right( n );
text = text.mid( 0, text.length() - n );
}
QChar baseChar = text[0];
m_base = parseBase(baseChar);
if (m_base < 0)
{
return false;
}
text = text.mid(1);
if ( ifStartsWithTake( text, "es" )
|| (!text.startsWith("sus") && ifStartsWithTake( text, "s") )
|| ifStartsWithTake( text, "b" )
|| ifStartsWithTake( text, flat()) )
{
m_base--;
}
if ( ifStartsWithTake( text, "is" )
|| ifStartsWithTake( text, "#" )
|| ifStartsWithTake( text, sharp() ) )
{
m_base++;
}
m_base %= 12;
m_base += 12;
m_base %= 12;
if ( baseChar.isLower()
|| (!text.startsWith("min") && !text.startsWith("maj") && ifStartsWithTake( text, "m" ) ) )
{
m_isMinor = true;
}
else
{
m_isMinor = false;
}
m_attachment = text;
if (QRegExp( CHORD_EXTENSION_PATTERN ).exactMatch( m_attachment ))
{
return true;
}
else
{
return false;
}
}
QString ToolTipFiller::filterActionTipContents(const FilterAction& action)
{
if (action.isNull())
{
return QString();
}
QString str;
DToolTipStyleSheet cnt(ApplicationSettings::instance()->getToolTipsFont());
QString tip = cnt.tipHeader;
tip += cnt.headBeg + i18n("Filter") + cnt.headEnd;
// Displayable name
tip += cnt.cellBeg + i18n("Name:") + cnt.cellMid
+ DImgFilterManager::instance()->i18nDisplayableName(action) + cnt.cellEnd;
// Category
QString reproducible("---");
switch (action.category())
{
case FilterAction::ReproducibleFilter:
reproducible = i18nc("Image filter reproducible: Yes", "Yes");
break;
case FilterAction::ComplexFilter:
reproducible = i18nc("Image filter reproducible: Partially", "Partially");
break;
case FilterAction::DocumentedHistory:
reproducible = i18nc("Image filter reproducible: No", "No");
break;
default:
break;
};
tip += cnt.cellBeg + i18n("Reproducible:") + cnt.cellMid
+ reproducible + cnt.cellEnd;
// Description
str = action.description();
if (str.isEmpty())
{
str = QString("---");
}
tip += cnt.cellSpecBeg + i18nc("Image filter description", "Description:") + cnt.cellSpecMid
+ cnt.breakString(str) + cnt.cellSpecEnd;
// Identifier + version
tip += cnt.cellBeg + i18n("Identifier:") + cnt.cellMid
+ action.identifier() + " (v" + QString::number(action.version()) + ") " + cnt.cellEnd;
if (action.hasParameters())
{
tip += cnt.headBeg + i18n("Technical Parameters") + cnt.headEnd;
const QHash<QString, QVariant>& params = action.parameters();
QList<QString> keys = params.keys();
qSort(keys);
foreach(const QString& key, keys)
{
QHash<QString, QVariant>::const_iterator it;
for (it = params.find(key); it != params.end() && it.key() == key; ++it)
{
if (it.key().isEmpty() || !it.value().isValid())
{
continue;
}
if (it.key().startsWith(QLatin1String("curveData")))
{
str = i18n("<i>Binary Data</i>");
}
else
{
str = it.value().toString();
}
if (str.length() > cnt.maxStringLength)
{
str = cnt.elidedText(str, Qt::ElideRight);
}
QString key = it.key();
QChar first = key.at(0);
if (first.isLower())
{
key.replace(0, 1, first.toUpper());
}
tip += cnt.cellBeg + key + cnt.cellMid
+ str + cnt.cellEnd;
}
}
void Changecase::sentenceCase()
{
QTextBlock block = m_document->findBlock(m_startPosition);
QTextCursor backCursor(m_cursor);
int pos = block.position() + block.length() - 1;
// TODO
// * Exception?
while (true) {
QString text = block.text();
int prevLetterIndex = -1;
QChar currentWord;
pos = block.position() + block.length() - 1;
QString::Iterator iter = text.end();
if (text.isEmpty()) { // empty block, go to next block
if (!(block.isValid() && block.position() + block.length() < m_endPosition))
break;
block = block.next();
continue;
}
iter--;
while (iter != text.begin()) {
while (iter != text.begin() && !iter->isSpace()) {
iter--;
pos--;
}
prevLetterIndex = pos;
currentWord = QChar(*(iter + 1));
while (iter != text.begin() && iter->isSpace()) {
iter--;
pos--;
}
// found end of sentence, go back to last found letter (indicating start of a word)
if (iter != text.begin() && (*iter == QChar('.') || *iter == QChar('!') || *iter == QChar('?'))) {
if (prevLetterIndex >= m_startPosition && prevLetterIndex <= m_endPosition && currentWord.isLower()) {
// kDebug() <<"Found end of sentence" << *iter <<" :" << currentWord;
m_cursor.setPosition(prevLetterIndex);
m_cursor.deleteChar();
m_cursor.insertText(currentWord.toUpper());
iter--;
pos--;
}
else if (prevLetterIndex < m_startPosition)
break;
}
}
if (iter == text.begin() && --pos >= m_startPosition) { // start of paragraph, must be start of a sentence also
if (pos + 1 == prevLetterIndex && (*iter).isLower()) {
m_cursor.setPosition(pos);
m_cursor.deleteChar();
m_cursor.insertText((*iter).toUpper());
}
else if (!(*iter).isLetter() && currentWord.isLower()) {
m_cursor.setPosition(prevLetterIndex);
m_cursor.deleteChar();
m_cursor.insertText(currentWord.toUpper());
}
}
if (!(block.isValid() && block.position() + block.length() < m_endPosition))
break;
block = block.next();
}
}
bool Classic::toASS(const QByteArray &txt, LibASS *ass, double fps)
{
if (!ass)
return false;
bool ok = false, use_mDVD_FPS = Use_mDVD_FPS;
const QRegExp TMPRegExp("\\d{1,2}:\\d{1,2}:\\d{1,2}\\D\\s?");
const QRegExp MPL2RegExp("\\[\\d+\\]\\[\\d*\\]\\s?");
const QRegExp MicroDVDRegExp("\\{\\d+\\}\\{\\d*\\}\\s?");
QRegExp MicroDVDStylesRegExp("\\{(\\w):(.*)\\}");
MicroDVDStylesRegExp.setMinimal(true);
QList<SubWithoutEnd> subsWithoutEnd;
for (const QString &line : QString(txt).remove('\r').split('\n', QString::SkipEmptyParts))
{
double start = 0.0, duration = 0.0;
QString sub;
int idx;
if ((idx = line.indexOf(TMPRegExp)) > -1)
{
int h = -1, m = -1, s = -1;
sscanf(line.toLatin1().constData() + idx, "%d:%d:%d", &h, &m, &s);
if (h > -1 && m > -1 && s > -1)
{
start = h*3600 + m*60 + s;
sub = convertLine(TMPRegExp, line);
}
}
else if ((idx = line.indexOf(MPL2RegExp)) > -1)
{
int s = -1, e = -1;
sscanf(line.toLatin1().constData() + idx, "[%d][%d]", &s, &e);
if (s > -1)
{
for (const QString &l : convertLine(MPL2RegExp, line).split('\n'))
{
if (!sub.isEmpty())
sub.append('\n');
if (!l.isEmpty())
{
switch (l.at(0).toLatin1()) {
case '/':
sub.append("{\\i1}" + l.mid(1) + "{\\i0}");
break;
case '\\':
sub.append("{\\b1}" + l.mid(1) + "{\\b0}");
break;
case '_':
sub.append("{\\u1}" + l.mid(1) + "{\\u0}");
break;
default:
sub.append(l);
break;
}
}
}
start = s / 10.0;
duration = e / 10.0 - start;
}
}
else if ((idx = line.indexOf(MicroDVDRegExp)) > -1)
{
int s = -1, e = -1;
sscanf(line.toLatin1().constData() + idx, "{%d}{%d}", &s, &e);
if (s > -1)
{
sub = convertLine(MicroDVDRegExp, line);
if (use_mDVD_FPS && (s == 0 || s == 1))
{
use_mDVD_FPS = false;
const double newFPS = sub.midRef(0, 6).toDouble();
if (newFPS > 0.0 && newFPS < 100.0)
{
fps = newFPS;
continue;
}
}
int pos = 0;
while ((pos = MicroDVDStylesRegExp.indexIn(sub, pos)) != -1)
{
const int matchedLength = MicroDVDStylesRegExp.matchedLength();
const QString styleText = MicroDVDStylesRegExp.cap(2);
const QChar s = MicroDVDStylesRegExp.cap(1).at(0);
const bool singleLine = s.isLower();
switch (s.toLower().toLatin1())
{
case 'c':
if (styleText.startsWith('$') && styleText.length() == 7)
{
replaceText(sub, pos, matchedLength, singleLine, "{\\1c&" + styleText.mid(1) + "&}", "{\\1c}");
continue;
}
break;
case 'f':
replaceText(sub, pos, matchedLength, singleLine, "{\\fn" + styleText + "}", "{\\fn}");
continue;
case 's':
replaceText(sub, pos, matchedLength, singleLine, "{\\fs" + styleText + "}", "{\\fs}");
continue;
case 'p':
if (!singleLine)
{
replaceText(sub, pos, matchedLength, false, "{\\pos(" + styleText + ")}", QString());
continue;
}
break;
case 'y':
replaceText(sub, pos, matchedLength, singleLine, "{\\" + styleText + "1}", "{\\" + styleText + "0}");
continue;
}
pos += MicroDVDStylesRegExp.matchedLength();
}
start = s / fps;
duration = e / fps - start;
}
}
if (start >= 0.0 && !sub.isEmpty())
{
if (duration > 0.0)
{
initOnce(ok, ass);
ass->addASSEvent(Functions::convertToASS(sub), start, duration);
}
else
subsWithoutEnd.append(SubWithoutEnd(start, Sub_max_s, sub));
}
}
if (!subsWithoutEnd.isEmpty())
{
qSort(subsWithoutEnd);
for (int i = 0; i < subsWithoutEnd.size()-1; ++i)
{
const unsigned diff = subsWithoutEnd.at(i+1) - subsWithoutEnd.at(i);
if (!diff)
{
subsWithoutEnd[i+1] += subsWithoutEnd.at(i);
subsWithoutEnd.removeAt(i);
--i;
}
else
subsWithoutEnd[i].setDuration(diff);
}
initOnce(ok, ass);
for (const SubWithoutEnd &sub : asConst(subsWithoutEnd))
ass->addASSEvent(Functions::convertToASS(sub.sub), sub.start, sub.duration);
}
return ok;
}
