void LoadFonts() {
    QFontDatabase database;
    QStringList fontlist = database.families();

    QStringList preferList;
    preferList.append("Microsoft YaHei UI");
    preferList.append("微软雅黑");
    preferList.append("SimHei");
    preferList.append("黑体");

    foreach (QString font, preferList) {
        if (fontlist.contains(font)) {
            g_CurrentFont = QFont(font, 11);
            QApplication::setFont(g_CurrentFont);
            qDebug()<<"Load font: "<<font
                    <<"Current"<<g_CurrentFont.family();
            return;
        }
    }
}
Ejemplo n.º 2
0
QFont FontPanel::selectedFont() const
{
    QFont rc = m_familyComboBox->currentFont();
    const QString family = rc.family();
    rc.setPointSize(pointSize());
    const QString styleDescription = styleString();
    if (styleDescription.contains(QLatin1String("Italic")))
        rc.setStyle(QFont::StyleItalic);
    else if (styleDescription.contains(QLatin1String("Oblique")))
        rc.setStyle(QFont::StyleOblique);
    else
        rc.setStyle(QFont::StyleNormal);
    rc.setBold(m_fontDatabase.bold(family, styleDescription));

    // Weight < 0 asserts...
    const int weight = m_fontDatabase.weight(family, styleDescription);
    if (weight >= 0)
        rc.setWeight(weight);
    return rc;
}
Ejemplo n.º 3
0
Archivo: style.cpp Proyecto: apprb/qTox
QString Style::resolve(QString qss, const QFont& baseFont)
{
    if (dict.isEmpty())
    {
        dict = {
            // colors
            {"@green", Style::getColor(Style::Green).name()},
            {"@yellow", Style::getColor(Style::Yellow).name()},
            {"@red", Style::getColor(Style::Red).name()},
            {"@black", Style::getColor(Style::Black).name()},
            {"@darkGrey", Style::getColor(Style::DarkGrey).name()},
            {"@mediumGrey", Style::getColor(Style::MediumGrey).name()},
            {"@mediumGreyLight", Style::getColor(Style::MediumGreyLight).name()},
            {"@lightGrey", Style::getColor(Style::LightGrey).name()},
            {"@white", Style::getColor(Style::White).name()},
            {"@orange", Style::getColor(Style::Orange).name()},
            {"@themeDark", Style::getColor(Style::ThemeDark).name()},
            {"@themeMediumDark", Style::getColor(Style::ThemeMediumDark).name()},
            {"@themeMedium", Style::getColor(Style::ThemeMedium).name()},
            {"@themeLight", Style::getColor(Style::ThemeLight).name()},

            // fonts
            {"@baseFont", QString::fromUtf8("'%1' %2px")
             .arg(baseFont.family()).arg(QFontInfo(baseFont).pixelSize())},
            {"@extraBig", qssifyFont(Style::getFont(Style::ExtraBig))},
            {"@big", qssifyFont(Style::getFont(Style::Big))},
            {"@bigBold", qssifyFont(Style::getFont(Style::BigBold))},
            {"@medium", qssifyFont(Style::getFont(Style::Medium))},
            {"@mediumBold", qssifyFont(Style::getFont(Style::MediumBold))},
            {"@small", qssifyFont(Style::getFont(Style::Small))},
            {"@smallLight", qssifyFont(Style::getFont(Style::SmallLight))}
        };
    }

    for (const QString& key : dict.keys())
    {
        qss.replace(QRegularExpression(QString("%1\\b").arg(key)), dict[key]);
    }

    return qss;
}
Ejemplo n.º 4
0
    RoboScintilla::RoboScintilla(QWidget *parent) : QsciScintilla(parent),
        _ignoreEnterKey(false),
        _ignoreTabKey(false),
        _lineNumberDigitWidth(0),
        _lineNumberMarginWidth(0)
    {
        setAutoIndent(true);
        setIndentationsUseTabs(false);
        setIndentationWidth(indentationWidth);
        setUtf8(true);
        setMarginWidth(1, 0);
        setCaretForegroundColor(caretForegroundColor);
        setMatchedBraceForegroundColor(matchedBraceForegroundColor); //1AB0A6
        setMatchedBraceBackgroundColor(marginsBackgroundColor);
        setContentsMargins(0, 0, 0, 0);
        setViewportMargins(3, 3, 3, 3);
        QFont ourFont = GuiRegistry::instance().font();
        setMarginsFont(ourFont);
        setMarginLineNumbers(0, true);
        setMarginsBackgroundColor(QColor(53, 56, 58));
        setMarginsForegroundColor(QColor(173, 176, 178));

        SendScintilla(QsciScintilla::SCI_STYLESETFONT, 1, ourFont.family().data());
        SendScintilla(QsciScintilla::SCI_SETHSCROLLBAR, 0);

        setWrapMode((QsciScintilla::WrapMode)QsciScintilla::SC_WRAP_NONE);
        setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); 
        setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded); 

        // Cache width of one digit
