void GlyphStringRenderer::setPenWidth(int width) { mPenWidth = width; layout(); }
void GlyphStringRenderer::setRunArrowColor(QColor color) { mRunArrowColor = color; layout(); }
void GlyphStringRenderer::setRendererFlags(quint32 flags) { mFlags = flags; layout(); }
void GlyphStringRenderer::setGlyphString(const GlyphString *glyphString) { mGlyphString = glyphString; layout(); }
void GlyphStringRenderer::setLevelArrowColor(QColor color) { mLevelArrowColor = color; layout(); }
QgsHeatmapRendererWidget::QgsHeatmapRendererWidget( QgsVectorLayer* layer, QgsStyleV2* style, QgsFeatureRendererV2* renderer ) : QgsRendererV2Widget( layer, style ) , mRenderer( nullptr ) { if ( !layer ) { return; } // the renderer only applies to point vector layers if ( layer->geometryType() != Qgis::Point ) { //setup blank dialog mRenderer = nullptr; QLabel* label = new QLabel( tr( "The heatmap renderer only applies to point and multipoint layers. \n" "'%1' is not a point layer and cannot be rendered as a heatmap." ) .arg( layer->name() ), this ); layout()->addWidget( label ); return; } setupUi( this ); mRadiusUnitWidget->setUnits( QgsUnitTypes::RenderUnitList() << QgsUnitTypes::RenderMillimeters << QgsUnitTypes::RenderPixels << QgsUnitTypes::RenderMapUnits ); mWeightExpressionWidget->registerGetExpressionContextCallback( &_getExpressionContext, this ); if ( renderer ) { mRenderer = QgsHeatmapRenderer::convertFromRenderer( renderer ); } if ( !mRenderer ) { mRenderer = new QgsHeatmapRenderer(); } mRampComboBox->setShowGradientOnly( true ); mRampComboBox->populate( QgsStyleV2::defaultStyle() ); connect( mRampComboBox, SIGNAL( currentIndexChanged( int ) ), this, SLOT( applyColorRamp() ) ); connect( mRampComboBox, SIGNAL( sourceRampEdited() ), this, SLOT( applyColorRamp() ) ); connect( mButtonEditRamp, SIGNAL( clicked() ), mRampComboBox, SLOT( editSourceRamp() ) ); if ( mRenderer->colorRamp() ) { mRampComboBox->blockSignals( true ); mRampComboBox->setSourceColorRamp( mRenderer->colorRamp() ); mRampComboBox->blockSignals( false ); } mRadiusSpinBox->blockSignals( true ); mRadiusSpinBox->setValue( mRenderer->radius() ); mRadiusSpinBox->blockSignals( false ); mRadiusUnitWidget->blockSignals( true ); mRadiusUnitWidget->setUnit( mRenderer->radiusUnit() ); mRadiusUnitWidget->setMapUnitScale( mRenderer->radiusMapUnitScale() ); mRadiusUnitWidget->blockSignals( false ); mMaxSpinBox->blockSignals( true ); mMaxSpinBox->setValue( mRenderer->maximumValue() ); mMaxSpinBox->blockSignals( false ); mQualitySlider->blockSignals( true ); mQualitySlider->setValue( mRenderer->renderQuality() ); mQualitySlider->blockSignals( false ); mInvertCheckBox->blockSignals( true ); mInvertCheckBox->setChecked( mRenderer->invertRamp() ); mInvertCheckBox->blockSignals( false ); mWeightExpressionWidget->setLayer( layer ); mWeightExpressionWidget->setField( mRenderer->weightExpression() ); connect( mWeightExpressionWidget, SIGNAL( fieldChanged( QString ) ), this, SLOT( weightExpressionChanged( QString ) ) ); }
VCSlider::VCSlider(QWidget* parent, Doc* doc) : VCWidget(parent, doc) { /* Set the class name "VCSlider" as the object name as well */ setObjectName(VCSlider::staticMetaObject.className()); m_hbox = NULL; m_topLabel = NULL; m_slider = NULL; m_knob = NULL; m_bottomLabel = NULL; m_valueDisplayStyle = ExactValue; m_levelLowLimit = 0; m_levelHighLimit = UCHAR_MAX; m_levelValue = 0; m_levelValueChanged = false; m_playbackFunction = Function::invalidId(); m_playbackValue = 0; m_playbackValueChanged = false; m_submasterValue = UCHAR_MAX; m_widgetMode = WSlider; setType(VCWidget::SliderWidget); setCaption(QString()); setFrameStyle(KVCFrameStyleSunken); /* Main VBox */ new QVBoxLayout(this); /* Top label */ m_topLabel = new QLabel(this); m_topLabel->setAlignment(Qt::AlignHCenter); layout()->addWidget(m_topLabel); /* Slider's HBox |stretch|slider|stretch| */ m_hbox = new QHBoxLayout(); /* Put stretchable space before the slider (to its left side) */ m_hbox->addStretch(); /* The slider */ m_slider = new ClickAndGoSlider(this); m_hbox->addWidget(m_slider); m_slider->setRange(0, 255); m_slider->setPageStep(1); m_slider->setInvertedAppearance(false); m_slider->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Expanding); m_slider->setMinimumWidth(32); m_slider->setMaximumWidth(80); m_slider->setStyleSheet(sliderStyleSheet); connect(m_slider, SIGNAL(valueChanged(int)), this, SLOT(slotSliderMoved(int))); m_externalMovement = false; /* Put stretchable space after the slider (to its right side) */ m_hbox->addStretch(); layout()->addItem(m_hbox); /* Click & Go button */ m_cngType = ClickAndGoWidget::None; m_cngButton = new QToolButton(this); m_cngButton->setFixedSize(48, 48); m_cngButton->setIconSize(QSize(42, 42)); m_menu = new QMenu(this); QWidgetAction* action = new QWidgetAction(this); m_cngWidget = new ClickAndGoWidget(); action->setDefaultWidget(m_cngWidget); m_menu->addAction(action); m_cngButton->setMenu(m_menu); m_cngButton->setPopupMode(QToolButton::InstantPopup); layout()->addWidget(m_cngButton); layout()->setAlignment(m_cngButton, Qt::AlignHCenter); m_cngButton->hide(); connect(m_cngWidget, SIGNAL(levelChanged(uchar)), this, SLOT(slotClickAndGoLevelChanged(uchar))); connect(m_cngWidget, SIGNAL(colorChanged(QRgb)), this, SLOT(slotClickAndGoColorChanged(QRgb))); connect(m_cngWidget, SIGNAL(levelAndPresetChanged(uchar,QImage)), this, SLOT(slotClickAndGoLevelAndPresetChanged(uchar, QImage))); /* Bottom label */ m_bottomLabel = new QLabel(this); layout()->addWidget(m_bottomLabel); m_bottomLabel->setAlignment(Qt::AlignCenter); m_bottomLabel->setWordWrap(true); m_bottomLabel->hide(); setMinimumSize(20, 20); QSettings settings; QVariant var = settings.value(SETTINGS_SLIDER_SIZE); if (var.isValid() == true) resize(var.toSize()); else resize(VCSlider::defaultSize); /* Initialize to playback mode by default */ setInvertedAppearance(false); setSliderMode(Playback); /* Update the slider according to current mode */ slotModeChanged(mode()); /* Listen to fixture removals so that LevelChannels can be removed when they no longer point to an existing fixture->channel */ connect(m_doc, SIGNAL(fixtureRemoved(quint32)), this, SLOT(slotFixtureRemoved(quint32))); }
setTextRunAroundContour(KoShape::ContourBox); // Enable auto-resizing of chart labels foreach(KoShape *label, labels()) { TextLabelData *labelData = qobject_cast<TextLabelData*>(label->userData()); KoTextDocument doc(labelData->document()); //FIXME doc.setResizeMethod(KoTextDocument::AutoResize); } QSharedPointer<KoColorBackground> background(new KoColorBackground(Qt::white)); setBackground(background); KoShapeStroke *stroke = new KoShapeStroke(0, Qt::black); setStroke(stroke); ChartLayout *l = layout(); l->setPosition(d->plotArea, CenterPosition); l->setPosition(d->title, TopPosition, 0); l->setPosition(d->subTitle, TopPosition, 1); l->setPosition(d->footer, BottomPosition, 1); l->setPosition(d->legend, d->legend->legendPosition()); l->layout(); requestRepaint(); } ChartShape::~ChartShape() { delete d->title; delete d->subTitle; delete d->footer;
/*! Converts the log \a log to its textual representation and returns a QByteArray containing the data. */ QByteArray TLogger::logToByteArray(const TLog &log) const { return logToByteArray(log, layout(), dateTimeFormat(), codec_); }
void init() { /* subGrid holds global and * local SimulationSize and where the local SimArea is in the greater * scheme using Offsets from global LEFT, TOP, FRONT */ const SubGrid<DIM2>& subGrid = Environment<DIM2>::get().SubGrid(); /* The following sets up the local layout which consists of the actual * grid cells and some surrounding cells, called guards. * * ASCII Visualization: example taken for 1D, * distributed over 2 GPUs, only 1 border shown between those two GPUs * assuming non-periodic boundary conditions. * In a N-GPU or periodic example, border cells guard cells exist in each direction. * _______GPU 0________ _______GPU 1________ * | 0 | 1 | 2 | 3 | 4 | | 3 | 4 | 5 | 6 | 7 | <-- Global (super)cell idx * |___|___|___|___|___| |___|___|___|___|___| * |___Core____|Bor|Gua| |Gua|Bor|___Core____| * |___________|der|rd_| |rd_|der|___________| * |__"real" cells_|***| |***|__"real" cells_| * * |***| Clones cells which correspond to the border cells of the neighbor GPU * (sometimes also called "ghost" or "halo" cells/region) * * Recall that the following is defined: * typedef MappingDescription<DIM2, math::CT::Int<16,16> > MappingDesc; * where math::CT::Int<16,16> is arbitrarily(!) chosen SuperCellSize * and DIM2 is the dimension of the grid. * Expression of 2nd argument translates to DataSpace<DIM3>(16,16,0). * This is the guard size (here set to be one Supercell wide in all * directions). Meaning we have 16*16*(2*grid.x+2*grid.y+4) more * cells in GridLayout than in the SubGrid. * The formula above is SuperCellSize * TotalNumGuardCells with (in this case) * SuperCellSize = 16*16 (16 cells in 2 dimensions) * TotalNumGuardCells = 2 * grid.x (top and bottom) * + 2 * grid.y (left and right) * + 4 (the corners) */ GridLayout<DIM2> layout( subGrid.getLocalDomain().size, MappingDesc::SuperCellSize::toRT()); /* getDataSpace will return DataSpace( grid.x +16+16, grid.y +16+16) * * MappingDesc stores the layout regarding Core, Border and Guard * * in units of SuperCells. * * This is saved by init to be used by the kernel to identify itself. */ evo.init(layout.getDataSpace(), Space::create(1)); buff1 = new Buffer(layout, false); buff2 = new Buffer(layout, false); /* Set up the future data exchange. In this case we need to copy the * border cells of our neighbors to our guard cells, since we only read * from the guard cells but never write to it. * guardingCells holds the number of guard(super)cells in each dimension */ Space guardingCells(1, 1); for (uint32_t i = 1; i < traits::NumberOfExchanges<DIM2>::value; ++i) { /* to check which number corresponds to which direction, you can * * use the following member of class Mask like done in the two * * lines below: * * DataSpace<DIM2>relVec = Mask::getRelativeDirections<DIM2>(i); * * std::cout << "Direction:" << i << " => Vec: (" << relVec[0] * * << "," << relVec[1] << ")\n"; * * The result is: 1:right(1,0), 2:left(-1,0), 3:up(0,1), * * 4:up right(1,1), 5:(-1,1), 6:(0,-1), 7:(1,-1), 8:(-1,-1) */ /* types.hpp: enum CommunicationTags{ BUFF1 = 0u, BUFF2 = 1u }; */ buff1->addExchange(GUARD, Mask(i), guardingCells, BUFF1); buff2->addExchange(GUARD, Mask(i), guardingCells, BUFF2); } /* Both next lines are defined in GatherSlice.hpp: * * -gather saves the MessageHeader object * * -Then do an Allgather for the gloabalRanks from GC, sort out * * -inactive processes (second/boolean ,argument in gather.init) and* * save new MPI_COMMUNICATOR created from these into private var. * * -return if rank == 0 */ MessageHeader header(gridSize, layout, subGrid.getLocalDomain().offset); isMaster = gather.init(header, true); /* Calls kernel to initialize random generator. Game of Life is then * * initialized using uniform random numbers. With 10% (second arg) * * white points. World will be written to buffer in first argument */ evo.initEvolution(buff1->getDeviceBuffer().getDataBox(), 0.1); }
void Acceleration_Calibration_Wizard::prepare_step() { delete m_content; m_content = nullptr; if (m_step == Step::INTRO) { m_content = new QWidget(this); layout()->addWidget(m_content); Ui::Acceleration_Calibration_Wizard_Intro ui; ui.setupUi(m_content); ui.description->setText(q::util::format2<std::string>( "This wizard will calibrate the acceleration stream of node {}.\n" "It will ask you to hold the UAV still in various positions and will take about 1 minute.\n" "\n" "Ready?", m_node->name).c_str()); QObject::connect(ui.buttonBox, &QDialogButtonBox::accepted, [this]() { advance(); }); QObject::connect(ui.buttonBox, &QDialogButtonBox::rejected, [this]() { cancel(); }); } else if (m_step == Step::RESET) { m_content = new QWidget(this); layout()->addWidget(m_content); Ui::Acceleration_Calibration_Wizard_Reset ui; ui.setupUi(m_content); if (m_initial_calibration.points.size() > 0) { ui.info->setText(q::util::format2<std::string>("There are currently {} calibration points.\n" "Do you want to clear these points or keep them?", m_initial_calibration.points.size()).c_str()); auto* clear = ui.buttonBox->addButton("Clear", QDialogButtonBox::ResetRole); QObject::connect(clear, &QPushButton::released, [this]() { advance(); }); auto* keep = ui.buttonBox->addButton("Keep", QDialogButtonBox::AcceptRole); QObject::connect(keep, &QPushButton::released, [this]() { m_crt_calibration = m_initial_calibration; advance(); }); } else { ui.info->setText("There are no existing calibration data points.\nLet's add one"); auto* ok = ui.buttonBox->addButton("Keep", QDialogButtonBox::AcceptRole); QObject::connect(ok, &QPushButton::released, [this]() { advance(); }); } QObject::connect(ui.buttonBox, &QDialogButtonBox::rejected, [this]() { cancel(); }); } else if (m_step == Step::SHOW_INSTRUCTIONS) { static char const* direction[] = { "level", "on its LEFT side", "on its RIGHT side", "nose DOWN", "nose UP", "on its BACK", }; m_content = new QWidget(this); layout()->addWidget(m_content); Ui::Acceleration_Calibration_Wizard_Instructions ui; ui.setupUi(m_content); ui.instructions->setText(q::util::format2<std::string>( "Please place the UAV {} for {} seconds.\n" "\n" "Done?", direction[m_collect_data_step], DATA_COLLECTION_DURATION).c_str()); QObject::connect(ui.buttonBox, &QDialogButtonBox::accepted, [this]() { advance(); }); QObject::connect(ui.buttonBox, &QDialogButtonBox::rejected, [this]() { cancel(); }); } else if (m_step == Step::COLLECT) { m_content = new QWidget(this); layout()->addWidget(m_content); Ui::Acceleration_Calibration_Wizard_Collect ui; ui.setupUi(m_content); auto* info = ui.info; auto* progress = ui.progressBar; m_samples.clear(); QObject::connect(ui.buttonBox, &QDialogButtonBox::rejected, [this]() { cancel(); }); m_connection = m_stream->samples_available_signal.connect([this, info, progress](silk::stream::gs::Acceleration::Samples const& samples) { on_samples_received(samples); info->setText(q::util::format2<std::string>("Collected {} samples...", m_samples.size()).c_str()); size_t needed_samples = std::chrono::seconds(DATA_COLLECTION_DURATION).count() * m_output.rate; progress->setValue(float(m_samples.size() * 100.f) / float(needed_samples)); if (m_samples.size() >= needed_samples) { m_averages[m_collect_data_step].set(std::accumulate(m_samples.begin(), m_samples.end(), math::vec3f())); m_averages[m_collect_data_step] /= static_cast<double>(m_samples.size()); advance(); } }); } else if (m_step == Step::DONE) { math::vec3<double> bias, scale; compute_calibration_data(m_averages, bias, scale); m_content = new QWidget(this); layout()->addWidget(m_content); Ui::Acceleration_Calibration_Wizard_Done ui; ui.setupUi(m_content); ui.info->setText("Done!\n" "The new Bias & Scale are:"); ui.bias->setText(q::util::format2<std::string>("{}", bias).c_str()); ui.scale->setText(q::util::format2<std::string>("{}", scale).c_str()); sz::calibration::Acceleration point; point.temperature = 0; point.bias = math::vec3f(bias); point.scale = math::vec3f(scale); m_crt_calibration.points.push_back(point); QObject::connect(ui.temperature, static_cast<void (QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged), [this](double value) { m_crt_calibration.points.back().temperature = static_cast<float>(value); }); QObject::connect(ui.buttonBox, &QDialogButtonBox::accepted, [this]() { set_calibration_points(m_crt_calibration); this->accept(); }); QObject::connect(ui.buttonBox, &QDialogButtonBox::rejected, [this]() { cancel(); }); } }
static void drawTextCommon(GraphicsContext* ctx, const TextRun& run, const FloatPoint& point, int from, int to, const QFont& font, bool isComplexText) { if (to < 0) to = run.length(); QPainter *p = ctx->platformContext(); QPen textFillPen; if (ctx->textDrawingMode() & TextModeFill) { if (ctx->fillGradient()) { QBrush brush(*ctx->fillGradient()->platformGradient()); brush.setTransform(ctx->fillGradient()->gradientSpaceTransform()); textFillPen = QPen(brush, 0); } else if (ctx->fillPattern()) { AffineTransform affine; textFillPen = QPen(QBrush(ctx->fillPattern()->createPlatformPattern(affine)), 0); } else textFillPen = QPen(QColor(ctx->fillColor())); } QPen textStrokePen; if (ctx->textDrawingMode() & TextModeStroke) { if (ctx->strokeGradient()) { QBrush brush(*ctx->strokeGradient()->platformGradient()); brush.setTransform(ctx->strokeGradient()->gradientSpaceTransform()); textStrokePen = QPen(brush, ctx->strokeThickness()); } else if (ctx->strokePattern()) { AffineTransform affine; QBrush brush(ctx->strokePattern()->createPlatformPattern(affine)); textStrokePen = QPen(brush, ctx->strokeThickness()); } else textStrokePen = QPen(QColor(ctx->strokeColor()), ctx->strokeThickness()); } String sanitized = Font::normalizeSpaces(String(run.characters(), run.length())); QString string = fromRawDataWithoutRef(sanitized); QPointF pt(point.x(), point.y()); if (from > 0 || to < run.length()) { if (isComplexText) { QTextLayout layout(string, font); QTextLine line = setupLayout(&layout, run); float x1 = line.cursorToX(from); float x2 = line.cursorToX(to); if (x2 < x1) qSwap(x1, x2); QFontMetrics fm(font); int ascent = fm.ascent(); QRectF boundingRect(point.x() + x1, point.y() - ascent, x2 - x1, fm.height()); QRectF clip = boundingRect; ContextShadow* ctxShadow = ctx->contextShadow(); if (ctxShadow->m_type != ContextShadow::NoShadow) { qreal dx1 = 0, dx2 = 0, dy1 = 0, dy2 = 0; if (ctxShadow->offset().x() > 0) dx2 = ctxShadow->offset().x(); else dx1 = -ctxShadow->offset().x(); if (ctxShadow->offset().y() > 0) dy2 = ctxShadow->offset().y(); else dy1 = -ctxShadow->offset().y(); // expand the clip rect to include the text shadow as well clip.adjust(dx1, dx2, dy1, dy2); clip.adjust(-ctxShadow->m_blurDistance, -ctxShadow->m_blurDistance, ctxShadow->m_blurDistance, ctxShadow->m_blurDistance); } p->save(); p->setClipRect(clip.toRect(), Qt::IntersectClip); pt.setY(pt.y() - ascent); if (ctxShadow->m_type != ContextShadow::NoShadow) { ContextShadow* ctxShadow = ctx->contextShadow(); if (!ctxShadow->mustUseContextShadow(p)) { p->save(); p->setPen(ctxShadow->m_color); p->translate(ctxShadow->offset()); line.draw(p, pt); p->restore(); } else { QPainter* shadowPainter = ctxShadow->beginShadowLayer(p, boundingRect); if (shadowPainter) { // Since it will be blurred anyway, we don't care about render hints. shadowPainter->setFont(p->font()); shadowPainter->setPen(ctxShadow->m_color); line.draw(shadowPainter, pt); ctxShadow->endShadowLayer(p); } } } p->setPen(textFillPen); line.draw(p, pt); p->restore(); return; } #if QT_VERSION >= QT_VERSION_CHECK(4, 7, 0) int skipWidth = QFontMetrics(font).width(string, from, Qt::TextBypassShaping); pt.setX(pt.x() + skipWidth); string = fromRawDataWithoutRef(sanitized, from, to - from); #endif } p->setFont(font); int flags = run.rtl() ? Qt::TextForceRightToLeft : Qt::TextForceLeftToRight; #if QT_VERSION >= QT_VERSION_CHECK(4, 7, 0) // See QWebPagePrivate::QWebPagePrivate() where the default path is set to Complex for Qt 4.6 and earlier. if (!isComplexText && !(ctx->textDrawingMode() & TextModeStroke)) flags |= Qt::TextBypassShaping; #endif QPainterPath textStrokePath; if (ctx->textDrawingMode() & TextModeStroke) textStrokePath.addText(pt, font, string); ContextShadow* ctxShadow = ctx->contextShadow(); if (ctxShadow->m_type != ContextShadow::NoShadow) { if (ctx->textDrawingMode() & TextModeFill) { if (ctxShadow->m_type != ContextShadow::BlurShadow) { p->save(); p->setPen(ctxShadow->m_color); p->translate(ctxShadow->offset()); p->drawText(pt, string, flags, run.padding()); p->restore(); } else { QFontMetrics fm(font); #if QT_VERSION >= QT_VERSION_CHECK(4, 7, 0) QRectF boundingRect(pt.x(), point.y() - fm.ascent(), fm.width(string, -1, flags), fm.height()); #else QRectF boundingRect(pt.x(), point.y() - fm.ascent(), fm.width(string), fm.height()); #endif QPainter* shadowPainter = ctxShadow->beginShadowLayer(p, boundingRect); if (shadowPainter) { // Since it will be blurred anyway, we don't care about render hints. shadowPainter->setFont(p->font()); shadowPainter->setPen(ctxShadow->m_color); shadowPainter->drawText(pt, string, flags, run.padding()); ctxShadow->endShadowLayer(p); } } } else if (ctx->textDrawingMode() & TextModeStroke) { if (ctxShadow->m_type != ContextShadow::BlurShadow) { p->translate(ctxShadow->offset()); p->strokePath(textStrokePath, QPen(ctxShadow->m_color)); p->translate(-ctxShadow->offset()); } else { QFontMetrics fm(font); #if QT_VERSION >= QT_VERSION_CHECK(4, 7, 0) QRectF boundingRect(pt.x(), point.y() - fm.ascent(), fm.width(string, -1, flags), fm.height()); #else QRectF boundingRect(pt.x(), point.y() - fm.ascent(), fm.width(string), fm.height()); #endif QPainter* shadowPainter = ctxShadow->beginShadowLayer(p, boundingRect); if (shadowPainter) { // Since it will be blurred anyway, we don't care about render hints. shadowPainter->setFont(p->font()); shadowPainter->strokePath(textStrokePath, QPen(ctxShadow->m_color)); ctxShadow->endShadowLayer(p); } } } } if (ctx->textDrawingMode() & TextModeStroke) p->strokePath(textStrokePath, textStrokePen); if (ctx->textDrawingMode() & TextModeFill) { QPen previousPen = p->pen(); p->setPen(textFillPen); p->drawText(pt, string, flags, run.padding()); p->setPen(previousPen); } }
void GameWall::addGame(ChessGame* game) { Q_ASSERT(game != nullptr); QWidget* widget = new QWidget(this); ChessClock* clock[2] = { new ChessClock(), new ChessClock() }; QHBoxLayout* clockLayout = new QHBoxLayout(); for (int i = 0; i < 2; i++) { clock[i] = new ChessClock(); clockLayout->addWidget(clock[i]); Chess::Side side = Chess::Side::Type(i); clock[i]->setPlayerName(side.toString()); } clockLayout->insertSpacing(1, 20); BoardScene* scene = new BoardScene(); BoardView* view = new BoardView(scene); QVBoxLayout* mainLayout = new QVBoxLayout(); mainLayout->addLayout(clockLayout); mainLayout->addWidget(view); mainLayout->setContentsMargins(0, 0, 0, 0); widget->setLayout(mainLayout); layout()->addWidget(widget); game->lockThread(); connect(game, SIGNAL(fenChanged(QString)), scene, SLOT(setFenString(QString))); connect(game, SIGNAL(moveMade(Chess::GenericMove, QString, QString)), scene, SLOT(makeMove(Chess::GenericMove))); connect(game, SIGNAL(humanEnabled(bool)), view, SLOT(setEnabled(bool))); for (int i = 0; i < 2; i++) { ChessPlayer* player(game->player(Chess::Side::Type(i))); if (player->isHuman()) connect(scene, SIGNAL(humanMove(Chess::GenericMove, Chess::Side)), player, SLOT(onHumanMove(Chess::GenericMove, Chess::Side))); clock[i]->setPlayerName(player->name()); connect(player, SIGNAL(nameChanged(QString)), clock[i], SLOT(setPlayerName(QString))); clock[i]->setInfiniteTime(player->timeControl()->isInfinite()); if (player->state() == ChessPlayer::Thinking) clock[i]->start(player->timeControl()->activeTimeLeft()); else clock[i]->setTime(player->timeControl()->timeLeft()); connect(player, SIGNAL(startedThinking(int)), clock[i], SLOT(start(int))); connect(player, SIGNAL(stoppedThinking()), clock[i], SLOT(stop())); } scene->setBoard(game->pgn()->createBoard()); scene->populate(); foreach (const Chess::Move& move, game->moves()) scene->makeMove(move); game->unlockThread(); view->setEnabled(!game->isFinished() && game->playerToMove()->isHuman()); m_games[game] = widget; cleanupWidgets(); }
ChatPanel::ChatPanel(const QStringList &botNames, UsersColorsPool *colorsPool, TextEditorModifier *chatInputModifier, EmojiManager *emojiManager) : QWidget(nullptr), ui(new Ui::ChatPanel), emojiManager(emojiManager), botNames(botNames), autoTranslating(false), colorsPool(colorsPool), unreadedMessages(0), on(false) { ui->setupUi(this); QVBoxLayout *contentLayout = new QVBoxLayout(ui->scrollContent); contentLayout->setContentsMargins(0, 0, 0, 0); ui->scrollContent->setLayout(contentLayout); ui->topicLabel->setVisible(false); // disable blue border when QLineEdit has focus in mac ui->chatText->setAttribute(Qt::WA_MacShowFocusRect, 0); previousVerticalScrollBarMaxValue = ui->chatScroll->verticalScrollBar()->value(); emojiWidget = new EmojiWidget(emojiManager, this); emojiWidget->setVisible(false); qobject_cast<QVBoxLayout *>(layout())->insertWidget(layout()->count()-2, emojiWidget); emojiWidget->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::MinimumExpanding); auto emojiIcon = IconFactory::createChatEmojiIcon(Qt::black, on); emojiAction = ui->chatText->addAction(emojiIcon, QLineEdit::LeadingPosition); if (chatInputModifier) { bool finishEditorPressingReturnKey = false; chatInputModifier->modify(ui->chatText, finishEditorPressingReturnKey); } ui->scrollContent->installEventFilter(this); setupSignals(); instances.append(this); auto root = new QTreeWidgetItem(ui->treeWidget, QStringList()); root->setFirstColumnSpanned(true); // the root col span ui->treeWidget->addTopLevelItem(root); connect(ui->treeWidget, &QTreeWidget::collapsed, [=](){ ui->treeWidget->setMaximumHeight(20); }); connect(ui->treeWidget, &QTreeWidget::expanded, [=](){ auto root = ui->treeWidget->topLevelItem(0); Q_ASSERT(root); if (root->childCount() > 0) ui->treeWidget->setMaximumHeight(150); }); connect(ui->treeWidget, &QTreeWidget::clicked, [=](QModelIndex index){ auto root = ui->treeWidget->topLevelItem(0); Q_ASSERT(root); if (root->isExpanded()) ui->treeWidget->collapse(index); else ui->treeWidget->expand(index); }); ui->treeWidget->setMaximumHeight(20); ui->treeWidget->setVisible(false); ui->treeWidget->setContextMenuPolicy(Qt::CustomContextMenu); connect(ui->treeWidget, &QTreeWidget::customContextMenuRequested, this, &ChatPanel::showContextMenu); ui->buttonOnOff->setIcon(IconFactory::createChatOnOffIcon(Qt::black)); ui->buttonOnOff->setChecked(on); connect(ui->buttonOnOff, &QPushButton::toggled, this, &ChatPanel::toggleOnOff); updatePlaceHolderText(); updateEmojiIcon(); showConnectedUsersWidget(false); }
void Box::endEdit() { editMode = false; layout(); }
void Bracket::editDrag(const EditData& ed) { h2 += ed.delta.y() * .5; layout(); score()->setLayoutAll(false); }
void VBox::setGrip(int, const QPointF& pt) { setBoxHeight(Spatium(pt.y())); layout(); }
void CWizTitleBar::setContentsMargins(QMargins margins) { m_oldContentsMargin = margins; QWidget::setContentsMargins(margins); layout()->setContentsMargins(margins); }