示例#1
0
void HelpDialog::setText (QString text) {
  /* Try real hard to get a monospaced font. */
  QFont font ("monospace");

  if (!font_is_monospaced (font)) {
#if QT_VERSION >= 0x040700
    font.setStyleHint (QFont::Monospace);
#else
    font.setStyleHint (QFont::TypeWriter);
#endif
  }

  if (!font_is_monospaced (font)) {
    font.setFamily ("Courier New");
  }

  if (!font_is_monospaced (font)) {
    font.setFamily ("Courier");
  }

  /* If the font is not monospaced by now, there's not much else we can do... */
  font.setPointSize (10);

  plainTextEdit->setFont (font);

  plainTextEdit->setTabStopWidth (30);
  plainTextEdit->setWordWrapMode (QTextOption::NoWrap);
  plainTextEdit->setPlainText (text);
}
void ZoomableAssemblyOverview::drawCoordLabels(QPainter & p) {
    const static int xoffset = 4;
    const static int yoffset = 3;

    U2OpStatusImpl status;

    //Prepare text
    QString visibleStartText = QString::number(visibleRange.startPos);
    QString visibleEndText = QString::number(visibleRange.endPos());
    QString visibleDiffText = QString::number(visibleRange.length);
    insertSpaceSeparators(visibleStartText);
    insertSpaceSeparators(visibleEndText);
    insertSpaceSeparators(visibleDiffText);

    //Prepare font
    QFont font = p.font();
#if QT_VERSION >= QT_VERSION_CHECK(4, 7, 0)
        font.setStyleHint(QFont::SansSerif, (QFont::StyleStrategy)(QFont::PreferAntialias | QFont::ForceIntegerMetrics));
#else
        font.setStyleHint(QFont::SansSerif, QFont::PreferAntialias);
#endif
    p.setFont(font);
    QFontMetrics fontMetrics(font, this);

    p.setPen(labelForegroundColor);

    //draw Visible Region
    QString visibleRegionText = tr("%1 to %2 (%3 bp)").arg(visibleStartText).arg(visibleEndText).arg(visibleDiffText);
    QRect grtRect = QRect(0, 0, fontMetrics.width(visibleRegionText), fontMetrics.height());
    grtRect.translate(xoffset, rect().height() - yoffset - grtRect.height());
    if(rect().contains(grtRect)) {
        p.fillRect(grtRect, labelBackgroundColor);
        p.drawText(grtRect, visibleRegionText);
    }

    //draw Selected Region
    qint64 from = browser->getXOffsetInAssembly();
    qint64 to = qMin(browser->getXOffsetInAssembly() + browser->basesCanBeVisible(), model->getModelLength(status));

    //prepare text
    QString fromText = QString::number(from + 1); // because of 1-based coords
    QString toText = QString::number(to);
    QString diff = QString::number(to - from);

    insertSpaceSeparators(fromText);
    insertSpaceSeparators(toText);
    insertSpaceSeparators(diff);

    //draw text
    QString selectedRegionText = tr("%1 to %2 (%3 bp)").arg(fromText, toText, diff);
    QRect srtRect = QRect(0, 0, fontMetrics.width(selectedRegionText), fontMetrics.height());
    srtRect.translate(rect().width() - srtRect.width() - xoffset, rect().height() - yoffset - grtRect.height());
    if(rect().contains(srtRect) && !srtRect.intersects(grtRect)) {
        p.fillRect(srtRect, labelBackgroundColor);
        p.drawText(srtRect, selectedRegionText);
    }
}
static QFont
find_font(int face, int style, int size) {
    bool changed = false;

    if (last_face != face) { 
      if (face == FACE_MONOSPACE) {
        qfont.setStyleHint(QFont::TypeWriter);
        qfont.setFamily("fixed");
      } else {
        qfont.setStyleHint(QFont::Helvetica);
        qfont.setFamily("helvetica");
      }

      last_face = face;
      changed = true;
    }

    if (last_size != size) {
	int pointsize;

	switch (size) {
	default:
	case SIZE_SMALL:
	    pointsize = face == FACE_MONOSPACE ? 7: 11;
	    break;
	case SIZE_MEDIUM:
	    pointsize = 13;
	    break;
	case SIZE_LARGE:
	    pointsize = 17;
	    break;
	}

	qfont.setPointSize(pointsize);
	last_size = size;
	changed = true;
    }

    if (last_style != style) {
        qfont.setWeight((style & STYLE_BOLD) ? QFont::Bold : QFont::Normal);
	qfont.setItalic(style & STYLE_ITALIC);
	qfont.setUnderline(style & STYLE_UNDERLINED);
	last_style = style;
	changed = true;
    }

    if (changed) {
	if (qfontInfo) {
	    delete qfontInfo;
	    qfontInfo = NULL;
	}
	qfontInfo = new QFontMetrics(qfont);
    }

    return qfont;
}
示例#4
0
int Font::s_styleHint(lua_State * L)
{
    QFont* obj = ValueInstaller2<QFont>::check( L, 1);
    if( lua_gettop(L) > 2 )
        obj->setStyleHint( (QFont::StyleHint)Util::toInt( L, 2 ),
                           (QFont::StyleStrategy)Util::toInt( L, 3 ) );
    else
        obj->setStyleHint( (QFont::StyleHint)Util::toInt( L, 2 ) );
    return 0;
}
示例#5
0
/*!
    \internal
*/
QWebSettings::QWebSettings()
    : d(new QWebSettingsPrivate)
{
    // Initialize our global defaults
    d->fontSizes.insert(QWebSettings::MinimumFontSize, 0);
    d->fontSizes.insert(QWebSettings::MinimumLogicalFontSize, 0);
    d->fontSizes.insert(QWebSettings::DefaultFontSize, 16);
    d->fontSizes.insert(QWebSettings::DefaultFixedFontSize, 13);

    QFont defaultFont;
    defaultFont.setStyleHint(QFont::Serif);
    d->fontFamilies.insert(QWebSettings::StandardFont, defaultFont.defaultFamily());
    d->fontFamilies.insert(QWebSettings::SerifFont, defaultFont.defaultFamily());

    defaultFont.setStyleHint(QFont::Fantasy);
    d->fontFamilies.insert(QWebSettings::FantasyFont, defaultFont.defaultFamily());

    defaultFont.setStyleHint(QFont::Cursive);
    d->fontFamilies.insert(QWebSettings::CursiveFont, defaultFont.defaultFamily());

    defaultFont.setStyleHint(QFont::SansSerif);
    d->fontFamilies.insert(QWebSettings::SansSerifFont, defaultFont.defaultFamily());

    defaultFont.setStyleHint(QFont::Monospace);
    d->fontFamilies.insert(QWebSettings::FixedFont, defaultFont.defaultFamily());

    d->attributes.insert(QWebSettings::AutoLoadImages, true);
    d->attributes.insert(QWebSettings::DnsPrefetchEnabled, false);
    d->attributes.insert(QWebSettings::JavascriptEnabled, true);
    d->attributes.insert(QWebSettings::SpatialNavigationEnabled, false);
    d->attributes.insert(QWebSettings::LinksIncludedInFocusChain, true);
    d->attributes.insert(QWebSettings::ZoomTextOnly, false);
    d->attributes.insert(QWebSettings::PrintElementBackgrounds, true);
    d->attributes.insert(QWebSettings::OfflineStorageDatabaseEnabled, false);
    d->attributes.insert(QWebSettings::OfflineWebApplicationCacheEnabled, false);
    d->attributes.insert(QWebSettings::LocalStorageEnabled, false);
    d->attributes.insert(QWebSettings::LocalContentCanAccessRemoteUrls, false);
    d->attributes.insert(QWebSettings::LocalContentCanAccessFileUrls, true);
    d->attributes.insert(QWebSettings::AcceleratedCompositingEnabled, true);
    d->attributes.insert(QWebSettings::WebGLEnabled, true);
    d->attributes.insert(QWebSettings::WebAudioEnabled, false);
    d->attributes.insert(QWebSettings::CSSRegionsEnabled, true);
    d->attributes.insert(QWebSettings::CSSCompositingEnabled, true);
    d->attributes.insert(QWebSettings::CSSGridLayoutEnabled, false);
    d->attributes.insert(QWebSettings::HyperlinkAuditingEnabled, false);
    d->attributes.insert(QWebSettings::TiledBackingStoreEnabled, false);
    d->attributes.insert(QWebSettings::FrameFlatteningEnabled, false);
    d->attributes.insert(QWebSettings::SiteSpecificQuirksEnabled, true);
    d->attributes.insert(QWebSettings::ScrollAnimatorEnabled, false);
    d->attributes.insert(QWebSettings::CaretBrowsingEnabled, false);
    d->attributes.insert(QWebSettings::NotificationsEnabled, true);
    d->offlineStorageDefaultQuota = 5 * 1024 * 1024;
    d->defaultTextEncoding = QLatin1String("iso-8859-1");
    d->thirdPartyCookiePolicy = AlwaysAllowThirdPartyCookies;
}
示例#6
0
/*!
    \internal
*/
QWebSettings::QWebSettings()
    : d(new QWebSettingsPrivate)
{
    // Initialize our global defaults
    d->fontSizes.insert(QWebSettings::MinimumFontSize, 0);
    d->fontSizes.insert(QWebSettings::MinimumLogicalFontSize, 0);
    d->fontSizes.insert(QWebSettings::DefaultFontSize, 16);
    d->fontSizes.insert(QWebSettings::DefaultFixedFontSize, 13);

    QFont defaultFont;
    defaultFont.setStyleHint(QFont::Serif);
    d->fontFamilies.insert(QWebSettings::StandardFont, defaultFont.defaultFamily());
    d->fontFamilies.insert(QWebSettings::SerifFont, defaultFont.defaultFamily());

    defaultFont.setStyleHint(QFont::Fantasy);
    d->fontFamilies.insert(QWebSettings::FantasyFont, defaultFont.defaultFamily());

    defaultFont.setStyleHint(QFont::Cursive);
    d->fontFamilies.insert(QWebSettings::CursiveFont, defaultFont.defaultFamily());

    defaultFont.setStyleHint(QFont::SansSerif);
    d->fontFamilies.insert(QWebSettings::SansSerifFont, defaultFont.defaultFamily());

    defaultFont.setStyleHint(QFont::Monospace);
    d->fontFamilies.insert(QWebSettings::FixedFont, defaultFont.defaultFamily());

#if ENABLE(VIDEO) && USE(WEBOS_MULTIMEDIA)
    d->mediaPipelineOptions = QLatin1String("--gst-debug=1");
#endif

    d->attributes.insert(QWebSettings::AutoLoadImages, true);
    d->attributes.insert(QWebSettings::DnsPrefetchEnabled, false);
    d->attributes.insert(QWebSettings::JavascriptEnabled, true);
    d->attributes.insert(QWebSettings::SpatialNavigationEnabled, false);
    d->attributes.insert(QWebSettings::LinksIncludedInFocusChain, true);
    d->attributes.insert(QWebSettings::ZoomTextOnly, false);
    d->attributes.insert(QWebSettings::PrintElementBackgrounds, true);
    d->attributes.insert(QWebSettings::OfflineStorageDatabaseEnabled, false);
    d->attributes.insert(QWebSettings::OfflineWebApplicationCacheEnabled, false);
    d->attributes.insert(QWebSettings::LocalStorageEnabled, false);
    d->attributes.insert(QWebSettings::LocalContentCanAccessRemoteUrls, false);
    d->attributes.insert(QWebSettings::LocalContentCanAccessFileUrls, true);
    d->attributes.insert(QWebSettings::AcceleratedCompositingEnabled, true);
    d->attributes.insert(QWebSettings::WebGLEnabled, false);
    d->attributes.insert(QWebSettings::HyperlinkAuditingEnabled, false);
    d->attributes.insert(QWebSettings::TiledBackingStoreEnabled, false);
    d->attributes.insert(QWebSettings::FrameFlatteningEnabled, false);
    d->attributes.insert(QWebSettings::SiteSpecificQuirksEnabled, true);
    d->offlineStorageDefaultQuota = 5 * 1024 * 1024;
    d->defaultTextEncoding = QLatin1String("iso-8859-1");
#if QT_VERSION >= QT_VERSION_CHECK(4, 8, 0)
    d->thirdPartyCookiePolicy = AlwaysAllowThirdPartyCookies;
#endif
}
示例#7
0
文件: qt.cpp 项目: Ivan1234/qemacs
static QEFont *qt_open_font(QEditScreen *s, int style, int size)
{
    qDebug() << Q_FUNC_INFO << style << size;

    QEQtContext *ctx = (QEQtContext *)s->priv_data;
    QEFont *font;

    font = qe_mallocz(QEFont);
    if (!font)
        return NULL;

    QFont *f;

    switch (style & QE_FAMILY_MASK) {
    case QE_FAMILY_SANS:
        qDebug() << Q_FUNC_INFO << "Sans font requested";
        f = new QFont();
        f->setStyleHint(QFont::SansSerif);
        break;
    case QE_FAMILY_SERIF:
        qDebug() << Q_FUNC_INFO << "Serif font requested";
        f = new QFont();
        f->setStyleHint(QFont::Serif);
        break;
    case QE_FAMILY_FIXED:
    default:
        qDebug() << Q_FUNC_INFO << "Monospace font requested";
        f = new QFont("Consolas");
        f->setStyleHint(QFont::Monospace);
        f->setFixedPitch(true);
        break;
    }
    f->setStyleStrategy(QFont::ForceIntegerMetrics);
    f->setPointSize(size);

    if (style & QE_STYLE_BOLD)
        f->setBold(true);
    if (style & QE_STYLE_ITALIC)
        f->setItalic(true);
    if (style & QE_STYLE_UNDERLINE)
        f->setUnderline(true);
    if (style & QE_STYLE_LINE_THROUGH)
        f->setStrikeOut(true);

    QFontMetrics fm(*f, &ctx->image);
    font->ascent = fm.ascent();
    font->descent = fm.descent();

    font->priv_data = f;
    QFontInfo fi(*f);
    qDebug() << Q_FUNC_INFO << "Resolved" << fi.family() << fi.pointSize() << fi.fixedPitch();
    return font;
}
示例#8
0
BottomBar::BottomBar(QWidget *parent) :
    QTabWidget(parent)
{
	this->parent = (MainWindow*)parent;

    //console
    textArea = new QTextEdit();
	QFont font;
	font.setFamily("Courier");
	font.setStyleHint(QFont::Monospace);
	font.setFixedPitch(true);
	font.setPointSize(10);
	textArea->setFont(font);
	textArea->setReadOnly(true);
    this->addTab(textArea, "Console");

    //errorlist
    errorList = new QListWidget();
    this->addTab(errorList, "Errors");

    //tabwidget
    QPalette Pal(palette());
    Pal.setColor(QPalette::Background, "#323232");
    setAutoFillBackground(true);
    setPalette(Pal);
	
	setStyleSheet("QTextEdit, QListWidget { color: white; background-color: #2D2D2F; border-style: solid; border-width: 1px; border-color: black; } QTabWidget::pane { background-color: #2D2D2F; } QTabBar::tab { color: white; background-color: #2D2D2F; border-style: solid; border-width: 1px; border-color: black; padding: 3px;} QTabBar::tab:selected { background-color: black; }");

    connect(errorList, SIGNAL(itemDoubleClicked(QListWidgetItem*)), this, SLOT(errorListItemDoubleClicked(QListWidgetItem*)));
	connect(this, SIGNAL(stdOut(QString)), this, SLOT(onStdOut(QString)));

	createRedirector();
}
示例#9
0
OctaveWindow::OctaveWindow(QDockWidget *parent_): QWidget()
{
  QFont font;
  font = QFont("Courier New");
  font.setPointSize(SwieeSettings.font.pointSize()-1);
  font.setStyleHint(QFont::Courier);
  font.setFixedPitch(true);
  setFont(font);

  QWidget *all = new QWidget();
  QVBoxLayout *allLayout = new QVBoxLayout();

  output = new QTextEdit(this);
  output->setReadOnly(true);
  output->setUndoRedoEnabled(false);
  output->setTextFormat(Qt::LogText);
  output->setLineWrapMode(QTextEdit::NoWrap);
  output->setPaletteBackgroundColor(SwieeSettings.BGColor);
  allLayout->addWidget(output);

  input = new QLineEdit(this);
  connect(input, SIGNAL(returnPressed()), SLOT(slotSendCommand()));
  allLayout->addWidget(input);
  all->setLayout(allLayout);

  setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
  parent_->setWidget(all);

  //parent_->setResizeEnabled(true);
  //parent_->setHorizontallyStretchable(true);
  histPosition = 0;

  input->installEventFilter(this);
}
示例#10
0
LogWidget* MainWindow::create_log_widget() const
{
    LogWidget* log_widget = new LogWidget(m_ui->log_contents);
    m_ui->log_contents->layout()->addWidget(log_widget);

    log_widget->setObjectName(QString::fromUtf8("textedit_log"));
    log_widget->setUndoRedoEnabled(false);
    log_widget->setLineWrapMode(QTextEdit::NoWrap);
    log_widget->setReadOnly(true);
    log_widget->setTextInteractionFlags(Qt::TextSelectableByMouse);
    log_widget->setStyleSheet("QTextEdit { border: 0px; }");

    QFont font;
    font.setStyleHint(QFont::TypeWriter);
#if defined _WIN32
    font.setFamily(QString::fromUtf8("Consolas"));
#elif defined __APPLE__
    font.setFamily(QString::fromUtf8("Monaco"));
#else
    font.setFamily(QString::fromUtf8("Courier New"));
#endif
    font.setPixelSize(11);
    log_widget->setFont(font);

    return log_widget;
}
示例#11
0
picGen::picGen()
{

    //homePath="/home/allen7593";

    black=qRgba(0,0,0,255);
    white=qRgba(255,255,255,0);

    s1=new QImage(width*2,height*2,QImage::Format_RGBA8888);
    s2=new QImage(width*2,height*2,QImage::Format_RGBA8888);
    secret=new QImage(width,height,QImage::Format_RGBA8888);

    s1Ex=new QImage(width*6,height*6,QImage::Format_RGBA8888);
    s2Ex=new QImage(width*6,height*6,QImage::Format_RGBA8888);

    //setup a transparent pic for secret drawing
        for(int i=0;i<width;i++)
            for(int j=0;j<height;j++)
                secret->setPixel(i,j,white);

        //write words on the pic
        secretStr=generateRanStr();
        QPainter painter;
        QFont font;
        font.setPixelSize(20);
        //font.setBold(true);
        font.setStyleHint(QFont::TypeWriter);
        painter.begin(secret);
        painter.setFont(font);
        painter.drawText(0,25,secretStr.c_str());
        painter.end();

}
示例#12
0
	bool fromString(const QString & szValue, QFont & buffer)
	{
		KviCString str = szValue;
		KviCString family, pointSize, styleHint, weight, options;
		str.getToken(family, ',');
		str.getToken(pointSize, ',');
		str.getToken(styleHint, ',');
		str.getToken(weight, ',');
		if(!family.isEmpty())
			buffer.setFamily(family.ptr());
		int i;
		bool bOk;
		i = pointSize.toInt(&bOk);
		if(bOk && (i > 0))
			buffer.setPointSize(i);
		i = styleHint.toInt(&bOk);
		if(bOk && (i >= 0))
			buffer.setStyleHint((QFont::StyleHint)i);
		i = weight.toInt(&bOk);
		if(bOk && (i >= 0))
			buffer.setWeight(i);

		buffer.setBold(str.contains("b"));
		buffer.setItalic(str.contains("i"));
		buffer.setUnderline(str.contains("u"));
		buffer.setStrikeOut(str.contains("s"));
		buffer.setFixedPitch(str.contains("f"));
		return true;
	}