#ifdef Q_OS_WIN
        _lineNumberDigitWidth = rowNumberWidth;
#else
        _lineNumberDigitWidth = textWidth(STYLE_LINENUMBER, "0");
#endif
        updateLineNumbersMarginWidth();

        setLineNumbers(AppRegistry::instance().settingsManager()->lineNumbers());
        setUtf8(true);
        VERIFY(connect(this, SIGNAL(linesChanged()), this, SLOT(updateLineNumbersMarginWidth())));
    }
Ejemplo n.º 5
0
void FontButton::setFont(const QFont& font)
{
    m_font = font;
    QString style;
    if (!font.styleName().isEmpty()) {
        style = font.styleName();
    }
    else {
        QStringList styles;
        if (font.bold())
            styles << "Bold";
        if (font.italic())
            styles << "Italic";
        style = styles.join(" ");
    }
    m_ui->fontPreviewLabel->setText(QString("%1 %2").arg(m_font.family(), style));
    m_ui->fontPreviewLabel->setFont(m_font);
    if (font.family() != m_font.family()) {
        emit fontChanged(m_font);
    }
}
Ejemplo n.º 6
0
void MainWindow::fontChanged()
{
    QFont f = preview->font();
    f.setStyleStrategy(QFont::NoFontMerging);
    f.setPixelSize(pixelSize->value());
    f.setFamily(fontComboBox->currentFont().family());
    f.setItalic(italic->isChecked());
    f.setWeight(weightCombo->itemData(weightCombo->currentIndex()).toInt());

    if (!preview->isModified()) {
        QFontDatabase db;
        QFontDatabase::WritingSystem ws = db.writingSystems(f.family()).value(0, QFontDatabase::Any);
        QString sample = db.writingSystemSample(ws);
        preview->setText(sample);
        preview->setModified(false);
    }

    fileName->setText(QPF::fileNameForFont(f));

    preview->setFont(f);
}
Ejemplo n.º 7
0
void MainWindow::fontDialog() {
  if (tabWidget->count()) {
  	QsciLexer * lexer = getCurDoc()->lexer();
  	bool ok;

  	if (lexer) {
  	  QFont baseFont = QFontDialog::getFont(&ok, lexer->font(lexer->defaultStyle()));

  	  if (ok) {
  	    getCurDoc()->setFont(baseFont);
  	    setLexerFont(lexer, baseFont.family(), baseFont.pointSize());
  	  }
  	} else {
      QFont font = QFontDialog::getFont(&ok, getCurDoc()->font());

      if (ok) {
        getCurDoc()->setFont(font);
      }
  	}
  }
}
Ejemplo n.º 8
0
/**
 * <p>Load an assortment of saved application settings.  Typically called
 * early in the QMainWindow constructor.</p>
 * <ul>
 * <li>Replaces the default application font with the one saved in the
 * application settings (if present).  Doesn't do this on Mac OS X,
 * because it doesn't seem to stick well (keeps getting replaced by the
 * default font again upon certain actions, like the window regaining
 * focus).  The font settings are stored in the "Font" group, in the "Name"
 * and "Size" entries.</li>
 * <li>Loads the list of most recently opened files.  These are stored as
 * "Recent0", "Recent1", etc. in the "Files" group of the application
 * settings.</li>
 * <li>Loads the last directory where the application either opened or saved
 * a document file.  Replaces it with a reasonable default if the directory no
 * longer exists.  Stored in the "Files" group under "LastDir" in the
 * application settings.</li>
 * </ul>
 * @param settings The QSettings object from which to load the settings.
 */
