QCString KDEsuClient::escape(const QCString &str) { QCString copy = str; int n = 0; while((n = copy.find("\\", n)) != -1) { copy.insert(n, '\\'); n += 2; } n = 0; while((n = copy.find("\"", n)) != -1) { copy.insert(n, '\\'); n += 2; } copy.prepend("\""); copy.append("\""); return copy; }
void UmlClass::uml2java(bool rec) { if (isJavaExternal()) set_JavaDecl(JavaSettings::externalClassDecl()); else { QCString st = JavaSettings::classStereotype(stereotype()); UmlItem * pack = parent()->parent(); while (pack->kind() != aPackage) pack = pack->parent(); if ((st == "stereotype") || (st == "metaclass") || (pack->stereotype() == "profile")) { set_CppDecl(""); return; } if (st == "enum_pattern") set_JavaDecl(JavaSettings::enumPatternDecl()); else if (st == "enum") set_JavaDecl(JavaSettings::enumDecl()); else if (st == "interface") set_JavaDecl(JavaSettings::interfaceDecl()); else if (st == "@interface") { QCString s = JavaSettings::interfaceDecl(); int index = s.find("interface"); if (index != -1) s.insert(index, '@'); set_JavaDecl(s); } else if (st == "ignored") { set_JavaDecl(""); return; } else set_JavaDecl(JavaSettings::classDecl()); if (rec) { const QVector<UmlItem> ch = children(); unsigned n = ch.size(); for (unsigned i = 0; i != n; i += 1) ch[i]->uml2java(rec); } if (parent()->kind() == aClassView) // not nested artifact()->set_JavaSource(JavaSettings::sourceContent()); } }
QString LDIFConverter::makeLDIFfieldString( QString formatStr, QString value, bool allowEncode ) { if ( value.isEmpty() ) return QString(); // append format if not given if (formatStr.find(':') == -1) formatStr.append(": %1\n"); // check if base64-encoding is needed bool printable = true; unsigned int i, len; len = value.length(); for (i = 0; i<len; ++i ) { if (!value[i].isPrint()) { printable = false; break; } } if (printable) // always encode if we find special chars... printable = (value.find('\n') == -1); if (!printable && allowEncode) { // encode to base64 value = KCodecs::base64Encode( value.utf8() ); int p = formatStr.find(':'); if (p>=0) formatStr.insert(p, ':'); } // generate the new string and split it to 72 chars/line QCString txt = (formatStr.arg(value)).utf8(); if (allowEncode) { len = txt.length(); if (len && txt[len-1] == '\n') --len; i = 72; while (i < len) { txt.insert(i, "\n "); i += 72+1; len += 2; } } return QString::fromUtf8(txt); }
void UmlOperation::set_java(const char * return_form, const char * params, QCString body, bool inlinep) { QCString s = JavaSettings::operationDef(); int index = s.find("${type}"); s.replace(index, 7, return_form); s.insert(s.find("${)}", index), params); if (inlinep) { s.replace(s.findRev("${body}"), 7, body); set_JavaDef(s); } else { set_JavaDef(s); set_JavaBody(body); } }
void cTextField::onKeyDown(QKeyEvent *e) { int key = e->key(); Qt::ButtonState state = e->state(); // Handle special chars if (key == Qt::Key_Backspace) { // Replace the selection with an empty string if (selection_ != 0) { replaceSelection(""); } else if (caret_ > 0) { setCaret(caret_ - 1); text_.remove(caret_, 1); invalidateText(); } } else if (key == Qt::Key_Delete) { if (selection_ != 0) { replaceSelection(""); } else if (caret_ < text_.length()) { text_.remove(caret_, 1); invalidateText(); } } else if (key == Qt::Key_Left) { if (caret_ > 0) { setCaret(caret_ - 1); if ((state & Qt::ShiftButton) != 0) { selection_++; invalidateText(); } else { if (selection_ != 0) { selection_ = 0; invalidateText(); } } } } else if (key == Qt::Key_Right) { if (caret_ < text_.length()) { setCaret(caret_ + 1); if ((state & Qt::ShiftButton) != 0) { selection_--; invalidateText(); } else { if (selection_ != 0) { selection_ = 0; invalidateText(); } } } } else if (key == Qt::Key_V && (state & Qt::ControlButton) != 0) { QClipboard *clipboard = qApp->clipboard(); QString text = clipboard->text(); if (!text.isEmpty()) { QCString ltext = text.latin1(); replaceSelection(ltext); } } else if (key == Qt::Key_C && (state & Qt::ControlButton) != 0) { QClipboard *clipboard = qApp->clipboard(); QCString text = getSelection(); if (!text.isEmpty()) { clipboard->setText(QString(text), QClipboard::Clipboard); } } else if (key == Qt::Key_X && (state & Qt::ControlButton) != 0) { QClipboard *clipboard = qApp->clipboard(); QCString text = getSelection(); if (!text.isEmpty()) { clipboard->setText(QString(text), QClipboard::Clipboard); replaceSelection(""); } } else if (key == Qt::Key_Return) { onEnter(); } else if (key == Qt::Key_Home) { int oldCaret = caret_; selection_ = 0; setCaret(0); invalidateText(); /*if (key.mod & KMOD_SHIFT) { selection_--; invalidateText(); } else { if (selection_ != 0) { selection_ = 0; invalidateText(); } }*/ } else if (key == Qt::Key_End) { setCaret(text_.length()); selection_ = 0; invalidateText(); } else if (text_.length() < maxLength_) { char ch = e->text().at(0).latin1(); // Check if the character is supported by the current font. if (ch != 0) { cSurface *chs = AsciiFonts->getCharacter(font_, ch); if (chs) { QCString replacement; replacement.insert(0, ch); replaceSelection(replacement); } } } }
bool UmlAttribute::new_one(Class * container, const QCString & name, const QCString & type, const QCString & modifier, const QCString & pretype, const QCString & array, aVisibility visibility, bool staticp, bool constp, bool typenamep, bool mutablep, bool volatilep, const QCString & bitfield, const QCString & value, QCString comment, QCString description #ifdef ROUNDTRIP , bool roundtrip, QList<UmlItem> & expected_order #endif ) { #ifdef DEBUG_BOUML cout << "ATTRIBUTE '" << name << "' type '" << type << "' modifier '" << modifier << "' array '" << array << "'\n"; #endif if ( #ifdef REVERSE container->from_libp() && #endif (visibility == PrivateVisibility)) { Lex::finish_line(); Lex::clear_comments(); return TRUE; } UmlClass * cl = container->get_uml(); UmlAttribute * at; #ifdef ROUNDTRIP bool created; if (!roundtrip || ((at = search_attr(cl, name)) == 0)) { #endif at = UmlBaseAttribute::create(cl, name); if (at == 0) { UmlCom::trace(QCString("<font face=helvetica><b>cannot add attribute <i>") + name + "</i> in <i>" + QCString(cl->name()) + "</i></b></font><br><hr>"); return FALSE; } #ifdef REVERSE # ifndef ROUNDTRIP Statistic::one_attribute_more(); # else if (roundtrip) container->set_updated(); created = TRUE; } else created = FALSE; # endif #endif Lex::finish_line(); comment = Lex::get_comments(comment); description = Lex::get_description(description); bool pfunc = (type.find('$') != -1); UmlTypeSpec typespec; QCString typeform; QCString stereotype; if (! pfunc) { typeform = (pretype.isEmpty()) ? QCString("${type}") : pretype + " ${type}"; container->compute_type(type, typespec, typeform); } else { typespec.explicit_type = type.simplifyWhiteSpace(); int index = typespec.explicit_type.find("${name}"); if (index != -1) typespec.explicit_type.remove(index, 7); } QCString decl = CppSettings::attributeDecl(""); int index = decl.find("${type}"); if ((index == -1) || (decl.find("${const}") == -1) || (decl.find("${name}") == -1) || (decl.find("${mutable}") == -1) || (decl.find("${volatile}") == -1) || (decl.find(';') == -1)) { decl = " ${comment}${static}${mutable}${volatile}${const}${type} ${name}${value};"; index = decl.find("${type}"); } if (pfunc) decl.replace(index, decl.find("${name}") + 7 - index, type); else { if (!modifier.isEmpty()) decl.insert(index + 7, QCString(" ") + modifier); if (typeform != "${type}") decl.replace(index, 7, typeform); else if (typespec.type == 0) { QCString t = typespec.explicit_type; int index2; if (!t.isEmpty() && (t.at(t.length() - 1) == '>') && ((index2 = t.find('<')) > 0)) { stereotype = t.left(index2); typespec.explicit_type = // may be a,b ... t.mid(index2 + 1, t.length() - 2 - index2); decl.replace(index, 7, "${stereotype}<${type}>"); } } if (!array.isEmpty()) decl.insert(decl.find("${name}") + 7, "${multiplicity}"); if (!bitfield.isEmpty()) decl.insert(decl.find(';'), QCString(" : ") + bitfield); } if (typenamep) { int index = decl.find("${const}") + 8; // find cannot return -1 int index2 = decl.find("${mutable}") + 10; // find cannot return -1 int index3 = decl.find("${volatile}") + 11; // find cannot return -1 if (index2 > index) index = index2; if (index3 > index) index = index3; decl.insert(index, "typename "); } if (!value.isEmpty() && ((index = decl.find("${value}")) != -1)) decl.insert(index + 2, "h_"); #ifdef ROUNDTRIP if (roundtrip && !created) { if (decl.find("${description}") != -1) { if (nequal(at->description(), description)) { at->set_Description(description); container->set_updated(); } } else if (nequal(at->description(), Lex::simplify_comment(comment))) { at->set_Description(comment); // comment was set container->set_updated(); } if (at->isReadOnly() != constp) { at->set_isReadOnly(constp); container->set_updated(); } if (at->isCppMutable() != mutablep) { at->set_isCppMutable(mutablep); container->set_updated(); } if (at->isVolatile() != volatilep) { at->set_isVolatile(volatilep); container->set_updated(); } if (at->isClassMember() != staticp) { at->set_isClassMember(staticp); container->set_updated(); } if (neq(at->multiplicity(), array)) { at->set_Multiplicity(array); container->set_updated(); } if (!staticp) { QCString v = at->defaultValue(); if (!v.isEmpty() && (((const char *) v)[0] == '=')) v = v.mid(1); if (nequal(v, value)) { at->set_DefaultValue(value); container->set_updated(); } } if (at->visibility() != visibility) { at->set_Visibility(visibility); container->set_updated(); } if (!stereotype.isEmpty()) { QCString cppst; if (!at->stereotype().isEmpty()) cppst = CppSettings::relationAttributeStereotype(at->stereotype()); if (cppst != stereotype) { at->set_Stereotype(stereotype); container->set_updated(); } } if (!at->type().equal(typespec)) { at->set_Type(typespec); container->set_updated(); } if (neq(at->cppDecl(), decl)) { at->set_CppDecl(decl); container->set_updated(); } at->set_usefull(); expected_order.append(at); } else { #endif if (!comment.isEmpty()) at->set_Description((decl.find("${description}") != -1) ? description : Lex::simplify_comment(comment)); if (constp) at->set_isReadOnly(TRUE); if (mutablep) at->set_isCppMutable(TRUE); if (volatilep) at->set_isVolatile(TRUE); if (staticp) at->set_isClassMember(TRUE); if (!array.isEmpty()) at->set_Multiplicity(array); if (! value.isEmpty()) at->set_DefaultValue(value); at->set_Visibility(visibility); if (! stereotype.isEmpty()) at->set_Stereotype(stereotype); at->set_Type(typespec); at->set_CppDecl(decl); #ifdef ROUNDTRIP if (roundtrip) expected_order.append(at); } #endif return TRUE; }
void RTFGenParser::text(const QString &text) { if (m_res_size) return; unsigned size = res.length(); if (size > m_max_size){ textPos = start_pos; m_res_size = size; return; } for (int i = 0; i < (int)(text.length()); i++){ QChar c = text[i]; if (c.isSpace()){ unsigned size = res.length(); if (size > m_max_size){ textPos = start_pos + i; m_res_size = size; return; } } // In Qt, unless you force the paragraph direction with (Left/Right) // Ctrl-Shift (also known as Key_Direction_L and Key_Direction_R), // the P tag won't have a DIR attribute at all. In such cases, unlike // HTML, Qt will render the paragraph LTR or RTL according to the // first strong character (as Unicode TR#9 defines). Thus, if the // direction isn't known yet, we check each character till we find // a strong one. if ((m_lastParagraphPos != 0) && (m_paragraphDir == DirUnknown)) { switch(c.direction()) { case QChar::DirL: res.insert(m_lastParagraphPos, "\\ltrpar"); m_paragraphDir = DirLTR; break; case QChar::DirR: res.insert(m_lastParagraphPos, "\\rtlpar"); m_paragraphDir = DirRTL; break; default: // to avoid warnings break; } } unsigned short u = c.unicode(); if (c == '\r' || c == '\n') continue; if ((c == '{') || (c == '}') || (c == '\\')){ char b[5]; snprintf(b, sizeof(b), "\\\'%02x", u & 0xFF); res += b; m_bSpace = false; continue; } if (u < 0x80){ if (m_bSpace) res += ' '; res += (char)u; m_bSpace = false; continue; } QString s; s += c; if (m_codec){ QCString plain = m_codec->fromUnicode(s); if ((plain.length() == 1) && (m_codec->toUnicode(plain) == s)){ char b[5]; snprintf(b, sizeof(b), "\\\'%02x", plain[0] & 0xFF); res += b; m_bSpace = false; continue; } } res += "\\u"; res += QString::number(s[0].unicode()); res += '?'; m_bSpace = false; } }
void UmlTransition::generate(QList<UmlTransition> trs, UmlClass * machine, UmlClass * anystate, UmlState * state, QCString & body, QCString indent, bool completion) { UmlTransition * tr; bool guard = FALSE; for (tr = trs.first(); tr != 0; tr = trs.next()) { body += indent; if (!tr->cppGuard().isEmpty()) { // manage guard body += ((tr == trs.getFirst()) ? "if (" : "else if (") + tr->cppGuard() + ") {\n"; guard = TRUE; } else // no gard : it is the last transition, may be the first body += ((tr == trs.getFirst()) ? "{\n" : "else {\n"); // the target state UmlItem * tg = tr->target(); bool self_external = (state == tg) && tr->isExternal(); while (tg->kind() != aState) tg = tg->parent(); // the parent common to the current and the target state UmlState * common = state; if (self_external) { // execute exit behavior if (!state->cppExitBehavior().isEmpty()) body += indent + " _doexit(stm);\n"; } else { bool fromExit = // the exit behavior is made entering in the exit point (tr->parent()->kind() == anExitPointPseudoState); // compute common parent and manage exit behavior if (tr->target()->kind() != aTerminatePseudoState) { while (! ((UmlState *) tg)->inside(common)) { if (!fromExit && !common->cppExitBehavior().isEmpty()) body += indent + " stm" + common->path() + "._doexit(stm);\n"; fromExit = FALSE; switch (common->parent()->kind()) { case aState: common = (UmlState *) common->parent(); break; case aRegion: common = (UmlState *) common->parent()->parent(); break; default: UmlCom::trace("Error : transition from '" + state->name() + "' goes outside the state machine"); throw 0; } } } } // manage transition activity if (!tr->cppActivity().isEmpty()) body += "#ifdef VERBOSE_STATE_MACHINE\n" + indent + " puts(\"DEBUG : execute activity of transition " + tr->name() + "\");\n#endif\n" + tr->cppActivity(); // manage entry behavior if (self_external) { if (state->needCreate()) body += indent + " create(stm);\n"; } else if (tr->target()->kind() != aTerminatePseudoState) { if (tg != common) { QCString enter; UmlState * tg_parent; // the enter behavior of the target state will be managed // generating a call to create for (tg_parent = (UmlState *) tg->parent(); tg_parent != common; tg_parent = (UmlState *) tg_parent->parent()) if (!tg_parent->cppEntryBehavior().isEmpty()) enter.insert(0, indent + " stm" + tg_parent->path() + "._doentry(stm);\n"); if (!enter.isEmpty()) body += enter; } // set the current state if needed if (tg != state) body += indent + " stm._set_currentState(stm" + ((UmlState *) tg)->path() + ");\n#ifdef VERBOSE_STATE_MACHINE\n" + indent + " puts(\"DEBUG : current state is now " + ((UmlState *) tg)->prettyPath() + "\");\n#endif\n"; } // do the transition if (tr->target()->kind() == aState) { if ((tg != state) && ((UmlState *) tg)->needCreate()) body += indent + " stm" + ((UmlState *) tg)->path() + ".create(stm);\n"; } else tr->target()->generate(machine, anystate, ((UmlState *) tg), body, indent + " "); if (completion) body += indent + " return (bool) 1;\n"; body += indent + "}\n"; } if (completion && guard) body += indent + "return (bool) 0;\n"; }
bool UmlAttribute::new_one(Class * container, const QCString & name, UmlTypeSpec typespec, aVisibility visibility, bool staticp, bool finalp, bool transientp, bool volatilep, const QCString & array, const QCString & value, QCString comment, QCString description, QCString annotation #ifdef ROUNDTRIP , bool roundtrip, QList<UmlItem> & expected_order #endif ) { #ifdef TRACE cout << "ATTRIBUTE '" << name << "'\n"; #endif if ( #ifdef REVERSE container->from_libp() && #endif (visibility == PrivateVisibility)) { Lex::finish_line(); Lex::clear_comments(); return TRUE; } UmlClass * cl = container->get_uml(); UmlAttribute * at; #ifdef ROUNDTRIP bool created; if (!roundtrip || ((at = search_attr(container, name)) == 0)) { #endif at = UmlBaseAttribute::create(cl, name); if (at == 0) { JavaCatWindow::trace(QCString("<font face=helvetica><b>cannot add attribute <i>") + name + "</i> in <i>" + cl->name() + "</i></b></font><br>"); return FALSE; } #ifdef REVERSE # ifndef ROUNDTRIP Statistic::one_attribute_more(); # else if (roundtrip) container->set_updated(); created = TRUE; } else created = FALSE; # endif #endif Lex::finish_line(); comment = Lex::get_comments(comment); description = Lex::get_description(description); QCString decl = JavaSettings::attributeDecl(""); int index = decl.find("${type}"); if ((index == -1) || (decl.find("${name}") == -1)) { decl = " ${comment}${@}${visibility}${static}${final}${transient}${volatile}${type} ${name}${value};"; index = decl.find("${type}"); } #ifdef ROUNDTRIP if (roundtrip && !created) { if (decl.find("${description}") != -1) { if (nequal(at->description(), description)) { at->set_Description(description); container->set_updated(); } } else if (nequal(at->description(), Lex::simplify_comment(comment))) { at->set_Description(comment); // comment was set container->set_updated(); } if (at->isReadOnly() != finalp) { at->set_isReadOnly(finalp); container->set_updated(); } if (at->isJavaTransient() != transientp) { at->set_isJavaTransient(transientp); container->set_updated(); } if (at->isVolatile() != volatilep) { at->set_isVolatile(volatilep); container->set_updated(); } if (at->isClassMember() != staticp) { at->set_isClassMember(staticp); container->set_updated(); } if (!array.isEmpty()) decl.insert(index + 7, "${multiplicity}"); if (neq(at->multiplicity(), array)) { at->set_Multiplicity(array); container->set_updated(); } QCString v = at->defaultValue(); if (!v.isEmpty() && (((const char *) v)[0] == '=')) v = v.mid(1); if (nequal(v, value)) { at->set_DefaultValue(value); container->set_updated(); } if (nequal(at->javaAnnotations(), annotation)) { at->set_JavaAnnotations(annotation); container->set_updated(); } QCString stereotype; bool force_ste = FALSE; if (cl->stereotype() == "enum") { stereotype = "attribute"; force_ste = TRUE; } else if (typespec.type == 0) { QCString t = typespec.explicit_type; int index2; if (!t.isEmpty() && (t.at(t.length() - 1) == '>') && ((index2 = t.find('<')) > 0)) { stereotype = t.left(index2); typespec.explicit_type = // may be a,b ... t.mid(index2 + 1, t.length() - 2 - index2); decl.replace(index, 7, "${stereotype}<${type}>"); force_ste = TRUE; } } if (at->visibility() != visibility) { at->set_Visibility(visibility); container->set_updated(); } if (neq(at->stereotype(), stereotype)) { QCString jst; if (! at->stereotype().isEmpty()) jst = JavaSettings::relationAttributeStereotype(at->stereotype()); if ((force_ste) ? (jst != stereotype) : (jst == "attribute")) { at->set_Stereotype(stereotype); container->set_updated(); } } if (neq(at->javaDecl(), decl)) { at->set_JavaDecl(decl); container->set_updated(); } if (!at->type().equal(typespec)) { at->set_Type(typespec); container->set_updated(); } at->set_usefull(); expected_order.append(at); } else { #endif if (!comment.isEmpty()) at->set_Description((decl.find("${description}") != -1) ? description : Lex::simplify_comment(comment)); if (finalp) at->set_isReadOnly(TRUE); if (transientp) at->set_isJavaTransient(TRUE); if (volatilep) at->set_isVolatile(TRUE); if (staticp) at->set_isClassMember(TRUE); if (!array.isEmpty()) { decl.insert(index + 7, "${multiplicity}"); at->set_Multiplicity(array); } if (! value.isEmpty()) at->set_DefaultValue(value); if (! annotation.isEmpty()) at->set_JavaAnnotations(annotation); if ((typespec.type == 0) && (cl->stereotype() != "enum")) { QCString t = typespec.explicit_type; int index2; if (!t.isEmpty() && (t.at(t.length() - 1) == '>') && ((index2 = t.find('<')) > 0)) { at->set_Stereotype(t.left(index2)); typespec.explicit_type = // may be a,b ... t.mid(index2 + 1, t.length() - 2 - index2); decl.replace(index, 7, "${stereotype}<${type}>"); } } at->set_Visibility(visibility); if (cl->stereotype() == "enum") { at->set_JavaDecl(decl); at->set_Stereotype("attribute"); } else if (decl != JavaSettings::attributeDecl("")) at->set_JavaDecl(decl); at->set_Type(typespec); #ifdef ROUNDTRIP if (roundtrip) expected_order.append(at); } #endif return TRUE; }
void UmlOperation::set_cpp(const char * return_form_or_inherit, const char * params, QCString body, bool inlinep, const char * if_def, const char * end_if) { if (*return_form_or_inherit == ':') { // inherit if (inlinep) { QCString s = remove_throw(CppSettings::operationDecl()); int index = s.find("${)}"); s.resize(index + 5); s.insert(index, params); s.append(" "); s.append(return_form_or_inherit); if (!body.isEmpty()) { s.append(" {\n "); s.append(body); s.append("}\n"); } else s.append(" {\n}\n"); conditional(s, if_def, end_if); set_CppDecl(s); set_CppDef(""); } else { QCString s = remove_throw(CppSettings::operationDecl()); int index = s.find("${)}"); s.resize(index + 5); s.insert(index, params); s.append(";"); conditional(s, if_def, end_if); set_CppDecl(s); s = remove_throw(CppSettings::operationDef()); index = s.find("${)}"); s.resize(index + 5); s.insert(index, params); s.append(" "); s.append(return_form_or_inherit); if (!body.isEmpty()) { s.append(" {\n "); s.append(body); s.append("}\n"); } else s.append(" {\n}\n"); conditional(s, if_def, end_if); set_CppDef(s); } } else { // return if (inlinep) { QCString s = remove_throw(CppSettings::operationDecl()); int index = s.find("${type}"); s.replace(index, 7, return_form_or_inherit); s.insert(s.find("${)}", index), params); s.resize(s.findRev(";") + 1); if (!body.isEmpty()) { s.append(" {\n "); s.append(body); s.append("}\n"); } else s.append(" {\n}\n"); conditional(s, if_def, end_if); set_CppDecl(s); set_CppDef(""); } else { QCString s = remove_throw(CppSettings::operationDecl()); int index = s.find("${type}"); s.replace(index, 7, return_form_or_inherit); s.insert(s.find("${)}", index), params); conditional(s, if_def, end_if); set_CppDecl(s); s = remove_throw(CppSettings::operationDef()); index = s.find("${type}"); s.replace(index, 7, return_form_or_inherit); s.insert(s.find("${)}", index), params); conditional(s, if_def, end_if); set_CppDef(s); set_CppBody(body); } } }