示例#13
0
int main(int argc, char **argv)
{
	QGuiApplication app(argc, argv);

	if (app.arguments().size() < 2) {
		qStdOut() << "Usage: fontinfo <family>\n";
		qStdOut() << "       fontinfo -list";
		return -1;
	}

	if (app.arguments().at(1) == "-list") {
		printFontList();
		return 0;
	}

	QFont f;
	f.setStyleHint(QFont::TypeWriter, QFont::StyleStrategy(QFont::PreferDefault | QFont::ForceIntegerMetrics));
	f.setFamily(QStringList(app.arguments().mid(1)).join(" "));
	f.setFixedPitch(true);
	f.setKerning(false);

	printFontInfo(f);
	for (int i=10; i<=18; i++) {
		qStdOut() << "Font size: " << i << endl;
		f.setPointSize(i);
		printFontMetrics(f);
	}
	return 0;
}
/*!
* Constructs a GAsciiDialog object.
*
* \param filePath results file or directory
* \param parent parent widget
* \param f window flags
*/
GAsciiDialog::GAsciiDialog(const QString &filePath, QWidget *parent, Qt::WindowFlags f)
    : QDialog(parent, f)
{
    ui.setupUi(this);

	outputDir = "";
	ui.cboResultsSelect->clear();
	ui.txtResults->clear();

	QFont font = ui.txtResults->font();
	font.setStyleHint(QFont::Monospace);
	font.setFamily("Courier");
	ui.txtResults->setFont(font);

	if (!filePath.isEmpty())
	{
		QFileInfo fi(filePath);
		if (fi.isDir())
		{
			outputDir = filePath;
			QDir dir(filePath);
			dir.setNameFilters(QStringList() << tr("*outfile*.txt") << tr("MatchedPairs.txt") << tr("*DuplicatePairs.txt") << tr("error_log_*.txt"));
			QStringList fileList = dir.entryList();
			for (int i = 0; i < fileList.count(); i++)
				ui.cboResultsSelect->addItem(fileList.at(i));
		}
		else if (fi.isFile())
		{
			outputDir = fi.absolutePath();
			ui.cboResultsSelect->addItem(fi.fileName());
		}
	}
}
示例#15
0
void tst_QTextFormat::testFontStyleSetters()
{
    QTextCharFormat format;

    // test the setters
    format.setFontStyleHint(QFont::Serif);
    QCOMPARE(format.font().styleHint(), QFont::Serif);
    QCOMPARE(format.font().styleStrategy(), QFont::PreferDefault);
    format.setFontStyleStrategy(QFont::PreferOutline);
    QCOMPARE(format.font().styleStrategy(), QFont::PreferOutline);

    // test setting properties through setFont()
    QFont font;
    font.setStyleHint(QFont::SansSerif, QFont::PreferAntialias);
    format.setFont(font);
    QCOMPARE(format.font().styleHint(), QFont::SansSerif);
    QCOMPARE(format.font().styleStrategy(), QFont::PreferAntialias);

    // test kerning
    format.setFontKerning(false);
    QCOMPARE(format.font().kerning(), false);
    format.setFontKerning(true);
    QCOMPARE(format.font().kerning(), true);
    font.setKerning(false);
    format.setFont(font);
    QCOMPARE(format.font().kerning(), false);
}
示例#16
0
GLSLTextEditor::GLSLTextEditor(QWidget* parent)
  : QPlainTextEdit (parent)
{
  _highlighter = new GLSLSyntaxHighlighter(document());

  _lineNumberArea = new LineNumberArea (this);
  connect(this, SIGNAL(blockCountChanged(int)), this, SLOT(UpdateLineNumberAreaWidth(int)));
  connect(this, SIGNAL(updateRequest(QRect,int)), this, SLOT(UpdateLineNumberArea(QRect,int)));
  connect(this, SIGNAL(cursorPositionChanged()), this, SLOT(HighlightCurrentLine()));


  setWordWrapMode(QTextOption::NoWrap);
  QTextDocument* doc = document();
#ifdef _WIN32
  QFont f ("Courier");
#else
  QFont f ("Monospace");
#endif
  f.setStyleHint(QFont::Monospace);
	f.setPixelSize(11);
  doc->setDefaultFont(f);


  connect (doc, SIGNAL(contentsChange(int,int,int)), SLOT(on_document_contentChanged (int, int, int)));

  connect(doc, SIGNAL(contentsChanged()), this, SIGNAL(ContentChanged()));
}
示例#17
0
void EditorWindow::setup_text_editor(){
    QFont font;
    font.setFamily("Courier");
    font.setStyleHint(QFont::Monospace);
    font.setFixedPitch(true);
    font.setPointSize(10);

    ui->textEdit->setFont(font);
    QFontMetrics metrics(font);
    ui->textEdit->setTabStopWidth(6 * metrics.width(' '));

    QBrush *brush = new QBrush();
    brush->setStyle(Qt::SolidPattern);
    brush->setColor(QColor(238, 238, 238));

    QTextEdit::ExtraSelection highlight;
    highlight.cursor = ui->textEdit->textCursor();
    highlight.format.setProperty(QTextFormat::FullWidthSelection, true);
    highlight.format.setBackground( *brush );

    QList<QTextEdit::ExtraSelection> extras;
    extras << highlight;
    ui->textEdit->setExtraSelections( extras );

    new mips_highlighter(ui->textEdit->document());
}
CVisSystemCanvasNote::CVisSystemCanvasNote(CVisSystemCanvas* parent)
:QGraphicsRectItem(0)
{
    d = new CVisSystemCanvasNoteData;
    d->canvas = parent;
    QObject::setParent(d->canvas);

    // Default font
    QFont font;
    font = QApplication::font();
    font.setStyleHint(QFont::Decorative);
    font.setPointSize(font.pointSize()+4);
    setNoteFont(font);

    // Default color
    d->color = Qt::black;

	d->cursorShape = Qt::ArrowCursor;
	d->resizing = false;
    d->mouseOver = false;

	setAcceptHoverEvents(true);
    d->minimumSize = QSizeF(100, 100);
    setRect(QRectF(-100, -100, 200, 200));
    qApp->installEventFilter(this);

    setFlags(QGraphicsRectItem::ItemIsFocusable|QGraphicsRectItem::ItemIsMovable|QGraphicsRectItem::ItemIsSelectable);

    connect(&d->textDocument, SIGNAL(contentsChanged()), this, SIGNAL(noteTextChanged()));
}
OctaveWindow::OctaveWindow(QDockWidget *parent_): QWidget(parent_, 0)
{
  QFont font;
  font = QFont("Courier New");
  font.setPointSize(QucsSettings.font.pointSize()-1);
  font.setStyleHint(QFont::Courier);
  font.setFixedPitch(true);
  setFont(font);

  vBox = new Q3VBoxLayout(this);

  output = new Q3TextEdit(this);
  output->setReadOnly(true);
  output->setUndoRedoEnabled(false);
  output->setTextFormat(Qt::LogText);
  output->setMaxLogLines(2000);
  output->setWordWrap(Q3TextEdit::NoWrap);
  output->setPaletteBackgroundColor(QucsSettings.BGColor);
  vBox->addWidget(output, 10);

  input = new QLineEdit(this);
  connect(input, SIGNAL(returnPressed()), SLOT(slotSendCommand()));
  vBox->addWidget(input);

  setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
  parent_->setWidget(this);
  //parent_->setResizeEnabled(true);
  //parent_->setHorizontallyStretchable(true);

  histIterator = cmdHistory.end();
}
示例#20
0
void Prefs::setupPages() {
    QFontDatabase db;

    foreach (int size, db.standardSizes()) {
        this->fontSize->addItem(QString::number(size));
        if (size == 12) {
            this->fontSize->setCurrentIndex(this->fontSize->count()-1);
        }
    }

    QString fontfamily;
#ifdef Q_WS_X11
    fontfamily = "Mono";
#elif defined (Q_WS_WIN)
    fontfamily = "Console";
#elif defined (Q_WS_MAC)
    fontfamily = "Monaco";
#endif

    QFont font;
    font.setStyleHint(QFont::TypeWriter);
    font.setFamily(fontfamily);
    QString found_family(QFontInfo(font).family());

    this->defaultmap["editor/fontfamily"] = _settings->value("editor/fontfamily", "Courier").toString();
    this->defaultmap["editor/fontsize"]   = _settings->value("editor/fontsize", 12).toInt();
    this->defaultmap["lua/path"]          = _settings->value("lua/path", "/usr/share/bpp/demo/?.lua;demo/?.lua").toString();
    this->defaultmap["povray/export"]     = _settings->value("povray/export", "export").toString();

    QString cache = QStandardPaths::writableLocation(QStandardPaths::CacheLocation);

    QString povopt = "+L" + cache + " +L/usr/share/bpp/includes +L../../include -c +d -A +p +Q11 +GA +SP32 +EP2";
    this->defaultmap["povray/preview"]    = _settings->value("povray/preview", povopt).toString();

    this->defaultmap["openscad/executable"] = _settings->value("openscad/executable", "/usr/bin/openscad").toString();

    connect(this->fontChooser, SIGNAL(activated(const QString &)),
            this, SLOT(fontFamilyChanged(const QString &)));

    connect(this->fontSize, SIGNAL(editTextChanged(const QString &)),
            this, SLOT(fontSizeChanged(const QString &)));

    connect(this->luaPath, SIGNAL(textChanged()),
            this, SLOT(on_luaPathChanged()));

    connect(this->povExportDir, SIGNAL(textChanged(QString)),
            this, SLOT(on_povExportDirChanged()));

    connect(this->povExportDirBrowse, SIGNAL(clicked(bool)),
            this, SLOT(on_povExportDirBrowse()));

    connect(this->povPreview, SIGNAL(textChanged(QString)),
            this, SLOT(on_povPreviewChanged()));

    connect(this->scadExecutable, SIGNAL(textChanged(QString)),
            this, SLOT(on_scadExecutableChanged()));

    connect(this->scadExecutableBrowse, SIGNAL(clicked(bool)),
            this, SLOT(on_scadExecutableBrowse()));
}
示例#21
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;
    }
}
示例#22
0
QFont QsciLexerDASM16::defaultFont(int style) const
{
    QFont f;
    f.setStyleHint(QFont::TypeWriter);

    switch(style)
    {
        case Comment:
            f.setItalic(true);
            break;
        case DCPU_Instruction:
        case Register:
            break;
        case DoubleQuotedString:
        case SingleQuoteString:
        case UnclosedString:
            break;
        case DASM_Directive:
            f.setWeight(QFont::Bold);
        default:
            f = QsciLexer::defaultFont(style);
    }

    return f;
}
示例#23
0
LogDialog::LogDialog(QString lastOutput, QWidget *parent) : QDialog(parent)
{
    setWindowTitle(tr("CEN64 Log"));
    setMinimumSize(600, 400);

    logLayout = new QGridLayout(this);
    logLayout->setContentsMargins(5, 10, 5, 10);

    logArea = new QTextEdit(this);
    logArea->setWordWrapMode(QTextOption::NoWrap);

#if QT_VERSION >= 0x050200
    QFont font = QFontDatabase::systemFont(QFontDatabase::FixedFont);
#else
    QFont font("Monospace");
    font.setStyleHint(QFont::TypeWriter);
#endif
    logArea->setFont(font);

    logArea->setPlainText(lastOutput);

    logButtonBox = new QDialogButtonBox(Qt::Horizontal, this);
    logButtonBox->addButton(tr("Close"), QDialogButtonBox::AcceptRole);

    logLayout->addWidget(logArea, 0, 0);
    logLayout->addWidget(logButtonBox, 1, 0);

    connect(logButtonBox, SIGNAL(accepted()), this, SLOT(close()));

    setLayout(logLayout);
}
示例#24
0
void PHIContext2D::setFont( const QString &f )
{
    QFont font;
    QFont::StyleHint hint=QFont::AnyStyle;
    font.setPixelSize( 10 );
    QString str=f;
    str.replace( QRegExp( QStringLiteral( "[1-9]00" ) ), QString() );
    str.replace( QLatin1Char( '"' ), QString() );
    if ( str.contains( QLatin1String( "italic" ) ) ) {
        font.setItalic( true );
        str.replace( QLatin1String( "italic" ), QString() );
    }
    if ( str.contains( QLatin1String( "bold" ) ) ) {
        font.setWeight( QFont::Bold );
        str.replace( QLatin1String( "bold" ), QString() );
    } else if ( str.contains( QLatin1String( "lighter" ) ) ) {
        font.setWeight( QFont::Light );
        str.replace( QLatin1String( "lighter" ), QString() );
    } else if ( str.contains( QLatin1String( "bolder" ) ) ) {
        font.setWeight( QFont::Black );
        str.replace( QLatin1String( "bolder" ), QString() );
    }
    if ( str.contains( QLatin1String( "sans-serif" ) ) ) {
        hint=QFont::SansSerif;
        str.replace( QLatin1String( "sans-serif" ), QString() );
    } else if ( f.contains( QLatin1String( "monospace" ) ) ) {
        hint=QFont::Monospace;
        str.replace( QLatin1String( "monospace" ), QString() );
    } else if ( f.contains( QLatin1String( "fantasy" ) ) ) {
        hint=QFont::Fantasy;
        str.replace( QLatin1String( "fantasy" ), QString() );
    } else if ( f.contains( QLatin1String( "cursive" ) ) ) {
        hint=QFont::Cursive;
        str.replace( QLatin1String( "cursive" ), QString() );
    }
    int s;
    QString size=str;
    if ( size.contains( QLatin1String( "px" ) ) ) {
        size.replace( QRegExp( QStringLiteral( "px.*" ) ), QString() );
        size.replace( QRegExp( QStringLiteral( ".* " ) ), QString() );
        s=size.toInt();
        if ( s>0 ) font.setPixelSize( s );
        str.replace( QRegExp( QStringLiteral( "[0-9]*px" ) ), QString() );
    }
    if ( size.contains( QLatin1String( "pt" ) ) ) {
        size.replace( QRegExp( QStringLiteral( "pt.*" ) ), QString() );
        size.replace( QRegExp( QStringLiteral( ".* " ) ), QString() );
        s=size.toInt();
        if ( s>0 ) font.setPointSize( s );
        str.replace( QRegExp( QStringLiteral( "[0-9]*pt" ) ), QString() );
    }
    str.replace( QRegExp( QStringLiteral( ",.*" ) ), QString() );
    str=str.trimmed();
    if ( !str.isEmpty() ) font.setFamily( str );
    font.setStyleHint( hint );
    qDebug( "setFont: %s", qPrintable( font.toString() ) );
    _state.font=font;
    _state.flags |= DirtyFont;
}
示例#25
0
void QUnixTerminalImpl::initialize()
{
    m_terminalView = new TerminalView(this);
    m_terminalView->setKeyboardCursorShape(TerminalView::UnderlineCursor);
    m_terminalView->setBlinkingCursor(true);
    m_terminalView->setBellMode(TerminalView::NotifyBell);
    m_terminalView->setTerminalSizeHint(true);
    m_terminalView->setContextMenuPolicy(Qt::CustomContextMenu);
    m_terminalView->setTripleClickMode(TerminalView::SelectWholeLine);
    m_terminalView->setTerminalSizeStartup(true);
    m_terminalView->setSize(80, 40);
    m_terminalView->setScrollBarPosition(TerminalView::ScrollBarRight);

    connect(m_terminalView, SIGNAL(customContextMenuRequested(QPoint)),
            this, SLOT(handleCustomContextMenuRequested(QPoint)));

    connect (m_terminalView, SIGNAL (interrupt_signal (void)),
             this, SLOT (terminal_interrupt ()));

#ifdef Q_OS_MAC
    QFont font = QFont("Monaco");
    font.setStyleHint(QFont::TypeWriter);
    font.setPointSize(11);
#else
    QFont font = QFont("Monospace");
    font.setStyleHint(QFont::TypeWriter);
    font.setPointSize(10);
#endif
    setTerminalFont(font);
    setFocusPolicy (Qt::StrongFocus);
    setFocusProxy(m_terminalView);
    setFocus(Qt::OtherFocusReason);

    m_kpty = new KPty();
    m_kpty->open();

    m_terminalModel = new TerminalModel(m_kpty);
    m_terminalModel->setAutoClose(true);
    m_terminalModel->setCodec(QTextCodec::codecForName("UTF-8"));
    m_terminalModel->setHistoryType(HistoryTypeBuffer(1000));
    m_terminalModel->setDarkBackground(true);
    m_terminalModel->setKeyBindings("");
    m_terminalModel->run();
    m_terminalModel->addView(m_terminalView);
    connectToPty();
}
示例#26
0
void PythonConsole::setFonts()
{
	QFont font = QFont("Fixed");
	font.setStyleHint(QFont::TypeWriter);
	font.setPointSize(PrefsManager::instance()->appPrefs.uiPrefs.applicationFontSize);
	commandEdit->setFont(font);	
	outputEdit->setFont(font);
}
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	//
	// KviCanvasRichText
	//
	KviCanvasRichText::KviCanvasRichText(QCanvas * c,int x,int y,int w,int h)
	: KviCanvasRectangleItem(c,x,y,w,h)
	{
		QFont f = QFont();
		f.setStyleHint(QFont::SansSerif);
		f.setPointSize(12);
		m_properties.insert("szText",QVariant(QString("<center>Insert here your <font color=\"#FF0000\"><b>RICH TEXT</b></font></center>")));
		m_properties.insert("fntDefault",QVariant(f));
	}