void QQMenuHelper::loadSettings(QSettings *settings)
{
#if !defined(Q_WS_MAC)
    // Load font settings
    QFont currentFont = qApp->font();
    QString family = currentFont.family().toLower();
    int size = currentFont.pointSize();
    family = settings->value("Font/Name", family).toString();
    size = settings->value("Font/Size", size).toInt();
    QFont font(family, size);
    qApp->setFont(font);
    mainWindow->setFont(font);
#endif
    for (int i = 0; i < MAX_RECENT_FILES; i++) {
        QString key = QString("Files/Recent%1").arg(i);
        QString path = settings->value(key, "").toString();
        if (!path.isEmpty() && !QFileInfo(path).isDir()) {
            recentFiles.append(path);
        }
    }
}
Ejemplo n.º 9
0
static QString describeFont(const QFont &f)
{
    QString res = "'" + f.family() + "' ";

    if(f.pointSize() > 0)
        res += QString::number(f.pointSize()) + "pt";
    else
        res += QString::number(f.pixelSize()) + "px";

    if(f.bold())
        res += " bold";
    if(f.italic())
        res += " italic";
    if(f.underline())
        res += " underline";
    if(f.overline())
        res += " overline";
    if(f.strikeOut())
        res += " strikeout";
    return res;
}
Ejemplo n.º 10
0
void PreferencesDialog::on_selectMixerFontBtn_clicked()
{
	Preferences *preferencesMng = Preferences::get_instance();

	QString family = preferencesMng->getMixerFontFamily();
	int pointSize = preferencesMng->getMixerFontPointSize();

	bool ok;
	QFont font = QFontDialog::getFont( &ok, QFont( family, pointSize ), this );
	if ( ok ) {
		// font is set to the font the user selected
		family = font.family();
		pointSize = font.pointSize();
		QString familyStr = family;
		preferencesMng->setMixerFontFamily(familyStr);
		preferencesMng->setMixerFontPointSize(pointSize);
	}
	QFont newFont(family, pointSize);
	mixerFontLbl->setFont(newFont);
	mixerFontLbl->setText(family + QString("  %1").arg(pointSize));
}
void BiLiTextSourcePropertyDlg::mSltFontComboxChanged(const QString &text) {

	QFont font = qobject_cast<QFontComboBox *>(sender())->currentFont();

	obs_data_t *fontObj = obs_data_create();

	obs_data_set_string(fontObj, "face", (font.family()).toUtf8().data());
	obs_data_set_string(fontObj, "style", (font.styleName()).toUtf8().data());
	obs_data_set_int(fontObj, "size", font.pointSize());

	int flags  = font.bold() ? OBS_FONT_BOLD : 0;
	flags |= font.italic() ? OBS_FONT_ITALIC : 0;
	flags |= font.underline() ? OBS_FONT_UNDERLINE : 0;
	flags |= font.strikeOut() ? OBS_FONT_STRIKEOUT : 0;
	obs_data_set_int(fontObj, "flags", flags);

	obs_data_t *settingFont = obs_source_get_settings(mSrc);
	obs_data_set_obj(settingFont, "font", fontObj);
	obs_data_release(fontObj);
	obs_data_release(settingFont);
}
Ejemplo n.º 12
0
void DialogDisplaySettings::updateFontString(int line)
{
    QFont font = fonts[line];

    QString fontName;
    fontName.append(font.family());
    fontName.append(" ");
    fontName.append(QString::number(font.pointSize()));
    if(font.bold()){
        fontName.append(", fett");
    }
    if(font.italic()){
        fontName.append(tr(", kursiv"));
    }

    lineEdit_fonts[line]->setText(fontName);
    triggerRender();

//    qDebug()<<font.toString();
//    qDebug()<<font.key();
}
Ejemplo n.º 13
0
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();
}
Ejemplo n.º 14
0
static void print(QPrinter *printer)
{
    QPainter painter(printer);
    const QRectF pageF = printer->pageRect();

    QFont font = painter.font();
    font.setFamily("Courier");
    font.setPointSize(10);

    // Format message.
    const int charHeight = QFontMetrics(font).boundingRect('X').height();
    QString msg;
    QTextStream str(&msg);
    str << "Qt "<< QT_VERSION_STR;
#if QT_VERSION >= 0x050000
    str << ' ' << QGuiApplication::platformName();
#endif
    str << ' ' << QDateTime::currentDateTime().toString()
        << "\nFont: " << font.family() << ' ' << font.pointSize() << '\n'
        << *printer;

    if (!painter.device()->logicalDpiY() || !painter.device()->logicalDpiX()) {
        qWarning() << Q_FUNC_INFO << "Bailing out due to invalid DPI: " << msg;
        return;
    }

    painter.drawRect(pageF);

    drawHorizCmRuler(painter, pageF.x(), pageF.right(), pageF.height() /2);
    drawVertCmRuler(painter, pageF.x() + pageF.width() / 2, pageF.top(), pageF.bottom());

    painter.setFont(font);
    QPointF textPoint = pageF.topLeft() + QPoint(10, charHeight + 10);
    foreach (const QString &line, msg.split('\n')) {
        painter.drawText(textPoint, line);
        textPoint.ry() += (15 * charHeight) / 10;
    }

    painter.end();
}
Ejemplo n.º 15
0
TextStyle TextProp::textStyle() const
      {
      if (curUnit == 0)
            ts.setOffsetType(OffsetType::ABS);
      else if (curUnit == 1)
            ts.setOffsetType(OffsetType::SPATIUM);
      ts.setBold(fontBold->isChecked());
      ts.setItalic(fontItalic->isChecked());
      ts.setUnderline(fontUnderline->isChecked());
      ts.setSize(fontSize->value());
      QFont f = fontSelect->currentFont();
      ts.setFamily(f.family());
      ts.setXoff(xOffset->value() / ((ts.offsetType() == OffsetType::ABS) ? INCH : 1.0));
      ts.setYoff(yOffset->value() / ((ts.offsetType() == OffsetType::ABS) ? INCH : 1.0));
      ts.setFrameColor(frameColor->color());
      ts.setForegroundColor(color->color());
      ts.setBackgroundColor(bgColor->color());
      ts.setFrameWidth(Spatium(frameWidth->value()));
      ts.setPaddingWidth(Spatium(paddingWidth->value()));
      ts.setCircle(circleButton->isChecked());
      ts.setFrameRound(frameRound->value());
      ts.setHasFrame(frame->isChecked());
      ts.setSystemFlag(systemFlag->isChecked());
      ts.setSizeIsSpatiumDependent(sizeIsSpatiumDependent->isChecked());

      Align a = 0;
      if (alignHCenter->isChecked())
            a |= AlignmentFlags::HCENTER;
      else if (alignRight->isChecked())
            a |= AlignmentFlags::RIGHT;

      if (alignVCenter->isChecked())
            a |= AlignmentFlags::VCENTER;
      else if (alignBottom->isChecked())
            a |= AlignmentFlags::BOTTOM;
      else if (alignBaseline->isChecked())
            a |= AlignmentFlags::BASELINE;
      ts.setAlign(a);
      return ts;
      }
