void WordEditFrame::on_valueEdit_currentCharFormatChanged(const QTextCharFormat &format)
{
ui->boldButton->setFlat(ui->valueEdit->fontWeight()==50);
ui->italicButton->setFlat(!ui->valueEdit->fontItalic());
ui->underlineButton->setFlat(!ui->valueEdit->fontUnderline());
ui->strikeOutButton->setFlat(!format.fontStrikeOut());
disconnect(ui->fontComboBox, SIGNAL(currentIndexChanged(QString)), this, SLOT(on_fontComboBox_currentIndexChanged(QString)));
disconnect(ui->fontSizeSpinBox, SIGNAL(valueChanged(int)), this, SLOT(on_fontSizeSpinBox_valueChanged(int)));
ui->fontComboBox->setCurrentFont(format.font());
ui->fontSizeSpinBox->setValue((int)format.fontPointSize());
connect(ui->fontComboBox, SIGNAL(currentIndexChanged(QString)), this, SLOT(on_fontComboBox_currentIndexChanged(QString)));
connect(ui->fontSizeSpinBox, SIGNAL(valueChanged(int)), this, SLOT(on_fontSizeSpinBox_valueChanged(int)));
QPalette aPalette=ui->textColorArea->palette();
aPalette.setColor(QPalette::Window, format.foreground().color());
ui->textColorArea->setPalette(aPalette);
aPalette=ui->backgroundColorArea->palette();
if (format.background().style()==Qt::NoBrush)
{
aPalette.setColor(QPalette::Window, QColor(255, 255, 255));
}
else
{
aPalette.setColor(QPalette::Window, format.background().color());
}
ui->backgroundColorArea->setPalette(aPalette);
}
void ChatLine::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) {
Q_UNUSED(option);
Q_UNUSED(widget);
const QAbstractItemModel *model_ = model();
QModelIndex myIdx = model_->index(row(), 0);
Message::Type type = (Message::Type)myIdx.data(MessageModel::TypeRole).toInt();
UiStyle::MessageLabel label = (UiStyle::MessageLabel)myIdx.data(ChatLineModel::MsgLabelRole).toInt();
QTextCharFormat msgFmt = QtUi::style()->format(UiStyle::formatType(type), label);
if(msgFmt.hasProperty(QTextFormat::BackgroundBrush)) {
painter->fillRect(boundingRect(), msgFmt.background());
}
if(_selection & Selected) {
QTextCharFormat selFmt = QtUi::style()->format(UiStyle::formatType(type), label | UiStyle::Selected);
if(selFmt.hasProperty(QTextFormat::BackgroundBrush)) {
qreal left = item((ChatLineModel::ColumnType)(_selection & ItemMask))->pos().x();
QRectF selectRect(left, 0, width() - left, height());
painter->fillRect(selectRect, selFmt.background());
}
}
// draw chatitems
// the items draw themselves at the correct position
timestampItem()->paint(painter, option, widget);
senderItem()->paint(painter, option, widget);
contentsItem()->paint(painter, option, widget);
}
void GenericCodeEditor::applySettings( Settings::Manager *settings )
{
settings->beginGroup("IDE/editor");
bool lineWrap = settings->value("lineWrap").toBool();
bool showWhitespace = settings->value("showWhitespace").toBool();
mInactiveFadeAlpha = settings->value("inactiveEditorFadeAlpha").toInt();
QPalette palette;
settings->beginGroup("colors");
if (settings->contains("text")) {
QTextCharFormat format = settings->value("text").value<QTextCharFormat>();
QBrush bg = format.background();
QBrush fg = format.foreground();
if (bg.style() != Qt::NoBrush)
palette.setBrush(QPalette::Base, bg);
if (fg.style() != Qt::NoBrush)
palette.setBrush(QPalette::Text, fg);
}
if (settings->contains("lineNumbers")) {
// NOTE: the line number widget will inherit the palette from the editor
QTextCharFormat format = settings->value("lineNumbers").value<QTextCharFormat>();
QBrush bg = format.background();
QBrush fg = format.foreground();
if (bg.style() != Qt::NoBrush)
palette.setBrush(QPalette::Mid, bg);
if (fg.style() != Qt::NoBrush)
palette.setBrush(QPalette::ButtonText, fg);
}
if (settings->contains("selection")) {
QTextCharFormat format = settings->value("selection").value<QTextCharFormat>();
QBrush bg = format.background();
QBrush fg = format.foreground();
if (bg.style() != Qt::NoBrush)
palette.setBrush(QPalette::Highlight, bg);
if (fg.style() != Qt::NoBrush)
palette.setBrush(QPalette::HighlightedText, fg);
}
mCurrentLineTextFormat = settings->value("currentLine").value<QTextCharFormat>();
mSearchResultTextFormat = settings->value("searchResult").value<QTextCharFormat>();
settings->endGroup(); // colors
mHighlightCurrentLine = settings->value("highlightCurrentLine").toBool();
updateCurrentLineHighlighting();
settings->endGroup(); // IDE/editor
setLineWrapMode( lineWrap ? QPlainTextEdit::WidgetWidth : QPlainTextEdit::NoWrap );
setShowWhitespace( showWhitespace );
setPalette(palette);
setActiveAppearance(hasFocus());
}
void GenericCodeEditor::applySettings( Settings::Manager *settings )
{
settings->beginGroup("IDE/editor");
bool lineWrap = settings->value("lineWrap").toBool();
QPalette palette;
settings->beginGroup("colors");
if (settings->contains("text")) {
QTextCharFormat format = settings->value("text").value<QTextCharFormat>();
QBrush bg = format.background();
QBrush fg = format.foreground();
if (bg.style() != Qt::NoBrush)
palette.setBrush(QPalette::Base, bg);
if (fg.style() != Qt::NoBrush)
palette.setBrush(QPalette::Text, fg);
}
if (settings->contains("lineNumbers")) {
// NOTE: the line number widget will inherit the palette from the editor
QTextCharFormat format = settings->value("lineNumbers").value<QTextCharFormat>();
QBrush bg = format.background();
QBrush fg = format.foreground();
if (bg.style() != Qt::NoBrush)
palette.setBrush(QPalette::Button, bg);
if (fg.style() != Qt::NoBrush)
palette.setBrush(QPalette::ButtonText, fg);
}
if (settings->contains("selection")) {
QTextCharFormat format = settings->value("selection").value<QTextCharFormat>();
QBrush bg = format.background();
QBrush fg = format.foreground();
if (bg.style() != Qt::NoBrush)
palette.setBrush(QPalette::Highlight, bg);
if (fg.style() != Qt::NoBrush)
palette.setBrush(QPalette::HighlightedText, fg);
}
mSearchResultTextFormat = settings->value("searchResult").value<QTextCharFormat>();
settings->endGroup(); // colors
settings->endGroup(); // IDE/editor
setLineWrapMode( lineWrap ? QPlainTextEdit::WidgetWidth : QPlainTextEdit::NoWrap );
setPalette(palette);
}
QVariant ChatLineModelItem::backgroundBrush(UiStyle::FormatType subelement, bool selected) const
{
QTextCharFormat fmt = QtUi::style()->format(UiStyle::formatType(_styledMsg.type()) | subelement, messageLabel() | (selected ? UiStyle::Selected : 0));
if (fmt.hasProperty(QTextFormat::BackgroundBrush))
return QVariant::fromValue<QBrush>(fmt.background());
return QVariant();
}
void PostWindow::applySettings(Settings::Manager * settings)
{
int scrollback = settings->value("IDE/postWindow/scrollback").toInt();
QFont font = settings->codeFont();
QPalette palette;
settings->beginGroup("IDE/editor/colors");
if (settings->contains("text")) {
QTextCharFormat format = settings->value("text").value<QTextCharFormat>();
QBrush bg = format.background();
QBrush fg = format.foreground();
if (bg.style() != Qt::NoBrush)
palette.setBrush(QPalette::Base, bg);
if (fg.style() != Qt::NoBrush)
palette.setBrush(QPalette::Text, fg);
}
settings->endGroup(); // colors
bool lineWrap = settings->value("IDE/postWindow/lineWrap").toBool();
setMaximumBlockCount(scrollback);
setFont(font);
setPalette(palette);
setLineWrap( lineWrap );
QFontMetrics metrics (font);
QString stringOfSpaces (settings->value("IDE/editor/indentWidth").toInt(), QChar(' '));
setTabStopWidth(metrics.width(stringOfSpaces));
updateActionShortcuts(settings);
}
static inline QTextCharFormat invertedColorFormat(const QTextCharFormat &in)
{
QTextCharFormat rc = in;
rc.setForeground(in.background());
rc.setBackground(in.foreground());
return rc;
}
void PostWindow::applySettings(Settings::Manager * settings)
{
int scrollback = settings->value("IDE/postWindow/scrollback").toInt();
QFont font = settings->codeFont();
QPalette palette;
settings->beginGroup("IDE/editor/colors");
if (settings->contains("text")) {
QTextCharFormat format = settings->value("text").value<QTextCharFormat>();
QBrush bg = format.background();
QBrush fg = format.foreground();
if (bg.style() != Qt::NoBrush)
palette.setBrush(QPalette::Base, bg);
if (fg.style() != Qt::NoBrush)
palette.setBrush(QPalette::Text, fg);
}
settings->endGroup(); // colors
bool lineWrap = settings->value("IDE/postWindow/lineWrap").toBool();
setMaximumBlockCount(scrollback);
setFont(font);
setPalette(palette);
setLineWrap( lineWrap );
}
void TextEdit::currentCharFormatChanged(const QTextCharFormat &format)
{
fontChanged(format.font());
colorChanged(format.foreground().color());
fontChanged(format.font());
colorChanged(format.background().color());
}
void EditorPage::updateTextFormatDisplay( QTreeWidgetItem *item )
{
QTextCharFormat format = item->data( 0, DefaultTextFormatRole ).value<QTextCharFormat>();
format.merge( item->data( 0, TextFormatRole ).value<QTextCharFormat>() );
QBrush fg = format.foreground();
if ( fg != Qt::NoBrush)
item->setForeground( 0, fg );
else
item->setData( 0, Qt::ForegroundRole, QVariant() );
QBrush bg = format.background();
if ( bg != Qt::NoBrush)
item->setBackground( 0, bg );
else
item->setData( 0, Qt::BackgroundRole, QVariant() );
QFont f;
if (format.hasProperty(QTextFormat::FontItalic))
f.setItalic( format.fontItalic() );
if (format.hasProperty(QTextFormat::FontWeight))
f.setWeight( format.fontWeight() );
item->setFont( 0, f );
}
void FontSettings::addMixinStyle(QTextCharFormat &textCharFormat,
const MixinTextStyles &mixinStyles) const
{
for (TextStyle mixinStyle : mixinStyles) {
const Format &format = m_scheme.formatFor(mixinStyle);
if (textCharFormat.hasProperty(QTextFormat::ForegroundBrush)) {
if (format.foreground().isValid())
textCharFormat.setForeground(format.foreground());
else
textCharFormat.setForeground(mixBrush(textCharFormat.foreground(),
format.relativeForegroundSaturation(),
format.relativeForegroundLightness()));
}
if (textCharFormat.hasProperty(QTextFormat::BackgroundBrush)) {
if (format.background().isValid())
textCharFormat.setBackground(format.background());
else
textCharFormat.setBackground(mixBrush(textCharFormat.background(),
format.relativeBackgroundSaturation(),
format.relativeBackgroundLightness()));
}
if (!textCharFormat.fontItalic())
textCharFormat.setFontItalic(format.italic());
if (textCharFormat.fontWeight() == QFont::Normal)
textCharFormat.setFontWeight(format.bold() ? QFont::Bold : QFont::Normal);
if (textCharFormat.underlineStyle() == QTextCharFormat::NoUnderline) {
textCharFormat.setUnderlineStyle(format.underlineStyle());
textCharFormat.setUnderlineColor(format.underlineColor());
}
};
}
Format::Format (QTextCharFormat tcf, QObject* parent):QObject (parent)
{
setBackground( tcf.background().color() );
setForeground( tcf.foreground().color() );
setBold( tcf.fontWeight() >= QFont::Bold );
setItalic( tcf.fontItalic() );
setPoints ( tcf.fontPointSize() );
}
ConfigurationDialog::ConfigurationDialog(QWidget *parent) :
QDialog(parent),
ui(new Ui::ConfigurationDialog),
m_settings(0)
{
ui->setupUi(this);
// Filter out characters which are not allowed in a file name
QRegExpValidator *fileNameValidator = new QRegExpValidator(ui->name);
fileNameValidator->setRegExp(QRegExp(QLatin1String("^[^\\/\\\\\\?\\>\\<\\*\\%\\:\\\"\\']*$")));
ui->name->setValidator(fileNameValidator);
updateDocumentation();
connect(ui->name, SIGNAL(textChanged(QString)), this, SLOT(updateOkButton()));
updateOkButton(); // force initial test.
connect(ui->editor, SIGNAL(documentationChanged(QString,QString)),
this, SLOT(updateDocumentation(QString,QString)));
// Set palette and font according to settings
const TextEditor::FontSettings fs = TextEditor::TextEditorSettings::instance()->fontSettings();
const QTextCharFormat tf = fs.toTextCharFormat(TextEditor::C_TEXT);
const QTextCharFormat selectionFormat = fs.toTextCharFormat(TextEditor::C_SELECTION);
QPalette pal;
pal.setColor(QPalette::Base, tf.background().color());
pal.setColor(QPalette::Text, tf.foreground().color());
pal.setColor(QPalette::Foreground, tf.foreground().color());
if (selectionFormat.background().style() != Qt::NoBrush)
pal.setColor(QPalette::Highlight, selectionFormat.background().color());
pal.setBrush(QPalette::HighlightedText, selectionFormat.foreground());
ui->documentation->setPalette(pal);
ui->editor->setPalette(pal);
ui->documentation->setFont(tf.font());
ui->editor->setFont(tf.font());
// Set style sheet for documentation browser
const QTextCharFormat tfOption = fs.toTextCharFormat(TextEditor::C_FIELD);
const QTextCharFormat tfParam = fs.toTextCharFormat(TextEditor::C_STRING);
const QString css = QString::fromLatin1("span.param {color: %1; background-color: %2;} "
"span.option {color: %3; background-color: %4;} "
"p { text-align: justify; } ")
.arg(tfParam.foreground().color().name())
.arg(tfParam.background().style() == Qt::NoBrush
? QString() : tfParam.background().color().name())
.arg(tfOption.foreground().color().name())
.arg(tfOption.background().style() == Qt::NoBrush
? QString() : tfOption.background().color().name())
;
ui->documentation->document()->setDefaultStyleSheet(css);
}
void ItemEditorWidget::setBackground()
{
QTextCursor tc = textCursor();
QTextCharFormat format = tc.charFormat();
QColorDialog dialog(this);
dialog.setOptions(dialog.options() | QColorDialog::ShowAlphaChannel);
dialog.setCurrentColor( format.background().color() );
if ( dialog.exec() == QDialog::Accepted ) {
const QColor color = dialog.selectedColor();
format.setBackground(color);
tc.setCharFormat(format);
}
}
void EditorPage::updateTextFormatDisplayCommons()
{
QTextCharFormat commonFormat =
mCommonTextFormatItem->data(0, TextFormatRole).value<QTextCharFormat>();
QPalette palette;
QBrush fg = commonFormat.foreground();
if ( fg != Qt::NoBrush)
palette.setBrush( QPalette::Text, fg );
QBrush bg = commonFormat.background();
if (bg != Qt::NoBrush)
palette.setBrush( QPalette::Base, bg );
ui->textFormats->setPalette(palette);
}
bool wxCalendarCtrl::Create(wxWindow *parent, wxWindowID id, const wxDateTime& date,
const wxPoint& pos, const wxSize& size, long style, const wxString& name )
{
m_qtCalendar = new wxQtCalendarWidget( parent, this );
m_qtCalendar->resize(m_qtCalendar->sizeHint());
{
// Init holiday colours
const QTextCharFormat format = m_qtCalendar->weekdayTextFormat(Qt::Sunday);
m_colHolidayFg = format.foreground().color();
wxMISSING_IMPLEMENTATION( "Get holiday background color" );
// Bug in Qt: returned background color is incorrect
//m_colHolidayBg = format.background().color();
}
{
// synchronize header colours
QTextCharFormat format = m_qtCalendar->headerTextFormat();
bool sync = false;
if ( m_colHeaderFg.IsOk() )
sync = true;
else
m_colHeaderFg = format.foreground().color();
if ( m_colHeaderBg.IsOk() )
sync = true;
else
m_colHeaderFg = format.background().color();
if ( sync )
SetHeaderColours(m_colHeaderFg, m_colHeaderBg);
}
UpdateStyle();
if ( date.IsValid() )
SetDate(date);
return QtCreateControl( parent, id, pos, size, style, wxDefaultValidator, name );
}
void EditorPage::updateTextFormatEdit()
{
QTreeWidgetItem *item = ui->textFormats->currentItem();
bool canEdit = item && item->data(0, TextFormatConfigKeyRole).isValid();
ui->textFormatEdit->setEnabled(canEdit);
if (!canEdit) {
ui->fgPicker->setBrush( QBrush() );
ui->bgPicker->setBrush( QBrush() );
ui->italicOption->setChecked(false);
ui->italicOption->setChecked(false);
}
else {
QTextCharFormat format = item->data( 0, TextFormatRole).value<QTextCharFormat>();
ui->fgPicker->setBrush( format.foreground() );
ui->bgPicker->setBrush( format.background() );
ui->italicOption->setChecked( format.fontItalic() );
ui->boldOption->setChecked( format.fontWeight() == QFont::Bold );
}
}
void FontSettings::addMixinStyle(QTextCharFormat &textCharFormat,
const MixinTextStyles &mixinStyles) const
{
for (TextStyle mixinStyle : mixinStyles) {
const QTextCharFormat mixinTextCharFormat = toTextCharFormat(mixinStyle);
if (!textCharFormat.hasProperty(QTextFormat::ForegroundBrush))
textCharFormat.setForeground(mixinTextCharFormat.foreground());
if (!textCharFormat.hasProperty(QTextFormat::BackgroundBrush))
textCharFormat.setBackground(mixinTextCharFormat.background());
if (!textCharFormat.fontItalic())
textCharFormat.setFontItalic(mixinTextCharFormat.fontItalic());
if (textCharFormat.fontWeight() == QFont::Normal)
textCharFormat.setFontWeight(mixinTextCharFormat.fontWeight());
if (textCharFormat.underlineStyle() == QTextCharFormat::NoUnderline) {
textCharFormat.setUnderlineStyle(mixinTextCharFormat.underlineStyle());
textCharFormat.setUnderlineColor(mixinTextCharFormat.underlineColor());
}
};
}
void QTextOdfWriter::writeCharacterFormat(QXmlStreamWriter &writer, QTextCharFormat format, int formatIndex) const
{
writer.writeStartElement(styleNS, QString::fromLatin1("style"));
writer.writeAttribute(styleNS, QString::fromLatin1("name"), QString::fromLatin1("c%1").arg(formatIndex));
writer.writeAttribute(styleNS, QString::fromLatin1("family"), QString::fromLatin1("text"));
writer.writeEmptyElement(styleNS, QString::fromLatin1("text-properties"));
if (format.fontItalic())
writer.writeAttribute(foNS, QString::fromLatin1("font-style"), QString::fromLatin1("italic"));
if (format.hasProperty(QTextFormat::FontWeight) && format.fontWeight() != QFont::Normal) {
QString value;
if (format.fontWeight() == QFont::Bold)
value = QString::fromLatin1("bold");
else
value = QString::number(format.fontWeight() * 10);
writer.writeAttribute(foNS, QString::fromLatin1("font-weight"), value);
}
if (format.hasProperty(QTextFormat::FontFamily))
writer.writeAttribute(foNS, QString::fromLatin1("font-family"), format.fontFamily());
else
writer.writeAttribute(foNS, QString::fromLatin1("font-family"), QString::fromLatin1("Sans")); // Qt default
if (format.hasProperty(QTextFormat::FontPointSize))
writer.writeAttribute(foNS, QString::fromLatin1("font-size"), QString::fromLatin1("%1pt").arg(format.fontPointSize()));
if (format.hasProperty(QTextFormat::FontCapitalization)) {
switch(format.fontCapitalization()) {
case QFont::MixedCase:
writer.writeAttribute(foNS, QString::fromLatin1("text-transform"), QString::fromLatin1("none")); break;
case QFont::AllUppercase:
writer.writeAttribute(foNS, QString::fromLatin1("text-transform"), QString::fromLatin1("uppercase")); break;
case QFont::AllLowercase:
writer.writeAttribute(foNS, QString::fromLatin1("text-transform"), QString::fromLatin1("lowercase")); break;
case QFont::Capitalize:
writer.writeAttribute(foNS, QString::fromLatin1("text-transform"), QString::fromLatin1("capitalize")); break;
case QFont::SmallCaps:
writer.writeAttribute(foNS, QString::fromLatin1("font-variant"), QString::fromLatin1("small-caps")); break;
}
}
if (format.hasProperty(QTextFormat::FontLetterSpacing))
writer.writeAttribute(foNS, QString::fromLatin1("letter-spacing"), pixelToPoint(format.fontLetterSpacing()));
if (format.hasProperty(QTextFormat::FontWordSpacing) && format.fontWordSpacing() != 0)
writer.writeAttribute(foNS, QString::fromLatin1("word-spacing"), pixelToPoint(format.fontWordSpacing()));
if (format.hasProperty(QTextFormat::FontUnderline))
writer.writeAttribute(styleNS, QString::fromLatin1("text-underline-type"),
format.fontUnderline() ? QString::fromLatin1("single") : QString::fromLatin1("none"));
if (format.hasProperty(QTextFormat::FontOverline)) {
// bool fontOverline () const TODO
}
if (format.hasProperty(QTextFormat::FontStrikeOut))
writer.writeAttribute(styleNS,QString::fromLatin1( "text-line-through-type"),
format.fontStrikeOut() ? QString::fromLatin1("single") : QString::fromLatin1("none"));
if (format.hasProperty(QTextFormat::TextUnderlineColor))
writer.writeAttribute(styleNS, QString::fromLatin1("text-underline-color"), format.underlineColor().name());
if (format.hasProperty(QTextFormat::FontFixedPitch)) {
// bool fontFixedPitch () const TODO
}
if (format.hasProperty(QTextFormat::TextUnderlineStyle)) {
QString value;
switch (format.underlineStyle()) {
case QTextCharFormat::NoUnderline: value = QString::fromLatin1("none"); break;
case QTextCharFormat::SingleUnderline: value = QString::fromLatin1("solid"); break;
case QTextCharFormat::DashUnderline: value = QString::fromLatin1("dash"); break;
case QTextCharFormat::DotLine: value = QString::fromLatin1("dotted"); break;
case QTextCharFormat::DashDotLine: value = QString::fromLatin1("dash-dot"); break;
case QTextCharFormat::DashDotDotLine: value = QString::fromLatin1("dot-dot-dash"); break;
case QTextCharFormat::WaveUnderline: value = QString::fromLatin1("wave"); break;
case QTextCharFormat::SpellCheckUnderline: value = QString::fromLatin1("none"); break;
}
writer.writeAttribute(styleNS, QString::fromLatin1("text-underline-style"), value);
}
if (format.hasProperty(QTextFormat::TextVerticalAlignment)) {
QString value;
switch (format.verticalAlignment()) {
case QTextCharFormat::AlignMiddle:
case QTextCharFormat::AlignNormal: value = QString::fromLatin1("0%"); break;
case QTextCharFormat::AlignSuperScript: value = QString::fromLatin1("super"); break;
case QTextCharFormat::AlignSubScript: value = QString::fromLatin1("sub"); break;
case QTextCharFormat::AlignTop: value = QString::fromLatin1("100%"); break;
case QTextCharFormat::AlignBottom : value = QString::fromLatin1("-100%"); break;
case QTextCharFormat::AlignBaseline: break;
}
writer.writeAttribute(styleNS, QString::fromLatin1("text-position"), value);
}
if (format.hasProperty(QTextFormat::TextOutline))
writer.writeAttribute(styleNS, QString::fromLatin1("text-outline"), QString::fromLatin1("true"));
if (format.hasProperty(QTextFormat::TextToolTip)) {
// QString toolTip () const TODO
}
if (format.hasProperty(QTextFormat::IsAnchor)) {
// bool isAnchor () const TODO
}
if (format.hasProperty(QTextFormat::AnchorHref)) {
// QString anchorHref () const TODO
}
if (format.hasProperty(QTextFormat::AnchorName)) {
// QString anchorName () const TODO
}
if (format.hasProperty(QTextFormat::ForegroundBrush)) {
QBrush brush = format.foreground();
writer.writeAttribute(foNS, QString::fromLatin1("color"), brush.color().name());
}
if (format.hasProperty(QTextFormat::BackgroundBrush)) {
QBrush brush = format.background();
writer.writeAttribute(foNS, QString::fromLatin1("background-color"), brush.color().name());
}
writer.writeEndElement(); // style
}
QList<HtmlExporter::tag> HtmlExporter::emitCharFormatStyle( const QTextCharFormat
&charFormat, const QTextBlockFormat &blockFormat )
{
// kDebug() << "html" << html;
QList<HtmlExporter::tag> tags;
bool attributesEmitted = false;
QLatin1String styleTag( "<span style=\"" );
const QString family = charFormat.fontFamily();
//if (!family.isEmpty() && family != defaultCharFormat.fontFamily()) {
// NOTE the above line replaced with the bottom line to use default charFormat, which can be set from outside.
if ( charFormat.hasProperty( BilboTextFormat::HasCodeStyle ) &&
charFormat.boolProperty( BilboTextFormat::HasCodeStyle ) ) {
tags << code;
} else if ( !family.isEmpty() && family != mDefaultCharFormat.fontFamily() ) {
// if ( family.right( 7 ) == "courier" ) {
// tags << code;
// } else {
if ( ! attributesEmitted ) {
html += styleTag;
}
html += QLatin1String( " font-family:'" );
html += family;
html += QLatin1String( "';" );
attributesEmitted = true;
// }
}
// if (format.hasProperty(QTextFormat::FontPointSize)
// && format.fontPointSize() != defaultCharFormat.fontPointSize()) {
// NOTE the above line replaced with the bottom line to use default charFormat, which can be set from outside.
if ( charFormat.hasProperty( QTextFormat::FontPointSize )
&& charFormat.fontPointSize() != mDefaultCharFormat.fontPointSize() ) {
if ( ! attributesEmitted ) {
html += styleTag;
}
html += QLatin1String( " font-size:" );
html += QString::number( charFormat.fontPointSize() );
html += QLatin1String( "pt;" );
attributesEmitted = true;
} else if ( charFormat.hasProperty( QTextFormat::FontSizeAdjustment ) &&
!( blockFormat.hasProperty( BilboTextFormat::HtmlHeading ) &&
blockFormat.intProperty( BilboTextFormat::HtmlHeading ) ) ) {
///To use <h1-5> tags for font size
// const int idx = format.intProperty(QTextFormat::FontSizeAdjustment) + 1;
//
// switch (idx) {
// case 0: tags << h5; break;
// //case 1: tags << h4; break; //NOTE h4 will be the normal text!
// case 2: tags << h3; break;
// case 3: tags << h2; break;
// case 4: tags << h1; break;
// }
///To use <span> tags for font size
static const char * const sizeNames[] = {
"small", "medium", "large", "x-large", "xx-large"
};
const char *name = 0;
const int idx = charFormat.intProperty( QTextFormat::FontSizeAdjustment ) + 1;
if ( idx == 1 ) {
// assume default to not bloat the html too much
} else if ( idx >= 0 && idx <= 4 ) {
name = sizeNames[idx];
}
if ( name ) {
if ( ! attributesEmitted ) {
html += styleTag;
}
html += QLatin1String( " font-size:" );
html += QLatin1String( name );
html += QLatin1Char( ';' );
attributesEmitted = true;
}
}
// if (format.fontWeight() > defaultCharFormat.fontWeight()) {
// NOTE the above line replaced with the bottom line to use default charFormat, which can be set from outside.
if ( charFormat.fontWeight() > mDefaultCharFormat.fontWeight() &&
!( blockFormat.hasProperty( BilboTextFormat::HtmlHeading ) &&
blockFormat.intProperty( BilboTextFormat::HtmlHeading ) ) ) {
tags << strong;
/*if (! attributesEmitted ) html += styleTag;
html += QLatin1String(" font-weight:");
html += QString::number(format.fontWeight() * 8);
html += QLatin1Char(';');
attributesEmitted = true;*/
}
// if (format.fontItalic() != defaultCharFormat.fontItalic()) {
// NOTE the above line replaced with the bottom line to use default charFormat, which can be set from outside.
if ( charFormat.fontItalic() != mDefaultCharFormat.fontItalic() ) {
tags << em;
/*
if (! attributesEmitted ) html += styleTag;
html += QLatin1String(" font-style:");
html += (format.fontItalic() ? QLatin1String("italic") : QLatin1String("normal"));
html += QLatin1Char(';');
attributesEmitted = true;*/
}
// if (format.fontUnderline() != defaultCharFormat.fontUnderline()) {
// NOTE the above line replaced with the bottom line to use default charFormat, which can be set from outside.
if ( charFormat.fontUnderline() != mDefaultCharFormat.fontUnderline() ) {
tags << u;
}
// if (format.fontStrikeOut() != defaultCharFormat.fontStrikeOut()) {
// NOTE the above line replaced with the bottom line to use default charFormat, which can be set from outside.
if ( charFormat.fontStrikeOut() != mDefaultCharFormat.fontStrikeOut() ) {
tags << s;
}
// if (format.fontOverline() != defaultCharFormat.fontOverline()) {
// NOTE the above line replaced with the bottom line to use default charFormat, which can be set from outside.
if ( charFormat.fontOverline() != mDefaultCharFormat.fontOverline() ) {
if ( charFormat.fontOverline() ) {
if ( ! attributesEmitted ) {
html += styleTag;
}
html += QLatin1String( " text-decoration: overline;" );
attributesEmitted = true;
}
}
/*
bool hasDecoration = false;
bool atLeastOneDecorationSet = false;
QLatin1String decorationTag(" text-decoration:");
if (format.fontUnderline() != defaultCharFormat.fontUnderline() ||
format.fontOverline() != defaultCharFormat.fontOverline() ||
format.fontStrikeOut() != defaultCharFormat.fontStrikeOut() )
{
if (! attributesEmitted ) html += styleTag;
html += decorationTag;
}
if (format.fontUnderline() != defaultCharFormat.fontUnderline()) {
hasDecoration = true;
if (format.fontUnderline()) {
html += QLatin1String(" underline");
atLeastOneDecorationSet = true;
}
}
if (format.fontOverline() != defaultCharFormat.fontOverline()) {
hasDecoration = true;
if (format.fontOverline()) {
html += QLatin1String(" overline");
atLeastOneDecorationSet = true;
}
}
if (format.fontStrikeOut() != defaultCharFormat.fontStrikeOut()) {
hasDecoration = true;
if (format.fontStrikeOut()) {
html += QLatin1String(" line-through");
atLeastOneDecorationSet = true;
}
}
if (hasDecoration) {
if (!atLeastOneDecorationSet)
html += QLatin1String("none");
html += QLatin1Char(';');
attributesEmitted = true;
}*/
/* else {
html.chop(qstrlen(decorationTag.latin1()));
}*/
// QBrush linkColor = KColorScheme(QPalette::Active, KColorScheme::Window).foreground(KColorScheme::LinkText);
// if ( format.foreground() != defaultCharFormat.foreground() &&
// format.foreground().style() != Qt::NoBrush) {
// NOTE the above line replaced with the bottom line to use default charFormat, which can be set from outside.
if ( charFormat.foreground() != mDefaultCharFormat.foreground() &&
charFormat.foreground().style() != Qt::NoBrush && !charFormat.isAnchor() ) {
// if ( format.foreground() != linkColor ) {
// if ( format.anchorHref().isNull() ) {
if ( ! attributesEmitted ) {
html += styleTag;
attributesEmitted = true;
}
// } else {
// html += QLatin1String(" style=\"");
// }
html += QLatin1String( " color:" );
html += charFormat.foreground().color().name();
html += QLatin1Char( ';' );
// if ( !format.anchorHref().isNull() ) {
// html += QLatin1String("\"");
// }
// attributesEmitted = true;
// }
}
// if (format.background() != defaultCharFormat.background()
// && format.background().style() != Qt::NoBrush) {
// NOTE the above line replaced with the bottom line to use default charFormat, which can be set from outside.
if ( !( charFormat.hasProperty( BilboTextFormat::HasCodeStyle ) &&
charFormat.boolProperty( BilboTextFormat::HasCodeStyle ) ) ) {
if ( charFormat.background() != mDefaultCharFormat.background()
&& charFormat.background().style() != Qt::NoBrush ) {
if ( ! attributesEmitted ) {
html += styleTag;
}
html += QLatin1String( " background-color:" );
html += charFormat.background().color().name();
html += QLatin1Char( ';' );
attributesEmitted = true;
}
}
// if (format.verticalAlignment() != defaultCharFormat.verticalAlignment()) { //TODO
// NOTE the above line replaced with the bottom line to use default charFormat, which can be set from outside.
if ( charFormat.verticalAlignment() != mDefaultCharFormat.verticalAlignment() ) { //TODO
if ( ! attributesEmitted ) {
html += styleTag;
}
html += QLatin1String( " vertical-align:" );
QTextCharFormat::VerticalAlignment valign = charFormat.verticalAlignment();
if ( valign == QTextCharFormat::AlignSubScript ) {
html += QLatin1String( "sub" );
} else if ( valign == QTextCharFormat::AlignSuperScript ) {
html += QLatin1String( "super" );
}
html += QLatin1Char( ';' );
attributesEmitted = true;
}
//Append close span Tag
if ( attributesEmitted ) {
html += QLatin1String( "\">" );
tags.prepend( span );
}
// kDebug() << "html=>" << html << tags;
return tags;
}
void MarkupHighlighter::highlightBlock(const QString &text)
{
if (FORMATTING.empty()){
qWarning() << "Not given any formatting, so not highlighting.";
return;
}
if (text.isEmpty()) return;
int start=0, end=0, highlightLength = 0;
QRegularExpression re;
QTextCharFormat textFormat;
for (QString exp : TOKENS.keys()){
setCurrentBlockState(0);
start = 0, end = 0;
re = QRegularExpression(exp);
if (!re.isValid()){
QString message = "Invalid regular expression \""
+ re.pattern() + "\" :" + re.errorString();
qFatal("%s", message.toStdString().data());
return;
}
if (previousBlockState() != 1)
start = re.match(text).capturedStart();
while (start >= 0){
QRegularExpressionMatch match = re.match(text, start);
end = match.capturedEnd();
if (end == -1 || (end == start && end != 0)){
setCurrentBlockState(1);
highlightLength = text.length();
} else {
highlightLength = match.capturedLength();
}
QTextCharFormat baseFormat = currentBlock().blockFormat().toCharFormat();
MarkupHighlighter::MarkupToken tok = TOKENS[exp];
if (!FORMATTING.contains(tok)){
qWarning() << "Could not find" << tok;
break;
}
const StyleProxy *styleProxy = FORMATTING[tok];
textFormat = styleProxy->toFormat(baseFormat);
setFormat(start, highlightLength, textFormat);
qDebug() << "highlightBlock";
qDebug() << "Formatting"
<< "token" << tok
<< "with regex=" << exp
<< ", string="
<< text.mid(start, highlightLength)
<< "\n"
<< " Bold?" << textFormat.font().bold() << "\n"
<< " Italic?" << textFormat.font().italic() << "\n"
<< " Size:" << textFormat.font().pointSize() << "\n"
<< " Background:" << textFormat.background().color();
start = re.match(text, end).capturedStart();
// This should not be 0 again. If it is, that means our search has
// come up empty.
if (start == 0)
start = -1;
}
}
}
void QQuickTextNodeEngine::addTextBlock(QTextDocument *textDocument, const QTextBlock &block, const QPointF &position, const QColor &textColor, const QColor &anchorColor, int selectionStart, int selectionEnd)
{
Q_ASSERT(textDocument);
#ifndef QT_NO_IM
int preeditLength = block.isValid() ? block.layout()->preeditAreaText().length() : 0;
int preeditPosition = block.isValid() ? block.layout()->preeditAreaPosition() : -1;
#endif
QVarLengthArray<QTextLayout::FormatRange> colorChanges;
mergeFormats(block.layout(), &colorChanges);
QPointF blockPosition = textDocument->documentLayout()->blockBoundingRect(block).topLeft() + position;
if (QTextList *textList = block.textList()) {
QPointF pos = blockPosition;
QTextLayout *layout = block.layout();
if (layout->lineCount() > 0) {
QTextLine firstLine = layout->lineAt(0);
Q_ASSERT(firstLine.isValid());
setCurrentLine(firstLine);
QRectF textRect = firstLine.naturalTextRect();
pos += textRect.topLeft();
if (block.textDirection() == Qt::RightToLeft)
pos.rx() += textRect.width();
const QTextCharFormat charFormat = block.charFormat();
QFont font(charFormat.font());
QFontMetricsF fontMetrics(font);
QTextListFormat listFormat = textList->format();
QString listItemBullet;
switch (listFormat.style()) {
case QTextListFormat::ListCircle:
listItemBullet = QChar(0x25E6); // White bullet
break;
case QTextListFormat::ListSquare:
listItemBullet = QChar(0x25AA); // Black small square
break;
case QTextListFormat::ListDecimal:
case QTextListFormat::ListLowerAlpha:
case QTextListFormat::ListUpperAlpha:
case QTextListFormat::ListLowerRoman:
case QTextListFormat::ListUpperRoman:
listItemBullet = textList->itemText(block);
break;
default:
listItemBullet = QChar(0x2022); // Black bullet
break;
};
QSizeF size(fontMetrics.width(listItemBullet), fontMetrics.height());
qreal xoff = fontMetrics.width(QLatin1Char(' '));
if (block.textDirection() == Qt::LeftToRight)
xoff = -xoff - size.width();
setPosition(pos + QPointF(xoff, 0));
QTextLayout layout;
layout.setFont(font);
layout.setText(listItemBullet); // Bullet
layout.beginLayout();
QTextLine line = layout.createLine();
line.setPosition(QPointF(0, 0));
layout.endLayout();
QList<QGlyphRun> glyphRuns = layout.glyphRuns();
for (int i=0; i<glyphRuns.size(); ++i)
addUnselectedGlyphs(glyphRuns.at(i));
}
}
int textPos = block.position();
QTextBlock::iterator blockIterator = block.begin();
while (!blockIterator.atEnd()) {
QTextFragment fragment = blockIterator.fragment();
QString text = fragment.text();
if (text.isEmpty())
continue;
QTextCharFormat charFormat = fragment.charFormat();
QFont font(charFormat.font());
QFontMetricsF fontMetrics(font);
int fontHeight = fontMetrics.descent() + fontMetrics.ascent();
int valign = charFormat.verticalAlignment();
if (valign == QTextCharFormat::AlignSuperScript)
setPosition(QPointF(blockPosition.x(), blockPosition.y() - fontHeight / 2));
else if (valign == QTextCharFormat::AlignSubScript)
setPosition(QPointF(blockPosition.x(), blockPosition.y() + fontHeight / 6));
else
setPosition(blockPosition);
if (text.contains(QChar::ObjectReplacementCharacter)) {
QTextFrame *frame = qobject_cast<QTextFrame *>(textDocument->objectForFormat(charFormat));
if (frame && frame->frameFormat().position() == QTextFrameFormat::InFlow) {
int blockRelativePosition = textPos - block.position();
QTextLine line = block.layout()->lineForTextPosition(blockRelativePosition);
if (!currentLine().isValid()
|| line.lineNumber() != currentLine().lineNumber()) {
setCurrentLine(line);
}
QQuickTextNodeEngine::SelectionState selectionState =
(selectionStart < textPos + text.length()
&& selectionEnd >= textPos)
? QQuickTextNodeEngine::Selected
: QQuickTextNodeEngine::Unselected;
addTextObject(QPointF(), charFormat, selectionState, textDocument, textPos);
}
textPos += text.length();
} else {
if (charFormat.foreground().style() != Qt::NoBrush)
setTextColor(charFormat.foreground().color());
else if (charFormat.isAnchor())
setTextColor(anchorColor);
else
setTextColor(textColor);
int fragmentEnd = textPos + fragment.length();
#ifndef QT_NO_IM
if (preeditPosition >= 0
&& (preeditPosition + block.position()) >= textPos
&& (preeditPosition + block.position()) <= fragmentEnd) {
fragmentEnd += preeditLength;
}
#endif
if (charFormat.background().style() != Qt::NoBrush) {
QTextLayout::FormatRange additionalFormat;
additionalFormat.start = textPos - block.position();
additionalFormat.length = fragmentEnd - textPos;
additionalFormat.format = charFormat;
colorChanges << additionalFormat;
}
textPos = addText(block, charFormat, textColor, colorChanges, textPos, fragmentEnd,
selectionStart, selectionEnd);
}
++blockIterator;
}
#ifndef QT_NO_IM
if (preeditLength >= 0 && textPos <= block.position() + preeditPosition) {
setPosition(blockPosition);
textPos = block.position() + preeditPosition;
QTextLine line = block.layout()->lineForTextPosition(preeditPosition);
if (!currentLine().isValid()
|| line.lineNumber() != currentLine().lineNumber()) {
setCurrentLine(line);
}
textPos = addText(block, block.charFormat(), textColor, colorChanges,
textPos, textPos + preeditLength,
selectionStart, selectionEnd);
}
#endif
setCurrentLine(QTextLine()); // Reset current line because the text layout changed
m_hasContents = true;
}
void HtmlExporter::emitTable( const QTextTable *table )
{
//qDebug() << "emitTable" << html;
QTextTableFormat format = table->format();
html += QLatin1String( "\n<table" );
if ( format.hasProperty( QTextFormat::FrameBorder ) ) {
emitAttribute( "border", QString::number( format.border() ) );
}
emitFloatStyle( format.position() );
emitAlignment( format.alignment() );
emitTextLength( "width", format.width() );
if ( format.hasProperty( QTextFormat::TableCellSpacing ) ) {
emitAttribute( "cellspacing", QString::number( format.cellSpacing() ) );
}
if ( format.hasProperty( QTextFormat::TableCellPadding ) ) {
emitAttribute( "cellpadding", QString::number( format.cellPadding() ) );
}
QBrush bg = format.background();
if ( bg != Qt::NoBrush ) {
emitAttribute( "bgcolor", bg.color().name() );
}
html += QLatin1Char( '>' );
const int rows = table->rows();
const int columns = table->columns();
QVector<QTextLength> columnWidths = format.columnWidthConstraints();
if ( columnWidths.isEmpty() ) {
columnWidths.resize( columns );
columnWidths.fill( QTextLength() );
}
// Q_ASSERT(columnWidths.count() == columns);
QVarLengthArray<bool> widthEmittedForColumn( columns );
for ( int i = 0; i < columns; ++i ) {
widthEmittedForColumn[i] = false;
}
const int headerRowCount = qMin( format.headerRowCount(), rows );
if ( headerRowCount > 0 ) {
html += QLatin1String( "<thead>" );
}
for ( int row = 0; row < rows; ++row ) {
html += QLatin1String( "\n<tr>" );
for ( int col = 0; col < columns; ++col ) {
const QTextTableCell cell = table->cellAt( row, col );
// for col/rowspans
if ( cell.row() != row ) {
continue;
}
if ( cell.column() != col ) {
continue;
}
html += QLatin1String( "\n<td" );
if ( !widthEmittedForColumn[col] ) {
emitTextLength( "width", columnWidths.at( col ) );
widthEmittedForColumn[col] = true;
}
if ( cell.columnSpan() > 1 ) {
emitAttribute( "colspan", QString::number( cell.columnSpan() ) );
}
if ( cell.rowSpan() > 1 ) {
emitAttribute( "rowspan", QString::number( cell.rowSpan() ) );
}
const QTextCharFormat cellFormat = cell.format();
QBrush bg = cellFormat.background();
if ( bg != Qt::NoBrush ) {
emitAttribute( "bgcolor", bg.color().name() );
}
html += QLatin1Char( '>' );
emitFrame( cell.begin() );
html += QLatin1String( "</td>" );
}
html += QLatin1String( "</tr>" );
if ( headerRowCount > 0 && row == headerRowCount - 1 ) {
html += QLatin1String( "</thead>" );
}
}
html += QLatin1String( "</table>" );
}
void AppearancePreferences::reset()
{
QSettings settings;
// Empty this
_ui->programTokenTable->clear();
// Declare some variables which will be used to populate the table
QTextCharFormat format;
QTableWidgetItem *item;
int row = 0;
int column = 0;
QStringList headers;
headers << "Token" << "Font" << "Foreground" << "Background";
_ui->programTokenTable->setHorizontalHeaderLabels(headers);
QVector<int> tokens;
// Default, identifiers, declaration identifiers, operators, keywords,
// comments and errors
tokens << ProgramLexeme_Default << ProgramLexeme_Identifier << ProgramLexeme_Declaration << ProgramLexeme_DeclarationOperator
<< ProgramLexeme_Keyword << ProgramLexeme_Comment << ProgramLexeme_Error;
_ui->programTokenTable->setRowCount(tokens.count());
for(row = 0; row < tokens.count(); ++row)
{
format = _ui->plainTextEdit->highlighter()->format(tokens.at(row));
for(column = 0; column < 4; ++column)
{
item = new QTableWidgetItem();
switch(column)
{
case 0:
// The name of this token type
switch(tokens.at(row))
{
case ProgramLexeme_Default:
item->setText("Default");
break;
case ProgramLexeme_Identifier:
item->setText("Identifiers");
break;
case ProgramLexeme_Declaration:
item->setText("Macro Declarations");
break;
case ProgramLexeme_DeclarationOperator:
item->setText("Operators");
break;
case ProgramLexeme_Keyword:
item->setText("Keywords");
break;
case ProgramLexeme_Comment:
item->setText("Comments");
break;
case ProgramLexeme_Error:
item->setText("Errors");
break;
default:
qDebug() << "Unknown token type encountered in "
"AppearancePreferences::reset(), passed "
<< tokens.at(row);
break;
}
item->setFlags(Qt::ItemIsSelectable);
item->setFont(format.font());
item->setForeground(format.foreground());
item->setBackground(format.background());
break;
case 1:
// The font
item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
item->setText(format.font().family() + ", "
+ QVariant(format.fontPointSize()).toString());
break;
case 2:
// The foreground colour
item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEditable
| Qt::ItemIsEnabled);
item->setText(QVariant(format.foreground().color()).toString());
break;
case 3:
// The background colour
item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEditable
| Qt::ItemIsEnabled);
item->setText(QVariant(format.background().color()).toString());
break;
default:
qDebug() << "Unexpected column ID in "
"AppearancePreferences::reset(), passed " << column;
break;
}
_ui->programTokenTable->setItem(row, column, item);
}
}
// Now have the table rejig to fit the items it now contains
_ui->programTokenTable->resizeColumnsToContents();
}
void ClientTextEdit::updateFormat(QTextCharFormat& format, int ansiCode)
{
/*
if (ansiCode != previous)
qDebug("new code: %d", ansiCode);
else
qDebug("repeat");
*/
previous = ansiCode;
QBrush tempBrush;
switch (ansiCode) {
case 0:
// turn ANSI off (i.e. return to normal defaults)
format = _defaultFormat;
//format.clearBackground();
//format.clearForeground();
break;
case 1:
// bold
format.setFontWeight(QFont::Bold);
updateFormatBoldColor(format);
break;
case 4:
// underline
format.setFontUnderline(true);
break;
case 5:
// blink
// TODO
break;
case 7:
// inverse
tempBrush = format.background();
format.setBackground(format.foreground());
format.setForeground(tempBrush);
break;
case 8:
// strike-through
format.setFontStrikeOut(true);
break;
case 30:
// black foreground
format.setForeground(_blackColor);
break;
case 31:
// red foreground
format.setForeground(_redColor);
break;
case 32:
// green foreground
format.setForeground(_greenColor);
break;
case 33:
// yellow foreground
format.setForeground(_yellowColor);
break;
case 34:
// blue foreground
format.setForeground(_blueColor);
break;
case 35:
// magenta foreground
format.setForeground(_magentaColor);
break;
case 36:
// cyan foreground
format.setForeground(_cyanColor);
break;
case 37:
// gray foreground
format.setForeground(_grayColor);
break;
case 40:
// black background
format.setBackground(_blackColor);
break;
case 41:
// red background
format.setBackground(_redColor);
break;
case 42:
// green background
format.setBackground(_greenColor);
break;
case 43:
// yellow background
format.setBackground(_yellowColor);
break;
case 44:
// blue background
format.setBackground(_blueColor);
break;
case 45:
// magenta background
format.setBackground(_magentaColor);
break;
case 46:
// cyan background
format.setBackground(_cyanColor);
break;
case 47:
// gray background
format.setBackground(_grayColor);
break;
case 90:
// high-black foreground
format.setForeground(_darkGrayColor);
break;
case 91:
// high-red foreground
format.setForeground(_brightRedColor);
break;
case 92:
// high-green foreground
format.setForeground(_brightGreenColor);
break;
case 93:
// high-yellow foreground
format.setForeground(_brightYellowColor);
break;
case 94:
// high-blue foreground
format.setForeground(_brightBlueColor);
break;
case 95:
// high-magenta foreground
format.setForeground(_brightMagentaColor);
break;
case 96:
// high-cyan foreground
format.setForeground(_brightCyanColor);
break;
case 97:
// high-white foreground
format.setForeground(_whiteColor);
break;
case 100:
// high-black background
format.setBackground(_darkGrayColor);
break;
case 101:
// high-red background
format.setBackground(_brightRedColor);
break;
case 102:
// high-green background
format.setBackground(_brightGreenColor);
break;
case 103:
// high-yellow background
format.setBackground(_brightYellowColor);
break;
case 104:
// high-blue background
format.setBackground(_brightBlueColor);
break;
case 105:
// high-magenta background
format.setBackground(_brightMagentaColor);
break;
case 106:
// high-cyan background
format.setBackground(_brightCyanColor);
break;
case 107:
// high-white background
format.setBackground(_whiteColor);
break;
default:
qDebug("Unknown!");
format.setBackground(Qt::gray);
};
}
void MRichTextEdit::slotCurrentCharFormatChanged(const QTextCharFormat &format)
{
fontChanged(format.font());
bgColorChanged((format.background().isOpaque()) ? format.background().color() : QColor());
f_link->setChecked(format.isAnchor());
}
