BackStageForm::BackStageForm(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::BackStageForm)
{
	_log = NULL;

	ui->setupUi(this);

	connect(ui->buttonOpen, SIGNAL(clicked()), this, SLOT(openFile()));
	connect(ui->buttonClose, SIGNAL(clicked()), this, SLOT(closeItemSelected()));
	connect(ui->buttonExport, SIGNAL(clicked()), this, SLOT(exportItemSelected()));

	connect(ui->buttonSaveAs, SIGNAL(clicked()), this, SLOT(saveAs()));
	connect(ui->buttonSave, SIGNAL(clicked()), this, SLOT(save()));

	connect(ui->recentDataSets, SIGNAL(dataSetSelected(QString)), this, SLOT(recentSelectedHandler(QString)));
	connect(ui->exampleDataSets, SIGNAL(dataSetSelected(QString)), this, SLOT(exampleSelectedHandler(QString)));

	setFileLoaded(false, NULL);

	QTimer::singleShot(200, this, SLOT(loadExamples())); // delay loading for quick start up

	this->installEventFilter(this);

#ifdef __WIN32__
	QFont f = ui->recentDataSetsHeading->font();
	QFont nf(f.family(), 11, f.weight(), f.italic());
	ui->recentDataSetsHeading->setFont(nf);
	ui->exampleDataSetsHeading->setFont(nf);
#endif

	ui->buttonNew->hide();
}
void QSysNoteHistory::setupUI()
{
    QHBoxLayout *hlay = new QHBoxLayout(this);
    m_edit = new QTextEdit(this);
    m_edit->setEnabled(true);
    hlay->setMargin(0);
    hlay->setSpacing(0);
    hlay->addWidget(m_edit);
    resize(400,500);
    QFile *f = new QFile("note.dat",this);
    if (!f->exists())
        return;
    if (!f->open(QIODevice::ReadOnly))
        return;
    QString txt;
    txt = QString::fromLocal8Bit(f->readAll());
    QFont font = m_edit->font();
    font.setBold(true);
    font.setKerning(true);
    font.setWeight( font.weight() + 2);
    m_edit->setFont(font);
    m_edit->setTextColor(Qt::red);
    m_edit->setText(txt);
    f->close();
}
Exemple #3
0
QFont stripStyleName(QFont &f, QFontDatabase &db)
{
    const QString &styleName = f.styleName();
    if (styleName.isEmpty()) {
        return f;
    } else {
        QFont g = (db.styleString(f) != styleName) ?
            db.font(f.family(), styleName, f.pointSize())
            : QFont(f.family(), f.pointSize(), f.weight());
        if (auto s = f.pixelSize() > 0) {
            g.setPixelSize(s);
        }
        g.setStyleHint(f.styleHint(), f.styleStrategy());
        g.setStyle(f.style());
        if (f.underline()) {
            g.setUnderline(true);
        }
        if (f.strikeOut()) {
            g.setStrikeOut(true);
        }
        if (f.fixedPitch()) {
            g.setFixedPitch(true);
        }
        return g;
    }
}
void KoOdtFrameReportTextBox::createStyle(KoGenStyles *coll)
{
    QFont font = textBox()->textStyle().font;

    KoGenStyle ps(KoGenStyle::ParagraphStyle, "paragraph");
    m_paragraphStyleName = coll->insert(ps, "P");

    // text style
    KoGenStyle ts(KoGenStyle::TextStyle, "text");
    ts.addProperty("fo:font-family", font.family());
    ts.addPropertyPt("fo:font-size", font.pointSizeF());
    ts.addProperty("fo:font-weight", font.weight() * 10);
    ts.addProperty("fo:color", textBox()->textStyle().foregroundColor.name());
    QString fs;
    switch (font.style()) {
        case QFont::StyleNormal: fs = "normal"; break;
        case QFont::StyleItalic: fs = "italic"; break;
        case QFont::StyleOblique: fs = "oblique"; break;
    }
    ts.addProperty("fo:font-style", fs);
    m_textStyleName = coll->insert(ts, "T");

    KoGenStyle gs(KoGenStyle::GraphicStyle, "graphic");
    QPen pen;
    pen.setColor(textBox()->lineStyle().lineColor);
    pen.setWidthF(textBox()->lineStyle().weight);
    pen.setStyle(textBox()->lineStyle().style);
    KoOdfGraphicStyles::saveOdfStrokeStyle(gs, coll, pen);
    gs.addProperty("style:horizontal-pos", "from-left");
    gs.addProperty("style:horizontal-rel", "page");
    gs.addProperty("style:vertical-pos", "from-top");
    gs.addProperty("style:vertical-rel", "page");
    gs.addProperty("fo:background-color", textBox()->textStyle().backgroundColor.name());
    m_frameStyleName = coll->insert(gs, "F");
}
void ViewSettingsTab::applySettings()
{
    const QFont font = m_fontRequester->currentFont();
    const bool useSystemFont = (m_fontRequester->mode() == DolphinFontRequester::SystemFont);

    switch (m_mode) {
    case IconsMode:
        IconsModeSettings::setTextWidthIndex(m_widthBox->currentIndex());
        IconsModeSettings::setMaximumTextLines(m_maxLinesBox->currentIndex());
        break;
    case CompactMode:
        CompactModeSettings::setMaximumTextWidthIndex(m_widthBox->currentIndex());
        break;
    case DetailsMode:
        DetailsModeSettings::setExpandableFolders(m_expandableFolders->isChecked());
        break;
    default:
        break;
    }

    ViewModeSettings settings(viewMode());

    const int iconSize = ZoomLevelInfo::iconSizeForZoomLevel(m_defaultSizeSlider->value());
    const int previewSize = ZoomLevelInfo::iconSizeForZoomLevel(m_previewSizeSlider->value());
    settings.setIconSize(iconSize);
    settings.setPreviewSize(previewSize);

    settings.setUseSystemFont(useSystemFont);
    settings.setFontFamily(font.family());
    settings.setFontSize(font.pointSizeF());
    settings.setItalicFont(font.italic());
    settings.setFontWeight(font.weight());

    settings.writeConfig();
}
Exemple #6
0
QString qssifyFont(QFont font)
{
    return QString("%1 %2px \"%3\"")
            .arg(font.weight()*8)
            .arg(font.pixelSize())
            .arg(font.family());
}
Exemple #7
0
void FolderViewDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option,
                               const QModelIndex &index) const
{
  QStyledItemDelegate::paint(painter,option,index);

  painter->save();

  QFont font    = QApplication::font();
  QFont subFont = QApplication::font();
  //font.setPixelSize(font.weight()+);
  font.setBold(true);
  subFont.setWeight(subFont.weight() - 4);
  QFontMetrics fm(font);

  QIcon icon = qvariant_cast<QIcon>(index.data(FolderIconRole));
  QIcon statusIcon = qvariant_cast<QIcon>(index.data(FolderStatusIcon));
  QString aliasText = qvariant_cast<QString>(index.data(FolderAliasRole));
  QString pathText = qvariant_cast<QString>(index.data(FolderPathRole));
  QString statusText = qvariant_cast<QString>(index.data(FolderStatus));
  bool syncEnabled = index.data(FolderSyncEnabled).toBool();
  QString syncStatus = syncEnabled? tr( "Enabled" ) : tr( "Disabled" );

  QSize iconsize(48,48); //  = icon.actualSize(option.decorationSize);

  QRect headerRect = option.rect;
  QRect iconRect = option.rect;

  iconRect.setRight(iconsize.width()+30);
  iconRect.setTop(iconRect.top()+5);
  headerRect.setLeft(iconRect.right());
  headerRect.setTop(headerRect.top()+5);
  headerRect.setBottom(headerRect.top()+fm.height());

  QRect subheaderRect = headerRect;
  subheaderRect.setTop(headerRect.bottom());
  QFontMetrics fmSub( subFont );
  subheaderRect.setBottom(subheaderRect.top()+fmSub.height());
  QRect statusRect = subheaderRect;
  statusRect.setTop( subheaderRect.bottom() + 5);
  statusRect.setBottom( statusRect.top() + fmSub.height());

  QRect lastSyncRect = statusRect;
  lastSyncRect.setTop( statusRect.bottom());
  lastSyncRect.setBottom( lastSyncRect.top() + fmSub.height());

  //painter->drawPixmap(QPoint(iconRect.right()/2,iconRect.top()/2),icon.pixmap(iconsize.width(),iconsize.height()));
  painter->drawPixmap(QPoint(iconRect.left()+15,iconRect.top()),icon.pixmap(iconsize.width(),iconsize.height()));

  painter->drawPixmap(QPoint(option.rect.right() - 4 - 48, option.rect.top() + 8 ), statusIcon.pixmap( 48,48));

  painter->setFont(font);
  painter->drawText(headerRect, aliasText);

  painter->setFont(subFont);
  painter->drawText(subheaderRect.left(),subheaderRect.top()+17, pathText);
  painter->drawText(lastSyncRect, tr("Last Sync: %1").arg( statusText ));
  painter->drawText(statusRect, tr("Sync Status: %1").arg( syncStatus ));
  painter->restore();

}
Exemple #8
0
int QFontProto::weight() const
{
  QFont *item = qscriptvalue_cast<QFont*>(thisObject());
  if (item)
    return item->weight();
  return 0;
}
void LocalHelpManager::setFallbackFont(const QFont &font)
{
    setOrRemoveSetting(kFontFamilyKey, font.family(), defaultFallbackFontFamily());
    setOrRemoveSetting(kFontStyleKey, font.style(), kDefaultFallbackFontStyle);
    setOrRemoveSetting(kFontWeightKey, font.weight(), kDefaultFallbackFontWeight);
    setOrRemoveSetting(kFontSizeKey, font.pointSize(), kDefaultFallbackFontSize);
    emit m_instance->fallbackFontChanged(font);
}
Exemple #10
0
QtNativeFont::QtNativeFont(QFont const &font)
    : NativeFont(font.family()), d(new Instance)
{
    d->font = font;
    setSize(font.pointSizeF());
    setWeight(font.weight());
    setStyle(font.italic()? Italic : Regular);
}
WFont transform(const QFont& font)
{
	WFont f(font.family().toStdString(), font.pointSize(), font.weight(), font.italic());
	f.setUnderline(font.underline());
	f.setStrikeOut(font.strikeOut());
	f.setKerning(font.kerning());
	return f;
}
Exemple #12
0
QString QPF::fileNameForFont(const QFont &f)
{
    QString fileName = f.family().toLower() + "_" + QString::number(f.pixelSize())
                       + "_" + QString::number(f.weight())
                       + (f.italic() ? "_italic" : "")
                       + ".qpf2";
    fileName.replace(QLatin1Char(' '), QLatin1Char('_'));
    return fileName;
}
Exemple #13
0
void EmfPaintEngine::drawTextItem ( const QPointF & p, const QTextItem & textItem )
{
	setClipping();

	SetBkMode( metaDC, TRANSPARENT );

	QFont f = textItem.font();
	QFontMetrics fm(f);
	HFONT wfont = CreateFontA(fm.height() - 1, fm.averageCharWidth(), 0, 0,
				10*f.weight(), f.italic(), f.underline (), f.strikeOut(),
				DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
				DEFAULT_QUALITY, DEFAULT_PITCH, f.family().toAscii().data());
	SelectObject( metaDC, wfont);

	QColor colour = painter()->pen().color();
	SetTextColor( metaDC, RGB(colour.red(), colour.green(), colour.blue()));

	QString text = textItem.text();
	int size = text.size();

	QMatrix m = painter()->worldMatrix();

	XFORM xf;
	xf.eM11 = m.m11();
	xf.eM12 = m.m12();
	xf.eM21 = m.m21();
	xf.eM22 = m.m22();
	xf.eDx = m.dx();
	xf.eDy = m.dy();
	SetWorldTransform(metaDC, &xf);

#ifdef Q_WS_WIN
	wchar_t *wtext = (wchar_t *)malloc(size*sizeof(wchar_t));
	if (!wtext){
		qWarning("EmfEngine: Not enough memory in drawTextItem().");
		return;
	}
	
	size = text.toWCharArray(wtext);
	TextOutW(metaDC, qRound(p.x()), qRound(p.y() - 0.85*fm.height()), wtext, size);
	free(wtext);
#else
	TextOutA(metaDC, qRound(p.x()), qRound(p.y() - 0.85*fm.height()), text.toLocal8Bit().data(), size);
#endif

	xf.eM11 = 1.0;
	xf.eM12 = 0.0;
	xf.eM21 = 0.0;
	xf.eM22 = 1.0;
	xf.eDx = 0.0;
	xf.eDy = 0.0;
	SetWorldTransform(metaDC, &xf);

	resetClipping();
	DeleteObject(wfont);
}
Exemple #14
0
void RcFile::saveFont (Parm name, QFont &font)
{
  QString f =font.family() + "," +
              QString::number(font.pointSize()) + "," +
              QString::number(font.weight()) + "," +
              QString::number(font.italic ()) + "," +
              QString::number(font.bold ());
		
  saveData(name, f);
}
void Mesh2MainWindow::pickTitleFont()
{
	bool ok;
	QFont font = QFontDialog::getFont(&ok, this );
	if ( !ok ) 
	{
		return;
	} 
	dataWidget->setTitleFont(font.family(), font.pointSize(), font.weight(), font.italic());
}
Exemple #16
0
QString Setting::fontToString(QFont f)
{
#ifdef Q_WS_X11_xxx
	return f.rawName();
#else
	return f.family() + "-" +
		QString::number(f.pointSize()) + "-" +
		QString::number(f.weight()) + "-" +
		QString::number(f.italic()) + "-" +
		QString::number(f.underline()) + "-" +
		QString::number(f.strikeOut());
#endif
}
void StyleSheetEditorDialog::slotAddFont()
{
    bool ok;
    QFont font = QFontDialog::getFont(&ok, this);
    if (ok) {
        QString fontStr;
        if (font.weight() != QFont::Normal) {
            fontStr += QString::number(font.weight());
            fontStr += QLatin1Char(' ');
        }

        switch (font.style()) {
        case QFont::StyleItalic:
            fontStr += QLatin1String("italic ");
            break;
        case QFont::StyleOblique:
            fontStr += QLatin1String("oblique ");
            break;
        default:
            break;
        }
        fontStr += QString::number(font.pointSize());
        fontStr += QLatin1String("pt \"");
        fontStr += font.family();
        fontStr += QLatin1Char('"');

        insertCssProperty(QLatin1String("font"), fontStr);
        QString decoration;
        if (font.underline())
            decoration += QLatin1String("underline");
        if (font.strikeOut()) {
            if (!decoration.isEmpty())
                decoration += QLatin1Char(' ');
            decoration += QLatin1String("line-through");
        }
        insertCssProperty(QLatin1String("text-decoration"), decoration);
    }
}
Exemple #18
0
/**
 * Set the parameters with the current font
 */