Ejemplo n.º 16
0
void userfont::saveFont( QFont Font )
{
	int k = Font.pointSize() ;
	QString s = QString( "%1\n%2\n" ).arg( Font.family() ).arg( QString::number( k ) ) ;

	if( Font.style() == QFont::StyleNormal ){
		s = s + QString( "normal\n" ) ;
	}else if( Font.style() == QFont::StyleItalic ){
		s = s + QString( "italic\n" ) ;
	}else{
		s = s + QString( "oblique\n" ) ;
	}
	if( Font.weight() == QFont::Normal ){
		s = s + QString( "normal\n" ) ;
	}else{
		s = s + QString( "bold" ) ;
	}
	QFile f( QDir::homePath() + QString( "/.zuluCrypt/font" ) ) ;
	f.open( QIODevice::WriteOnly | QIODevice::Truncate ) ;
	f.write( s.toAscii() ) ;
	f.close();
}
Ejemplo n.º 17
0
void QQGeneralSettings::fontChanged(const QFont &font)
{
	QFontDatabase fDB;

	QList<int> listSizes = fDB.pointSizes(font.family());

	int fontSize = m_defaultFont.pointSize();
	if(! listSizes.contains(fontSize))
		fontSize = font.pointSize();
	QString fontSizeStr = QString::number(fontSize);

	ui->fontSizeComboB->clear();
	for(int i = 0; i < listSizes.size(); i++)
		ui->fontSizeComboB->addItem(QString::number(listSizes.at(i)));

	int index = ui->fontSizeComboB->findText(fontSizeStr);
	if(index >= 0)
		ui->fontSizeComboB->setCurrentIndex(index);

	m_defaultFont = font;
	m_defaultFont.setPointSize(fontSize);
}
Ejemplo n.º 18
0
	void toString(const QFont & font, QString & szBuffer)
	{
		QString szFamily(font.family());
		szBuffer.sprintf("%s,%d,%d,%d", szFamily.toUtf8().data(), font.pointSize(), font.styleHint(), font.weight());
		QString szOptions;
		if(font.bold())
			szOptions.append('b');
		if(font.italic())
			szOptions.append('i');
		if(font.underline())
			szOptions.append('u');
		if(font.strikeOut())
			szOptions.append('s');
		if(font.fixedPitch())
			szOptions.append('f');

		if(!szOptions.isEmpty())
		{
			szBuffer.append(',');
			szBuffer.append(szOptions);
		}
	}
