void draw(void) {
if (!visible()) return;
Serial.println(absoluteX());
int16_t newx = absoluteX() + padding;
int16_t midy = GuiUtils::getElementCentreY(this);
int8_t boxSize = fontSize() * 7;
// we are going to recalc the width here too. not ideal but the width isn't know when an element is added
if (parent == NULL) {
width = 30;
}
else {
width = parent->width - (2*margin) - (2*parent->padding);
}
GuiElement::drawBase();
_tft->drawCircle(newx + (boxSize / 2), midy, boxSize/2, ILI9341_WHITE);
if (pressed())
Serial.println("pressed");
// erase or fill the bg
if (pressed()) {
// tick it
_tft->fillCircle(newx + (boxSize / 2), midy, (boxSize/2) - 3, ILI9341_WHITE);
}
extraXOffset = 3 + fontSize() * 7;
// draw all of the children now
GuiLabel::draw(false);
}
void ScreenPainter::drawGlyphOutline(const GlyphLayout gl, bool fill)
{
if (fill)
drawGlyph(gl);
m_painter->save();
bool fr = m_painter->fillRule();
m_painter->setFillRule(false);
setupState(false);
m_painter->translate(0, -(fontSize() * gl.scaleV));
FPointArray outline = font().glyphOutline(gl.glyph);
double scaleHv = gl.scaleH * fontSize() / 10.0;
double scaleVv = gl.scaleV * fontSize() / 10.0;
QTransform trans;
trans.scale(scaleHv, scaleVv);
outline.map(trans);
m_painter->setupPolygon(&outline, true);
if (outline.size() > 3)
{
m_painter->setLineWidth(strokeWidth());
m_painter->strokePath();
}
m_painter->setFillRule(fr);
m_painter->restore();
}
Vector2i CheckBox::preferredSize(NVGcontext *ctx) {
if (mFixedSize != Vector2i(0))
return mFixedSize;
nvgFontSize(ctx, fontSize());
nvgFontFace(ctx, "sans");
return Vector2i(
nvgTextBounds(ctx, 0, 0, mCaption.c_str(), nullptr, nullptr) +
1.7f * fontSize(),
fontSize() * 1.3f);
}
/*!
* Returns a QFont object based on font data contained in the format.
*/
QFont Format::font() const
{
QFont font;
font.setFamily(fontName());
if (fontSize() > 0)
font.setPointSize(fontSize());
font.setBold(fontBold());
font.setItalic(fontItalic());
font.setUnderline(fontUnderline()!=FontUnderlineNone);
font.setStrikeOut(fontStrikeOut());
return font;
}
InteractivePointer::InteractivePointer()
{
this->setScaledContents(true);
this->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored);
this->setFixedWidth(pointerSizeX());
this->setFixedHeight(pointerSizeY());
//this->setTextFormat(Qt::RichText);
this->setMargin(0);
this->setContentsMargins(0, 0, 0, 0);
this->setAlignment(Qt::AlignTop);
setPointerSizeX(40);
setPointerSizeY(40);
setWinSize(3);
// Initialise an image to hold pointer data.
m_imagep = new QImage(8, 8, QImage::Format_ARGB32);
m_pixmap = QPixmap::fromImage(*m_imagep);
// Set pixelmap to this label.
this->setPixmap(m_pixmap);
// Set font size.
setFontSize(9);
m_labelFont.setPointSize(fontSize());
// Font metrics in order to adjust pointer size
QFontMetrics fm(m_labelFont);
m_pixelsWideT = fm.width("000");
m_pixelsWideS = fm.width(" ");
m_pixelsHighT = fm.height();
m_pixelsHighS = fm.lineSpacing();
}
void CheckBox::draw(NVGcontext *ctx) {
Widget::draw(ctx);
nvgFontSize(ctx, fontSize());
nvgFontFace(ctx, "sans");
nvgFillColor(ctx,
mEnabled ? mTheme->mTextColor : mTheme->mDisabledTextColor);
nvgTextAlign(ctx, NVG_ALIGN_LEFT | NVG_ALIGN_MIDDLE);
nvgText(ctx, mPos.x + 1.2f * mSize.y + 5, mPos.y + mSize.y * 0.5f,
mCaption.c_str(), nullptr);
NVGpaint bg = nvgBoxGradient(ctx, mPos.x + 1.5f, mPos.y + 1.5f,
mSize.y - 2.0f, mSize.y - 2.0f, 3, 3,
mPushed ? Color(0, 100) : Color(0, 32),
Color(0, 0, 0, 180));
nvgBeginPath(ctx);
nvgRoundedRect(ctx, mPos.x + 1.0f, mPos.y + 1.0f, mSize.y - 2.0f,
mSize.y - 2.0f, 3);
nvgFillPaint(ctx, bg);
nvgFill(ctx);
if (mChecked) {
nvgFontSize(ctx, 1.8 * mSize.y);
nvgFontFace(ctx, "icons");
nvgFillColor(ctx, mEnabled ? mTheme->mIconColor
: mTheme->mDisabledTextColor);
nvgTextAlign(ctx, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);
nvgText(ctx, mPos.x + mSize.y * 0.5f + 1,
mPos.y + mSize.y * 0.5f, utf8(ENTYPO_ICON_CHECK).data(),
nullptr);
}
}
QFont State::font(QFont base)
{
if (bold())
base.setBold(true);
if (italic())
base.setItalic(true);
if (underline())
base.setUnderline(true);
if (strikeOut())
base.setStrikeOut(true);
if (!fontName().isEmpty())
base.setFamily(fontName());
if (fontSize() > 0)
base.setPointSize(fontSize());
return base;
}
void ComparisonGraphic::paintPreview(QPainter *painter)
{
if (!statHeader.trimmed().isEmpty()) {
painter->setFont(statFont);
QFontMetrics fontSize(statFont);
painter->fillRect(0, BOX_HEIGHT-24, fontSize.width(statHeader) + 10, 24, statHeaderGradient );
painter->setPen(QColor(1,1,1));
painter->drawText(0, BOX_HEIGHT-24,fontSize.width(statHeader) + 10, 24, Qt::AlignCenter, statHeader);
}
painter->fillRect(0, BOX_HEIGHT, statistics.size() > 2 ? 800 : 600, BOX_HEIGHT * 2, bgGradient);
painter->fillRect(5, BOX_HEIGHT, statistics.size() > 2 ? 790 : 590, BOX_HEIGHT, topGradient);
painter->fillRect(5, BOX_HEIGHT * 2, statistics.size() > 2 ? 790 : 590, BOX_HEIGHT, bottomGradient);
painter->drawPixmap(5 + (topOffset ? awayLogoXOffset : 0), BOX_HEIGHT + (topOffset ? awayLogoYOffset : 0),topOffset ? *awayLogo:*homeLogo);
painter->drawPixmap(5 + (botOffset ? awayLogoXOffset : 0), BOX_HEIGHT*2 +( botOffset ? awayLogoYOffset : 0),botOffset ? *awayLogo:*homeLogo);
painter->setFont(nameFont);
painter->setPen(QColor(255, 255, 255));
painter->drawText(100, BOX_HEIGHT, 400, BOX_HEIGHT, Qt::AlignVCenter, awayLabel);
painter->drawText(400, BOX_HEIGHT, 200, BOX_HEIGHT, Qt::AlignVCenter, statistics.at(0));
painter->drawText(100, BOX_HEIGHT*2, 400, BOX_HEIGHT, Qt::AlignVCenter, homeLabel);
painter->drawText(400, BOX_HEIGHT*2, 200, BOX_HEIGHT, Qt::AlignVCenter, statistics.at(1));
if (statistics.size() > 2) {
painter->drawText(600, BOX_HEIGHT, 200 ,BOX_HEIGHT, Qt::AlignVCenter, statistics.at(2));
painter->drawText(600, BOX_HEIGHT*2, 200 ,BOX_HEIGHT, Qt::AlignVCenter, statistics.at(3));
}
}
void MRichTextEditDialogsManager::setTextStyleValues(const QString &fontfamily, int fontPointSize,
const QColor &fontColor)
{
Q_ASSERT(fontFamilyCombo);
int familyIndex = -1;
QStringListModel *fontFamilyModel = dynamic_cast<QStringListModel *>(fontFamilyCombo->itemModel());
if (fontFamilyModel) {
QStringList fontFamilies = fontFamilyModel->stringList();
familyIndex = fontFamilies.indexOf(fontfamily);
}
fontFamilyCombo->setCurrentIndex(familyIndex);
Q_ASSERT(fontSizeCombo);
QStringList fontSizeValues = generateFontSizeComboValues();
QStringListModel *fontSizeModel = dynamic_cast<QStringListModel *>(fontSizeCombo->itemModel());
if (fontSizeModel) {
fontSizeModel->setStringList(fontSizeValues);
}
//% "%L1 points"
QString fontSize(qtTrId("qtn_comm_font_size_value").arg(fontPointSize));
int sizeIndex = fontSizeValues.indexOf(fontSize);
fontSizeCombo->setCurrentIndex(sizeIndex);
Q_ASSERT(fontColorCombo);
fontColorCombo->setPickedColor(fontColor);
}
void QgsComposerLabel::paint( QPainter* painter, const QStyleOptionGraphicsItem* itemStyle, QWidget* pWidget )
{
if ( !painter )
{
return;
}
drawBackground( painter );
painter->setPen( QPen( QColor( mFontColor ) ) ); //draw all text black
painter->setFont( mFont );
QFontMetricsF fontSize( mFont );
//support multiline labels
double penWidth = pen().widthF();
QRectF painterRect( penWidth + mMargin, penWidth + mMargin, rect().width() - 2 * penWidth - 2 * mMargin,
rect().height() - 2 * penWidth - 2 * mMargin );
drawText( painter, painterRect, displayText(), mFont, mHAlignment, mVAlignment );
drawFrame( painter );
if ( isSelected() )
{
drawSelectionBoxes( painter );
}
}
bool KstViewLabel::fillConfigWidget(QWidget *w, bool isNew) const {
ViewLabelWidget *widget = dynamic_cast<ViewLabelWidget*>(w);
if (!widget) {
return false;
}
if (!isNew) {
widget->_text->setText(text());
}
widget->_precision->setValue(int(dataPrecision()));
widget->_rotation->setValue(double(rotation()));
widget->_fontSize->setValue(int(fontSize()));
widget->_horizontal->setCurrentItem(horizJustifyWrap());
widget->_fontColor->setColor(foregroundColor());
widget->_font->setCurrentFont(fontName());
widget->_transparent->setChecked(transparent());
widget->_border->setValue(borderWidth());
widget->_boxColors->setForeground(borderColor());
widget->_boxColors->setBackground(backgroundColor());
widget->_margin->setValue(labelMargin());
widget->_text->setFocus();
return true;
}
void Util::setFontSize(int size)
{
if (size == fontSize()) {
return;
}
setSettingsValue("ui/fontSize", size);
emit fontSizeChanged();
}
void FrotzScreen::loadVersion6Fonts(Common::Archive *archive) {
// Set the basic font properties
MonoFontInfo &mi = g_conf->_monoInfo;
PropFontInfo &pi = g_conf->_propInfo;
mi._size = pi._size = 7;
mi._aspect = pi._aspect = 1.0;
pi._quotes = 0;
pi._dashes = 0;
pi._spaces = 0;
pi._morePrompt = "[MORE]";
pi._lineSeparation = 0;
g_vm->_defaultForeground = 0;
g_vm->_defaultBackground = (int)zcolor_Transparent;
g_conf->_tMarginX = 3;
for (uint idx = 0; idx < style_NUMSTYLES; ++idx) {
g_conf->_tStyles[idx].bg = g_conf->_tStylesDefault[idx].bg = zcolor_Transparent;
g_conf->_gStyles[idx].bg = g_conf->_gStylesDefault[idx].bg = zcolor_Transparent;
}
_fonts.resize(8);
// Load up the 8x8 Infocom font
Image::BitmapDecoder decoder;
Common::File f;
if (!f.open("infocom6x8.bmp", *archive))
error("Could not load font");
Common::Point fontSize(6, 8);
decoder.loadStream(f);
f.close();
// Add normal fonts
_fonts[MONOR] = new FixedWidthBitmapFont(*decoder.getSurface(), fontSize, 6, 8);
_fonts[MONOB] = new FixedWidthBitmapFont(*decoder.getSurface(), fontSize, 6, 8);
_fonts[PROPR] = new VariableWidthBitmapFont(*decoder.getSurface(), fontSize, 6, 8);
_fonts[PROPB] = new VariableWidthBitmapFont(*decoder.getSurface(), fontSize, 6, 8);
// Create a new version of the font with every character unlined for the emphasized fonts
const Graphics::Surface &norm = *decoder.getSurface();
Graphics::ManagedSurface emph(norm.w, norm.h);
emph.blitFrom(norm);
for (int y = 8 - 2; y < emph.h; y += 8) {
byte *lineP = (byte *)emph.getBasePtr(0, y);
Common::fill(lineP, lineP + emph.w, 0);
}
// Add them to the font list
_fonts[MONOI] = new FixedWidthBitmapFont(emph, fontSize, 6, 8);
_fonts[MONOZ] = new FixedWidthBitmapFont(emph, fontSize, 6, 8);
_fonts[PROPI] = new VariableWidthBitmapFont(emph, fontSize, 6, 8);
_fonts[PROPZ] = new VariableWidthBitmapFont(emph, fontSize, 6, 8);
}
// FIXME: expensive - cache it?
int KstLabel::lineSpacing(QPainter &p) {
int LineSpacing = 0;
QFont TextFont(FontName, fontSize(p), QFont::Normal, false);
p.save();
p.setFont(TextFont);
LineSpacing = p.fontMetrics().lineSpacing();
p.restore();
return LineSpacing;
}
int KstLabel::ascent(QPainter &p) {
int Ascent = 0;
QFont TextFont(FontName, fontSize(p), QFont::Normal, false);
p.save();
p.setFont(TextFont);
Ascent = p.fontMetrics().boundingRect("1234567890").height();
p.restore();
return Ascent;
}
// ****************************************************************************
// using the current scale, work out the size of the label in molecule
// coordinates
void MolDraw2DSVG::getStringSize(const std::string &label, double &label_width,
double &label_height) const {
label_width = 0.0;
label_height = 0.0;
TextDrawType draw_mode = TextDrawNormal;
bool had_a_super = false;
bool had_a_sub = false;
for (int i = 0, is = label.length(); i < is; ++i) {
// setStringDrawMode moves i along to the end of any <sub> or <sup>
// markup
if ('<' == label[i] && setStringDrawMode(label, draw_mode, i)) {
continue;
}
label_height = fontSize();
double char_width =
fontSize() *
static_cast<double>(MolDraw2D_detail::char_widths[(int)label[i]]) /
MolDraw2D_detail::char_widths[(int)'M'];
if (TextDrawSubscript == draw_mode) {
char_width *= 0.5;
had_a_sub = true;
} else if (TextDrawSuperscript == draw_mode) {
char_width *= 0.5;
had_a_super = true;
}
label_width += char_width;
}
// subscript keeps its bottom in line with the bottom of the bit chars,
// superscript goes above the original char top by a bit (empirical)
if (had_a_super) {
label_height *= 1.1;
}
if (had_a_sub) {
label_height *= 1.1;
}
}
void ComparisonGraphic::showComparison()
{
show = true;
if (!statHeader.trimmed().isEmpty()) {
QFontMetrics fontSize(statFont);
emit addNoTransparencyZone(QRect(x(), y() + BOX_HEIGHT-24, fontSize.width(statHeader) + 10, 24));
}
emit addNoTransparencyZone(QRect(x(), y() + BOX_HEIGHT, statistics.size() > 2 ? 800 : 600, BOX_HEIGHT * 2));
scene()->update(this->x(), this->y(), rect().width(), rect().height());
}
PasteTextWindow(const std::string& face, int size,
const app::Color& color)
: m_face(face) {
ok()->setEnabled(!m_face.empty());
if (!m_face.empty())
updateFontFaceButton();
fontSize()->setTextf("%d", size);
fontFace()->Click.connect(Bind<void>(&PasteTextWindow::onSelectFontFile, this));
fontFace()->DropDownClick.connect(Bind<void>(&PasteTextWindow::onSelectSystemFont, this));
fontColor()->setColor(color);
}
MarkerContainer::MarkerContainer() {
auto s = Settings("MarkerL");
myColor1 = s.color1();
myColor2 = s.color2();
myPenWidth = s.penWidth();
myFont = s.font();
myFontSize = s.fontSize();
mySize = s.size();
myHasBackground = s.hasBackground();
myType = 0;
visible = true;
}
gdPoint stringSize(char *s, int f) {
// Returns the X and Y dimensions of string `s' when printed with font `f' (a GD font index).
gdPoint fsize;
gdPoint result;
fsize = fontSize(f);
//printf("%dx%d %d\n", fsize.x, fsize.y, strlen(s));
result.x = strlen(s) * fsize.x;
result.y = fsize.y;
return result;
}
/** fill the custom widget with current properties */
bool KstViewLegend::fillConfigWidget(QWidget *w, bool isNew) const {
ViewLegendWidget *widget = dynamic_cast<ViewLegendWidget*>(w);
if (!widget) {
return false;
}
KstBaseCurveList allCurves = kstObjectSubList<KstDataObject, KstBaseCurve>(KST::dataObjectList);
if (isNew) {
widget->_fontSize->setValue(0);
widget->_fontColor->setColor(KstSettings::globalSettings()->foregroundColor);
widget->_font->setCurrentFont(KstApp::inst()->defaultFont());
widget->_margin->setValue(5);
widget->_boxColors->setColor(KstSettings::globalSettings()->foregroundColor);
widget->_vertical->setChecked(true);
widget->_transparent->setChecked(false);
widget->_border->setValue(2);
widget->_title->setText("");
widget->TrackContents->setChecked(true);
for (KstBaseCurveList::ConstIterator it = allCurves.begin(); it != allCurves.end(); ++it) {
(*it)->readLock();
widget->AvailableCurveList->insertItem((*it)->tagName());
(*it)->unlock();
}
} else { // fill legend properties into widget
widget->TrackContents->setChecked(trackContents());
widget->_title->setText(title());
widget->_fontSize->setValue(int(fontSize()));
widget->_fontColor->setColor(foregroundColor());
widget->_font->setCurrentFont(fontName());
widget->_transparent->setChecked(transparent());
widget->_border->setValue(borderWidth());
widget->_boxColors->setColor(borderColor());
widget->_margin->setValue(_legendMargin);
widget->_vertical->setChecked(vertical());
for (KstBaseCurveList::ConstIterator it = _curves.begin(); it != _curves.end(); ++it) {
(*it)->readLock();
widget->DisplayedCurveList->insertItem((*it)->tagName());
(*it)->unlock();
}
for (KstBaseCurveList::ConstIterator it = allCurves.begin(); it != allCurves.end(); ++it) {
(*it)->readLock();
if (_curves.find(*it) == _curves.end()) {
widget->AvailableCurveList->insertItem((*it)->tagName());
}
(*it)->unlock();
}
}
return false;
}
QFont Ticker::resizeText()
{
int subtraction = 0;
int fontPointSize = 24;
QFontMetrics fontSize(QFont("Arial", 24, QFont::Bold));
// while (fontSize.width(players.at(index)->toString()) > WIDTH - 205) {
// QFont tempFont("Arial", fontPointSize - subtraction, QFont::Bold);
// subtraction++;
// QFontMetrics temp(tempFont);
// fontSize = temp;
// }
return QFont("Arial", 24 - subtraction, QFont::Bold);
}
void Label::draw(NVGcontext *ctx) {
Widget::draw(ctx);
nvgFontFace(ctx, mFont.c_str());
nvgFontSize(ctx, fontSize());
nvgFillColor(ctx, mColor);
if (mFixedSize.x() > 0) {
nvgTextAlign(ctx, NVG_ALIGN_LEFT | NVG_ALIGN_TOP);
nvgTextBox(ctx, mPos.x(), mPos.y(), mFixedSize.x(), mCaption.c_str(), nullptr);
} else {
nvgTextAlign(ctx, NVG_ALIGN_LEFT | NVG_ALIGN_MIDDLE);
nvgText(ctx, mPos.x(), mPos.y() + mSize.y() * 0.5f, mCaption.c_str(), nullptr);
}
}
static mFloat print_message(
const wchar_t* message,
mFloat x,
mFloat* y)
{
mFloat sy;
fontSize(message, NULL, &sy);
fontPrint(x, *y, 0, message);
*y += sy;
return sy;
}
void CommercialGraphic::checkAwayFont()
{
int fontPointSize = away->font().pointSize();
int subtraction = 1;
QFontMetrics fontSize(away->font());
while (fontSize.width(away->toPlainText()) > NAME_WIDTH - 5) {
QFont tempFont("Arial", fontPointSize - subtraction, QFont::Bold);
subtraction++;
away->setFont(tempFont);
QFontMetrics temp(away->font());
fontSize = temp;
}
}
bool KstViewLabel::fillConfigWidget(QWidget *w, bool isNew) const {
ViewLabelWidget *widget = dynamic_cast<ViewLabelWidget*>(w);
if (!widget) {
return false;
}
if (isNew) { // probably a new label: set widget to defaults
widget->_precision->setValue(8);
widget->_rotation->setValue(0);
widget->_fontSize->setValue(0);
widget->_horizontal->setCurrentItem(0);
widget->_fontColor->setColor(KstSettings::globalSettings()->foregroundColor);
widget->_font->setCurrentFont(KstApp::inst()->defaultFont());
widget->_margin->setValue(5);
widget->_boxColors->setColor(KstSettings::globalSettings()->backgroundColor);
if (size().width() * size().height() < 25) { // assume a click, and default to just text
widget->_transparent->setChecked(true);
widget->_border->setValue(0);
} else { // someone drew a box, so assume that is what they wanted
widget->_transparent->setChecked(false);
widget->_border->setValue(2);
}
} else {
// No, this is broken. It kills latex.
#if 0
// replace \n & \t with tabs and newlines for the text edit box
QString tmpstr = text();
tmpstr.replace(QString("\\n"), "\n");
tmpstr.replace(QString("\\t"), "\t");
widget->_text->setText(tmpstr);
#endif
widget->_text->setText(text());
widget->_precision->setValue(int(dataPrecision()));
widget->_rotation->setValue(double(rotation()));
widget->_fontSize->setValue(int(fontSize()));
widget->_horizontal->setCurrentIndex(horizJustifyWrap());
widget->_fontColor->setColor(foregroundColor());
widget->_font->setCurrentFont(fontName());
widget->_transparent->setChecked(transparent());
widget->_border->setValue(borderWidth());
widget->_boxColors->setColor(borderColor());
widget->_margin->setValue(_labelMargin);
}
widget->_text->setFocus();
return true;
}
QString State::toCSS(const QString &gradientFolderPath, const QString &gradientFolderName, const QFont &baseFont)
{
QString css;
if (bold())
css += " font-weight: bold;";
if (italic())
css += " font-style: italic;";
if (underline() && strikeOut())
css += " text-decoration: underline line-through;";
else if (underline())
css += " text-decoration: underline;";
else if (strikeOut())
css += " text-decoration: line-through;";
if (textColor().isValid())
css += " color: " + textColor().name() + ";";
if (!fontName().isEmpty()) {
QString fontFamily = Tools::cssFontDefinition(fontName(), /*onlyFontFamily=*/true);
css += " font-family: " + fontFamily + ";";
}
if (fontSize() > 0)
css += " font-size: " + QString::number(fontSize()) + "px;";
if (backgroundColor().isValid()) {
// Get the colors of the gradient and the border:
QColor topBgColor;
QColor bottomBgColor;
Note::getGradientColors(backgroundColor(), &topBgColor, &bottomBgColor);
// Produce the CSS code:
QString gradientFileName = Basket::saveGradientBackground(backgroundColor(), font(baseFont), gradientFolderPath);
css += " background: " + bottomBgColor.name() + " url('" + gradientFolderName + gradientFileName + "') repeat-x;";
css += " border-top: solid " + topBgColor.name() + " 1px;";
css += " border-bottom: solid " + Tools::mixColor(topBgColor, bottomBgColor).name() + " 1px;";
}
if (css.isEmpty())
return "";
else
return " .tag_" + id() + " {" + css + " }\n";
}
void ComparisonGraphic::prepareComp(QString topLabel, QString botLabel, QList<QString> stats, QString pStatHeader, int compStyle)
{
if(!preview && show) {
if (!statHeader.trimmed().isEmpty()) {
QFontMetrics fontSize(statFont);
emit removeNoTransparencyZone(QRect(x(), y() + BOX_HEIGHT-24, fontSize.width(statHeader) + 10, 24));
}
emit removeNoTransparencyZone(QRect(x(), y() + BOX_HEIGHT, statistics.size() > 2 ? 800 : 600, BOX_HEIGHT * 2));
}
statFont.setPointSize(statFontPointSize);
statHeader = pStatHeader;
this->awayLabel = topLabel;
this->homeLabel = botLabel;
statistics=stats;
prepareFontSize();
topOffset = compStyle != 2;
botOffset = compStyle == 1;
switch(compStyle) {
case 0:
topGradient.setColorAt(0, awayTeamMain);
topGradient.setColorAt(1, awayGradientEnd);
bottomGradient.setColorAt(0, homeTeamMain);
bottomGradient.setColorAt(1, homeGradientEnd);
// topLogo = awayLogo;
// bottomLogo = homeLogo;
break;
case 1:
topGradient.setColorAt(0, awayTeamMain);
topGradient.setColorAt(1, awayGradientEnd);
bottomGradient.setColorAt(0, awayTeamMain);
bottomGradient.setColorAt(1, awayGradientEnd);
// topLogo = awayLogo;
// bottomLogo = awayLogo;
break;
case 2:
topGradient.setColorAt(0, homeTeamMain);
topGradient.setColorAt(1, homeGradientEnd);
bottomGradient.setColorAt(0, homeTeamMain);
bottomGradient.setColorAt(1, homeGradientEnd);
// topLogo = homeLogo;
// bottomLogo = homeLogo;
break;
}
if (!preview) showComparison();
}
LegendGroup::LegendGroup(const QPointF& Clicked, MarkerModel* model, QGraphicsItem* parent):
QGraphicsItemGroup(parent), origin(Clicked), model(model)
{
mySize = 20;
frame = new RectItem(QRectF());
frame->setBrush(QColor(255, 255, 255, 192));
setFlags(QGraphicsItem::ItemIsSelectable | QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemSendsGeometryChanges);
addToGroup(frame);
auto s = Settings("LegendL");
myPenWidth = s.penWidth();
mySize = s.size();
myFont = s.font();
myFontSize = s.fontSize();
updateModel();
}
// ****************************************************************************
// draw the char, with the bottom left hand corner at cds
void MolDraw2DSVG::drawChar(char c, const Point2D &cds) {
unsigned int fontSz = scale() * fontSize();
std::string col = DrawColourToSVG(colour());
d_os << "<text";
d_os << " x='" << cds.x;
d_os << "' y='" << cds.y << "'";
d_os << " style='font-size:" << fontSz
<< "px;font-style:normal;font-weight:normal;fill-opacity:1;stroke:none;"
"font-family:sans-serif;text-anchor:start;"
<< "fill:" << col << "'";
d_os << " >";
d_os << c;
d_os << "</text>";
}