void ConfigDialog::refreshSyntaxFont(int index) {
  if (index == -1 && index >= Config::shGroupList.size()) {
    return;
  }
	
  QListWidgetItem *item = shListWidget->item(index);
  QFont font = item->font();

  QColor color = item->foreground().color();
  shColorButton->setColor(color);

  shBoldButton->setChecked(font.weight() == QFont::Bold);
  shItalicButton->setChecked(font.italic());
}
Exemple #19
0
void createFontNode( QDomDocument& doc, QDomNode& parent,
                     const QString& elementName, const QFont& font )
{
    QDomElement fontElement = doc.createElement( elementName );
    parent.appendChild( fontElement );
    createStringNode( doc, fontElement, "Family", font.family() );
    createIntNode( doc, fontElement, "PointSize", font.pointSize() );
    createIntNode( doc, fontElement, "PixelSize", font.pixelSize() );
    createIntNode( doc, fontElement, "Weight", font.weight() );
    createBoolNode( doc, fontElement, "Italic", font.italic() );
#if QT_VERSION < 300
    // Qt 3 handles the charset internally.
    createIntNode( doc, fontElement, "CharSet", font.charSet() );
#endif
}
nsresult
nsSystemFontsQt::GetSystemFontInfo(const char *aClassName, nsString *aFontName,
                                   gfxFontStyle *aFontStyle) const
{
    QFont qFont = QApplication::font(aClassName);

    aFontStyle->style = FONT_STYLE_NORMAL;
    aFontStyle->systemFont = PR_TRUE;
    NS_NAMED_LITERAL_STRING(quote, "\"");
    nsString family((PRUnichar*)qFont.family().data());
    *aFontName = quote + family + quote;
    aFontStyle->weight = qFont.weight();
    aFontStyle->size = qFont.pointSizeF() * float(gfxQtPlatform::DPI()) / 72.0f;
    return NS_OK;
}
void XmlFontSerializator::save(const QVariant &value, QString name)
{
    QFont font = value.value<QFont>();
    QDomElement _node = doc()->createElement(name);
    _node.setAttribute("Type","QFont");
    _node.setAttribute("family",font.family());
    _node.setAttribute("pointSize",font.pointSize());
#if QT_VERSION>0x040800
    _node.setAttribute("stylename",font.styleName());
#endif
    _node.setAttribute("weight",font.weight());
    //saveBool(_node,"bold",font.bold());
    saveBool(_node,"italic",font.italic());
    saveBool(_node,"underline",font.underline());
    node()->appendChild(_node);
}
void tst_QFont::resolve()
{
    QFont font;
    font.setPointSize(font.pointSize() * 2);
    font.setItalic(false);
    font.setWeight(QFont::Normal);
    font.setUnderline(false);
    font.setStrikeOut(false);
    font.setOverline(false);
    font.setStretch(QFont::Unstretched);

    QFont font1;
    font1.setWeight(QFont::Bold);
    QFont font2 = font1.resolve(font);

    QVERIFY(font2.weight() == font1.weight());

    QVERIFY(font2.pointSize() == font.pointSize());
    QVERIFY(font2.italic() == font.italic());
    QVERIFY(font2.underline() == font.underline());
    QVERIFY(font2.overline() == font.overline());
    QVERIFY(font2.strikeOut() == font.strikeOut());
    QVERIFY(font2.stretch() == font.stretch());

    QFont font3;
    font3.setStretch(QFont::UltraCondensed);
    QFont font4 = font3.resolve(font1).resolve(font);

    QVERIFY(font4.stretch() == font3.stretch());

    QVERIFY(font4.weight() == font.weight());
    QVERIFY(font4.pointSize() == font.pointSize());
    QVERIFY(font4.italic() == font.italic());
    QVERIFY(font4.underline() == font.underline());
    QVERIFY(font4.overline() == font.overline());
    QVERIFY(font4.strikeOut() == font.strikeOut());


    QFont f1,f2,f3;
    f2.setPointSize(45);
    f3.setPointSize(55);

    QFont f4 = f1.resolve(f2);
    QCOMPARE(f4.pointSize(), 45);
    f4 = f4.resolve(f3);
    QCOMPARE(f4.pointSize(), 55);
}
QString FontEdit::font2str(const QFont &f, bool use_tr)
{
    QString fontName = f.family();
    fontName += ", ";
    if (f.pointSize() > 0){
        fontName += QString::number(f.pointSize());
        fontName += " pt.";
    }else{
        fontName += QString::number(f.pixelSize());
        fontName += " pix.";
    }
    switch (f.weight()){
    case QFont::Light:
        fontName += ", ";
        fontName += s_tr(I18N_NOOP("light"), use_tr);
        break;
    case QFont::DemiBold:
        fontName += ", ";
        fontName += s_tr(I18N_NOOP("demibold"), use_tr);
        break;
    case QFont::Bold:
        fontName += ", ";
        fontName += s_tr(I18N_NOOP("bold"), use_tr);
        break;
    case QFont::Black:
        fontName += ", ";
        fontName += s_tr(I18N_NOOP("black"), use_tr);
        break;
    default:
        break;
    }
    if (f.italic()){
        fontName += ", ";
        fontName += s_tr(I18N_NOOP("italic"), use_tr);
    }
    if (f.strikeOut()){
        fontName += ", ";
        fontName += s_tr(I18N_NOOP("strikeout"), use_tr);
    }
    if (f.underline()){
        fontName += ", ";
        fontName += s_tr(I18N_NOOP("underline"), use_tr);
    }
    return fontName;
}
Exemple #24
0
QString QTextFormat::getKey( const QFont &fn, const QColor &col, bool misspelled,
                             const QString &lhref, const QString &lnm, VerticalAlignment a )
{
    QString k;
    QTextOStream ts( &k );
    ts << fn.pointSize() << "/"
    << fn.weight() << "/"
    << (int)fn.underline() << "/"
    << (int)fn.strikeOut() << "/"
    << (int)fn.italic() << "/"
    << (uint)col.rgb() << "/"
    << fn.family() << "/"
    << (int)misspelled << "/"
    << lhref << "/"
    << lnm << "/"
    << (int)a;
    return k;
}
Exemple #25
0
void
Button::loadPixmap( const QString& path )
{
	m_pixmapPath = path;

	QPixmap m_pixmap;
	
	if( !m_pixmap.load( path ) )
	{
		kdWarning() << k_funcinfo << "Could not convert image to pixmap" << endl;
		return;
	}
	
	setMinimumSize( m_pixmap.size() );
	
	// Paint the text on the button

	kdDebug() << "Pixmap : " << m_pixmap.size() << endl;
	QPainter p( &m_pixmap );
	// First make the pen white and thick
	QPen pen = p.pen();
	kdDebug() << "Painter's pen width: " << p.pen().width() << endl;
	kdDebug() << "New width: " << pen.width() << endl;
	p.setPen( QPen( white, 4 ) );
	kdDebug() << "Painter's pen width: " << p.pen().width() << endl;
	// Then make the font bold and italic
	QFont f = p.font();
	kdDebug() << "Default weight: " << p.font().weight() << endl;
	f.setWeight( 99 );
	kdDebug() << "New weight: " << f.weight() << endl;
	f.setBold( true );
	f.setItalic( true );
	p.setFont( f );
	kdDebug() << "Default weight: " << p.font().weight() << endl;
	// Finally draw the text
	int offset = (geometry().height() - p.fontMetrics().height()) / 2 + p.fontMetrics().height() - 2;
	p.drawText( 30, offset, i18n( "XK-Menu" ) );
	kdDebug() << "ABOUT TO setPixmap" << endl;

	setPixmap( m_pixmap );
	kdDebug() << "ABOUT TO setMask" << endl;
	setMask( *m_pixmap.mask() );
}
Exemple #26
0
QDomElement Calligra::Sheets::NativeFormat::createElement(const QString & tagName, const QFont & font, QDomDocument & doc)
{
    QDomElement e(doc.createElement(tagName));

    e.setAttribute("family", font.family());
    e.setAttribute("size", font.pointSize());
    e.setAttribute("weight", font.weight());
    if (font.bold())
        e.setAttribute("bold", "yes");
    if (font.italic())
        e.setAttribute("italic", "yes");
    if (font.underline())
        e.setAttribute("underline", "yes");
    if (font.strikeOut())
        e.setAttribute("strikeout", "yes");
    //e.setAttribute( "charset", KGlobal::charsets()->name( font ) );

    return e;
}
void DFont :: FromODataLayout (ODataLayout *pODataLayout )
{
  QFont    *qfont  = NULL;
  QColor   *qcolor = NULL;
BEGINSEQ
  if ( !pODataLayout )                               LEAVESEQ
    
  if ( qfont = pODataLayout->get_font() )
  {  
    strcpy(family_name,QS2SZ(qfont->family()));
    weight         = (ADK_FontWeight)qfont->weight();
    italic         = qfont->italic();
    underline      = qfont->underline();
    strike_out     = qfont->strikeOut();
    fixed_pitch    = qfont->fixedPitch();
    style_hint     = (ADK_FontStyle)qfont->styleHint();
    style_strategy = (ADK_FontStyleStrategy)qfont->styleStrategy();
    stretch        = qfont->stretch();
  }
  
  prefer_quality = NO;
  if ( style_strategy && QFont::PreferQuality )
  {
    prefer_quality = YES;
    style_strategy = (ADK_FontStyleStrategy)(style_strategy - QFont::PreferQuality);
  }
  
  if ( qcolor = pODataLayout->get_text_color() )
    text_color = QCOLOR2DCOLOR(*qcolor); 
  if ( qcolor = pODataLayout->get_bg_color() )
    bg_color = QCOLOR2DCOLOR(*qcolor);

  use_pixel = NO;
  if ( (size = qfont->pointSize()) == -1 )  // pixel size used
  {
    use_pixel = YES;
    size = qfont->pixelSize();
  }

ENDSEQ

}
void ColumnViewSettingsPage::applySettings()
{
    ColumnModeSettings* settings = DolphinSettings::instance().columnModeSettings();

    const int iconSize = ZoomLevelInfo::iconSizeForZoomLevel(m_iconSizeGroupBox->defaultSizeValue());
    const int previewSize = ZoomLevelInfo::iconSizeForZoomLevel(m_iconSizeGroupBox->previewSizeValue());
    settings->setIconSize(iconSize);
    settings->setPreviewSize(previewSize);

    const QFont font = m_fontRequester->font();
    settings->setUseSystemFont(m_fontRequester->mode() == DolphinFontRequester::SystemFont);
    settings->setFontFamily(font.family());
    settings->setFontSize(font.pointSizeF());
    settings->setItalicFont(font.italic());
    settings->setFontWeight(font.weight());

    const int columnWidth = BaseTextWidth + (m_textWidthBox->currentIndex() * TextInc);
    settings->setColumnWidth(columnWidth);

    settings->writeConfig();
}
QString LegendWidget::saveToString()
{
	QString s = "<Legend>\n";
	s += FrameWidget::saveToString();
	s += "<Text>\n" + d_text->text() + "\n</Text>\n";

	QFont f = d_text->font();
	s += "<Font>" + f.family() + "\t";
	s += QString::number(f.pointSize())+"\t";
	s += QString::number(f.weight())+"\t";
	s += QString::number(f.italic())+"\t";
	s += QString::number(f.underline())+"\t";
	s += QString::number(f.strikeOut())+"</Font>\n";

	s += "<TextColor>" + d_text->color().name()+"</TextColor>\n";
	QColor bc = backgroundColor();
	s += "<Background>" + bc.name() + "</Background>\n";
	s += "<Alpha>" + QString::number(bc.alpha()) + "</Alpha>\n";
	s += "<Angle>" + QString::number(d_angle) + "</Angle>\n";
	s += "<AutoUpdate>" + QString::number(d_auto_update) + "</AutoUpdate>\n";
	return s + "</Legend>\n";
}
static void
GetSystemFontInfo(const char *aClassName, nsString *aFontName,
                  gfxFontStyle *aFontStyle)
{
  QFont qFont = QApplication::font(aClassName);

  NS_NAMED_LITERAL_STRING(quote, "\"");
  nsString family((PRUnichar*)qFont.family().data());
  *aFontName = quote + family + quote;

  aFontStyle->systemFont = true;
  aFontStyle->style = NS_FONT_STYLE_NORMAL;
  aFontStyle->weight = qFont.weight();
  // FIXME: Set aFontStyle->stretch correctly!
  aFontStyle->stretch = NS_FONT_STRETCH_NORMAL;
  // use pixel size directly if it is set, otherwise compute from point size
  if (qFont.pixelSize() != -1) {
    aFontStyle->size = qFont.pixelSize();
  } else {
    aFontStyle->size = qFont.pointSizeF() * 96.0f / 72.0f;
  }
}