Ejemplo n.º 19
0
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;
  }
}
Ejemplo n.º 20
0
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";
}
Ejemplo n.º 21
0
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);
    }
}
Ejemplo n.º 22
0
void PreferenceDialog::chooseFont()
{
    bool ok;
    QFont font;
    QLabel *label = NULL;

    if (sender() == ui->chooseViewerFont) {
        font = ui->viewerSample->font();
    }
    else if (sender() == ui->chooseBoxFont) {
        font = ui->sampleEdit->font();
    }
    else if (sender() == ui->chooseViewFont) {
        font = m_model.font();
    }

    font = QFontDialog::getFont(&ok, font, this);

    if (sender() == ui->chooseViewerFont) {
        ui->viewerSample->setFont(font);
        label = ui->viewerFont;
    }
    else if (sender() == ui->chooseBoxFont) {
        ui->sampleEdit->setFont(font);
        label = ui->boxFont;
    }
    else if (sender() == ui->chooseViewFont) {
        QHeaderView *header = ui->sampleTable->verticalHeader();
        header->setDefaultSectionSize(QFontMetrics(font).height() * 1.5);
        ui->sampleTable->setMinimumHeight(header->sectionSize(0) * 5);
        ui->sampleTable->setMaximumHeight(ui->sampleTable->minimumHeight() + 2);
        m_model.setFont(font);
        m_model.update();
        label = ui->viewFont;
    }
    label->setText(tr("%1, %2pt").arg(font.family()).arg(font.pointSize()));

}
Ejemplo n.º 23
0
void ZLQtPaintContext::setFont(const std::string &family, int size, bool bold, bool italic) {
	if (myPainter->device() == 0) {
		myFontIsStored = true;
		myStoredFamily = family;
		myStoredSize = size;
		myStoredBold = bold;
		myStoredItalic= italic;
	} else {
		QFont font = myPainter->font();
		bool fontChanged = false;

		if (font.family() != family.c_str()) {
			font.setFamily(family.c_str());
			fontChanged = true;
		}

		if (font.pointSize() != size) {
			font.setPointSize(size);
			fontChanged = true;
		}

		if ((font.weight() != (bold ? QFont::Bold : QFont::Normal))) {
			font.setWeight(bold ? QFont::Bold : QFont::Normal);
			fontChanged = true;
		}

		if (font.italic() != italic) {
			font.setItalic(italic);
			fontChanged = true;
		}

		if (fontChanged) {
			myPainter->setFont(font);
			mySpaceWidth = -1;
			myDescent = myPainter->fontMetrics().descent();
		}
	}
}
Ejemplo n.º 24
0
CalamaresApplication::CalamaresApplication( int& argc, char *argv[] )
    : QApplication( argc, argv )
    , m_mainwindow( 0 )
{
    setOrganizationName( QLatin1String( CALAMARES_ORGANIZATION_NAME ) );
    setOrganizationDomain( QLatin1String( CALAMARES_ORGANIZATION_DOMAIN ) );
    setApplicationName( QLatin1String( CALAMARES_APPLICATION_NAME ) );
    setApplicationVersion( QLatin1String( CALAMARES_VERSION ) );

    CalamaresUtils::installTranslator( this );

    QFont f = font();

    cDebug() << "Default font ====="
             << "\nPixel size:   " << f.pixelSize()
             << "\nPoint size:   " << f.pointSize()
             << "\nPoint sizeF:  " << f.pointSizeF()
             << "\nFont family:  " << f.family()
             << "\nMetric height:" << QFontMetrics( f ).height();
    // The following line blocks for 15s on Qt 5.1.0
    cDebug() << "Font height:" << QFontMetrics( f ).height();
    CalamaresUtils::setDefaultFontSize( f.pointSize() );
}
Ejemplo n.º 25
0
void QJsonPaintEngine::updateFont(const QFont &font)
{
	Q_D(QJsonPaintEngine);
#ifdef QT_PICTURE_DEBUG
	qDebug() << " -> updateFont(): pt sz:" << font.pointSize();
#endif
	QStringList decorators;
	if (font.italic())     decorators << "itallic";
	if (font.strikeOut())   decorators << "strikeout";
	if (font.underline())   decorators << "underline";
	switch (font.weight())
	{
	case QFont::Light: decorators << "lighter"; break;
	case QFont::DemiBold: decorators << "bolder"; break;
	case QFont::Bold: decorators << "bold"; break;
	case QFont::Black: decorators << "bold"; break;
	case QFont::Normal: break;
	default: break;
	}

	QString units;
	float size;
	if (font.pixelSize() != -1)
	{
		units="px";
		size = font.pixelSize();
	} else {
		units="pt";
		size = font.pointSize();
	}

	d->s << QString("\t{\"f\": { \"d\": \"%1\", \"s\": %2, \"u\": \"%4\", \"f\": \"%3\"}},\r\n")
			.arg(decorators.join(" "))
			.arg(size)
			.arg(font.family())
			.arg(units);
}
Ejemplo n.º 26
0
/*virtual*/
bool
nsLookAndFeel::GetFontImpl(FontID aID, nsString& aFontName,
                           gfxFontStyle& aFontStyle,
                           float aDevPixPerCSSPixel)
{
  QFont qFont = QGuiApplication::font();

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

  aFontStyle.systemFont = true;
  aFontStyle.style = qFont.style();
  aFontStyle.weight = qFont.weight();
  aFontStyle.stretch = qFont.stretch();
  // 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() * qApp->primaryScreen()->logicalDotsPerInch() / 72.0f;
  }

  return true;
}
Ejemplo n.º 27
0
void QgsFontButton::dropEvent( QDropEvent *e )
{
  //is dropped data valid format data?
  QColor mimeColor;
  QgsTextFormat format;
  QFont font;
  bool hasAlpha = false;
  if ( mMode == ModeTextRenderer && formatFromMimeData( e->mimeData(), format ) )
  {
    setTextFormat( format );
    QgsFontUtils::addRecentFontFamily( mFormat.font().family() );
    return;
  }
  else if ( mMode == ModeQFont && fontFromMimeData( e->mimeData(), font ) )
  {
    QgsFontUtils::addRecentFontFamily( font.family() );
    setCurrentFont( font );
    return;
  }
  else if ( mMode == ModeTextRenderer && colorFromMimeData( e->mimeData(), mimeColor, hasAlpha ) )
  {
    //accept drop and set new color
    e->acceptProposedAction();

    if ( hasAlpha )
    {
      mFormat.setOpacity( mimeColor.alphaF() );
    }
    mimeColor.setAlphaF( 1.0 );
    mFormat.setColor( mimeColor );
    QgsRecentColorScheme::addRecentColor( mimeColor );
    updatePreview();
    emit changed();
  }
  updatePreview();
}
Ejemplo n.º 28
0
void BtFontChooserWidget::setFont(const QFont& font) {
    disconnect(m_fontListWidget, nullptr, nullptr, nullptr);
    disconnect(m_styleListWidget, nullptr, nullptr, nullptr);
    disconnect(m_sizeListWidget, nullptr, nullptr, nullptr);

    // set the font
    m_font = font;
    const QString fontFamily = font.family();
    restoreListWidgetValue(m_fontListWidget, fontFamily);

    // set the style
    loadStyles(fontFamily);
    QFontDatabase database;
    const QString styleString = database.styleString(m_font);
    m_choosenStyle = styleString;
    restoreListWidgetValue(m_styleListWidget, styleString);

    // set the size
    loadSizes(fontFamily, styleString);
    restoreListWidgetValue(m_sizeListWidget, QString::number(m_font.pointSize()) );

    outputHtmlText();
    connectListWidgets();
}
Ejemplo n.º 29
0
void DevGUI::fontChanged(const QFont &f)
{
    Font->setCurrentIndex(Font->findText(f.family()));
    Size->setCurrentIndex(Size->findText(QString::number(f.pointSize())));
}
void tst_QFont::exactMatch()
{
    QFont font;

    // Check if a non-existing font hasn't an exact match
    font = QFont( "BogusFont", 33 );
    QVERIFY( !font.exactMatch() );

#ifdef Q_OS_WIN
    QSKIP("Exact matching on windows misses a lot because of the sample chars");
#endif


    if (QGuiApplication::platformName() == QLatin1String("xcb")) {
        QVERIFY(QFont("sans").exactMatch());
        QVERIFY(QFont("sans-serif").exactMatch());
        QVERIFY(QFont("serif").exactMatch());
        QVERIFY(QFont("monospace").exactMatch());
    }

    QSKIP("This test is bogus on Unix with support for font aliases in fontconfig");

    QFontDatabase fdb;

    QList<QFontDatabase::WritingSystem> systems = fdb.writingSystems();
    for (int system = 0; system < systems.count(); ++system) {
        QStringList families = fdb.families(systems[system]);
        if (families.isEmpty())
            return;

        QStringList::ConstIterator f_it, f_end = families.end();
        for (f_it = families.begin(); f_it != f_end; ++f_it) {
            const QString &family = *f_it;
            if (family.contains('['))
                continue;

            QStringList styles = fdb.styles(family);
            QVERIFY(!styles.isEmpty());
            QStringList::ConstIterator s_it, s_end = styles.end();
            for (s_it = styles.begin(); s_it != s_end; ++s_it) {
                const QString &style = *s_it;

                if (fdb.isSmoothlyScalable(family, style)) {
                    // smoothly scalable font... don't need to load every pointsize
                    font = fdb.font(family, style, 12);
                    QFontInfo fontinfo(font);

                    if (! fontinfo.exactMatch()) {
                        // Unfortunately, this can fail, since
                        // QFontDatabase does not fill in all font
                        // properties.  Check to make sure that the
                        // test didn't fail for obvious reasons

                        if (fontinfo.family().isEmpty()
                                && fontinfo.pointSize() == 0) {
                            // this is a box rendering engine... this can happen from
                            // time to time, especially on X11 with iso10646-1 or
                            // unknown font encodings
                            continue;
                        }

#ifdef Q_OS_WIN
                        if (font.family().startsWith("MS ") || fontinfo.family().startsWith("MS ")) {
                            /* qDebug("Family matching skipped for MS-Alias font: %s, fontinfo: %s",
                               font.family().latin1(), fontinfo.family().latin1());
                               */
                        } else
#endif
                        {
                            if (!(font.family() == fontinfo.family()
                                        || fontinfo.family().contains(font.family())
                                        || fontinfo.family().isEmpty())) {
                                qDebug("Test about to fail for font: %s, fontinfo: %s",
                                        font.family().toLatin1().constData(),
                                        fontinfo.family().toLatin1().constData());
                            }
                            QVERIFY(font.family() == fontinfo.family()
                                    || fontinfo.family().contains(font.family())
                                    || fontinfo.family().isEmpty());
                        }
                        if (font.pointSize() != -1) {
                            QVERIFY(font.pointSize() == fontinfo.pointSize());
                        } else {
                            QVERIFY(font.pixelSize() == fontinfo.pixelSize());
                        }
                        QVERIFY(font.italic() == fontinfo.italic());
                        if (font.weight() != fontinfo.weight()) {
                            qDebug("font is %s", font.toString().toLatin1().constData());
                        }
                        QVERIFY(font.weight() == fontinfo.weight());
                    } else {
                        font.setFixedPitch(!fontinfo.fixedPitch());
                        QFontInfo fontinfo1(font);
                        QVERIFY( !fontinfo1.exactMatch() );

                        font.setFixedPitch(fontinfo.fixedPitch());
                        QFontInfo fontinfo2(font);
                        QVERIFY( fontinfo2.exactMatch() );
                    }
                }
#if 0
                // ############## can only work if we have float point sizes in QFD
                else {
                    QList<int> sizes = fdb.pointSizes(family, style);
                    QVERIFY(!sizes.isEmpty());
                    QList<int>::ConstIterator z_it, z_end = sizes.end();
                    for (z_it = sizes.begin(); z_it != z_end; ++z_it) {
                        const int size = *z_it;

                        // Initialize the font, and check if it is an exact match
                        font = fdb.font(family, style, size);
                        QFontInfo fontinfo(font, (QFont::Script) script);

                        if (! fontinfo.exactMatch()) {
                            // Unfortunately, this can fail, since
                            // QFontDatabase does not fill in all font
                            // properties.  Check to make sure that the
                            // test didn't fail for obvious reasons

                            if (fontinfo.family().isEmpty()
                                    && fontinfo.pointSize() == 0) {
                                // this is a box rendering engine... this can happen from
                                // time to time, especially on X11 with iso10646-1 or
                                // unknown font encodings
                                continue;
                            }

                            // no need to skip MS-fonts here it seems
                            if (!(font.family() == fontinfo.family()
                                        || fontinfo.family().contains(font.family())
                                        || fontinfo.family().isEmpty())) {
                                qDebug("Test about to fail for font: %s, fontinfo: %s",
                                        font.family().latin1(), fontinfo.family().latin1());
                            }
                            QVERIFY(font.family() == fontinfo.family()
                                    || fontinfo.family().contains(font.family())
                                    || fontinfo.family().isEmpty());
                            if (font.pointSize() != -1) {
                                QVERIFY(font.pointSize() == fontinfo.pointSize());
                            } else {
                                QVERIFY(font.pixelSize() == fontinfo.pixelSize());
                            }
                            QVERIFY(font.italic() == fontinfo.italic());
                            QVERIFY(font.weight() == fontinfo.weight());
                        } else {
                            font.setFixedPitch(!fontinfo.fixedPitch());
                            QFontInfo fontinfo1(font, (QFont::Script) script);
                            QVERIFY( !fontinfo1.exactMatch() );

                            font.setFixedPitch(fontinfo.fixedPitch());
                            QFontInfo fontinfo2(font, (QFont::Script) script);
                            QVERIFY( fontinfo2.exactMatch() );
                        }
                    }
                }
#endif
            }
        }
    }
}