示例#28
0
QFont Utility::monoFont(const QFont::Weight& weight, const int &delta)
{
    QFont systemFont;
    systemFont.setStyleHint(QFont::Monospace);
    systemFont.setPointSize(systemFont.pointSize() + delta);
    systemFont.setWeight(weight);

    return systemFont;
}
示例#29
0
QString FontSettings::defaultFixedFontFamily()
{
    static QString rc;
    if (rc.isEmpty()) {
        QFont f = QFont(defaultFontFamily());
        f.setStyleHint(QFont::TypeWriter);
        rc = f.family();
    }
    return rc;
}
void
VBoxDbgConsoleOutput::setFontType(VBoxDbgConsoleFontType enmFontType, bool fSaveIt)
{
    QFont Font = font();
    QAction *pAction;
    const char *pszSetting;
    switch (enmFontType)
    {
        case kFontType_Courier:
#ifdef Q_WS_MAC
            Font = QFont("Monaco", Font.pointSize(), QFont::Normal, FALSE);
            Font.setStyleStrategy(QFont::NoAntialias);
#else
            Font.setStyleHint(QFont::TypeWriter);
            Font.setFamily("Courier [Monotype]");
#endif
            pszSetting = "Courier";
            pAction = m_pCourierFontAction;
            break;

        case kFontType_Monospace:
            Font.setStyleHint(QFont::TypeWriter);
            Font.setStyleStrategy(QFont::PreferAntialias);
            Font.setFamily("Monospace [Monotype]");
            pszSetting = "Monospace";
            pAction = m_pMonospaceFontAction;
            break;

        default:
            AssertFailedReturnVoid();
    }

    setFont(Font);

    /* When going through a slot, the action is typically checked already by Qt. */
    if (!pAction->isChecked())
        pAction->setChecked(true);

    /* Make this setting persistent. */
    if (m_pVirtualBox && fSaveIt)
        m_pVirtualBox->SetExtraData(com::Bstr("DbgConsole/Font").raw(), com::Bstr(pszSetting).raw());
}