void MusicRecommendFoundWidget::createLabels()
{
delete m_statusLabel;
m_statusLabel = nullptr;
initFirstWidget();
m_container->show();
layout()->removeWidget(m_mainWindow);
QScrollArea *scrollArea = new QScrollArea(this);
scrollArea->setStyleSheet(MusicUIObject::MScrollBarStyle01);
scrollArea->setWidgetResizable(true);
scrollArea->setFrameShape(QFrame::NoFrame);
scrollArea->setAlignment(Qt::AlignLeft);
scrollArea->setWidget(m_mainWindow);
layout()->addWidget(scrollArea);
QWidget *function = new QWidget(m_mainWindow);
function->setStyleSheet(MusicUIObject::MCheckBoxStyle01 + MusicUIObject::MPushButtonStyle03);
QVBoxLayout *grid = new QVBoxLayout(function);
QLabel *firstLabel = new QLabel(function);
firstLabel->setText(tr("<font color=#158FE1> Recommend Music</font>"));
grid->addWidget(firstLabel);
QLabel *iconLabel = new QLabel(function);
iconLabel->setPixmap(QPixmap(":/image/lb_recmd_daily"));
grid->addWidget(iconLabel);
////////////////////////////////////////////////////////////////////////////
grid->addWidget(m_container);
m_mainWindow->layout()->addWidget(function);
}
DownloadRegionDialog::DownloadRegionDialog( MarbleWidget *const widget, QWidget * const parent,
Qt::WindowFlags const f )
: QDialog( parent, f ),
d( new Private( widget, this ))
{
setWindowTitle( tr( "Download Region" ));
QVBoxLayout * const layout = new QVBoxLayout;
layout->addWidget( d->createSelectionMethodBox() );
layout->addWidget( d->m_tileLevelRangeWidget );
layout->addLayout( d->createTilesCounter() );
if ( MarbleGlobal::getInstance()->profiles() & MarbleGlobal::SmallScreen ) {
QWidget* widget = new QWidget( this );
widget->setLayout( layout );
QScrollArea* scrollArea = new QScrollArea( this );
scrollArea->setFrameShape( QFrame::NoFrame );
scrollArea->setWidget( widget );
QVBoxLayout * const mainLayout = new QVBoxLayout;
mainLayout->addWidget( scrollArea );
mainLayout->addWidget( d->createOkCancelButtonBox() );
setLayout( mainLayout );
} else {
layout->addWidget( d->createOkCancelButtonBox() );
setLayout( layout );
}
connect( d->m_latLonBoxWidget, SIGNAL(valueChanged()), SLOT(updateTilesCount()) );
connect( d->m_tileLevelRangeWidget, SIGNAL(topLevelChanged(int)),
SLOT(updateTilesCount()) );
connect( d->m_tileLevelRangeWidget, SIGNAL(bottomLevelChanged(int)),
SLOT(updateTilesCount()) );
connect( d->m_routeOffsetSpinBox, SIGNAL(valueChanged(double)), SLOT(updateTilesCount()) );
connect( d->m_routeOffsetSpinBox, SIGNAL(valueChanged(double)), SLOT(setOffsetUnit()) );
connect( d->m_model, SIGNAL(themeChanged(QString)), SLOT(updateTilesCount()) );
}
void EspressoPWscfConfig::setupElectrons () {
QWidget *ret = new QWidget;
QScrollArea *sa = new QScrollArea;
sa->setFrameShape(QFrame::NoFrame);
QFormLayout *layout = new QFormLayout;
QWidget *editor = 0;
editor = new QSpinBox; editor->setObjectName("electron_maxstep"); layout->addRow("electron_maxstep", editor);
editor = boolCombo(); editor->setObjectName("scf_must_converge"); layout->addRow("scf_must_converge", editor);
editor = new QDoubleSpinBox; editor->setObjectName("conv_thr"); layout->addRow("conv_thr", editor);
editor = boolCombo(); editor->setObjectName("adaptive_thr"); layout->addRow("adaptive_thr", editor);
editor = new QDoubleSpinBox; editor->setObjectName("conv_thr_init"); layout->addRow("conv_thr_init", editor);
editor = new QDoubleSpinBox; editor->setObjectName("conv_thr_multi"); layout->addRow("conv_thr_multi", editor);
editor = new QLineEdit; editor->setObjectName("mixing_mode"); layout->addRow("mixing_mode", editor);
editor = new QDoubleSpinBox; editor->setObjectName("mixing_beta"); layout->addRow("mixing_beta", editor);
editor = new QSpinBox; editor->setObjectName("mixing_ndim"); layout->addRow("mixing_ndim", editor);
editor = new QSpinBox; editor->setObjectName("mixing_fixed_ns"); layout->addRow("mixing_fixed_ns", editor);
editor = new QLineEdit; editor->setObjectName("diagonalization"); layout->addRow("diagonalization", editor);
editor = new QDoubleSpinBox; editor->setObjectName("diago_thr_init"); layout->addRow("diago_thr_init", editor);
editor = new QSpinBox; editor->setObjectName("diago_cg_maxiter"); layout->addRow("diago_cg_maxiter", editor);
editor = new QSpinBox; editor->setObjectName("diago_david_ndim"); layout->addRow("diago_david_ndim", editor);
editor = boolCombo(); editor->setObjectName("diago_full_acc"); layout->addRow("diago_full_acc", editor);
editor = new QDoubleSpinBox; editor->setObjectName("efield"); layout->addRow("efield", editor);
editor = new QDoubleSpinBox; editor->setObjectName("efield_cart(i),i=1,3"); layout->addRow("efield_cart(i),i=1,3", editor);
editor = new QLineEdit; editor->setObjectName("startingpot"); layout->addRow("startingpot", editor);
editor = new QLineEdit; editor->setObjectName("startingwfc"); layout->addRow("startingwfc", editor);
ret->setLayout(layout);
sa->setWidget(ret);
m_electronsWidget = sa;
}
void TwitterApiShowThread::setupUi()
{
kDebug();
QVBoxLayout *gridLayout;
QScrollArea *scrollArea;
QWidget *scrollAreaWidgetContents;
QVBoxLayout *verticalLayout_2;
QSpacerItem *verticalSpacer;
gridLayout = new QVBoxLayout(this);
gridLayout->setMargin(0);
gridLayout->setObjectName("gridLayout");
scrollArea = new QScrollArea(this);
scrollArea->setObjectName("scrollArea");
scrollArea->setFrameShape(QFrame::NoFrame);
scrollArea->setWidgetResizable(true);
scrollAreaWidgetContents = new QWidget();
scrollAreaWidgetContents->setObjectName("scrollAreaWidgetContents");
scrollAreaWidgetContents->setGeometry(QRect(0, 0, 254, 300));
verticalLayout_2 = new QVBoxLayout(scrollAreaWidgetContents);
verticalLayout_2->setMargin(1);
d->mainLayout = new QVBoxLayout();
verticalSpacer = new QSpacerItem(20, 40, QSizePolicy::Minimum, QSizePolicy::Expanding);
d->mainLayout->addItem(verticalSpacer);
d->mainLayout->setSpacing(3);
d->mainLayout->setMargin(1);
verticalLayout_2->addLayout(d->mainLayout);
scrollArea->setWidget(scrollAreaWidgetContents);
gridLayout->addWidget(scrollArea);
}
void EspressoPWscfConfig::setupControl () {
QWidget *ret = new QWidget;
QScrollArea *sa = new QScrollArea;
sa->setFrameShape(QFrame::NoFrame);
QFormLayout *layout = new QFormLayout;
QWidget *editor = 0;
editor = new QLineEdit; editor->setObjectName("calculation"); layout->addRow("calculation", editor);
editor = new QLineEdit; editor->setObjectName("title"); layout->addRow("title", editor);
editor = new QLineEdit; editor->setObjectName("verbosity"); layout->addRow("verbosity", editor);
editor = new QLineEdit; editor->setObjectName("restart_mode"); layout->addRow("restart_mode", editor);
editor = boolCombo(); editor->setObjectName("wf_collect"); layout->addRow("wf_collect", editor);
editor = new QSpinBox; editor->setObjectName("nstep"); layout->addRow("nstep", editor);
editor = new QSpinBox; editor->setObjectName("iprint"); layout->addRow("iprint", editor);
editor = boolCombo(); editor->setObjectName("tstress"); layout->addRow("tstress", editor);
editor = boolCombo(); editor->setObjectName("tprnfor"); layout->addRow("tprnfor", editor);
editor = new QDoubleSpinBox; editor->setObjectName("dt"); layout->addRow("dt", editor);
editor = new QLineEdit; editor->setObjectName("outdir"); layout->addRow("outdir", editor);
editor = new QLineEdit; editor->setObjectName("wfcdir"); layout->addRow("wfcdir", editor);
editor = new QLineEdit; editor->setObjectName("prefix"); layout->addRow("prefix", editor);
editor = boolCombo(); editor->setObjectName("lkpoint_dir"); layout->addRow("lkpoint_dir", editor);
editor = new QDoubleSpinBox; editor->setObjectName("max_seconds"); layout->addRow("max_seconds", editor);
editor = new QDoubleSpinBox; editor->setObjectName("etot_conv_thr"); layout->addRow("etot_conv_thr", editor);
editor = new QDoubleSpinBox; editor->setObjectName("forc_conv_thr"); layout->addRow("forc_conv_thr", editor);
editor = new QLineEdit; editor->setObjectName("disk_io"); layout->addRow("disk_io", editor);
editor = new QLineEdit; editor->setObjectName("pseudo_dir"); layout->addRow("pseudo_dir", editor);
editor = boolCombo(); editor->setObjectName("tefield"); layout->addRow("tefield", editor);
editor = boolCombo(); editor->setObjectName("dipfield"); layout->addRow("dipfield", editor);
editor = boolCombo(); editor->setObjectName("lelfield"); layout->addRow("lelfield", editor);
editor = new QSpinBox; editor->setObjectName("nberrycyc"); layout->addRow("nberrycyc", editor);
editor = boolCombo(); editor->setObjectName("lberry"); layout->addRow("lberry", editor);
editor = new QSpinBox; editor->setObjectName("gdir"); layout->addRow("gdir", editor);
ret->setLayout(layout);
sa->setWidget(ret);
m_controlWidget = sa;
}
void DlgPreferencesImp::resizeEvent(QResizeEvent* ev)
{
if (canEmbedScrollArea) {
// embed the widget stack into a scroll area if the size is
// bigger than the available desktop
QRect rect = QApplication::desktop()->availableGeometry();
int maxHeight = rect.height();
int maxWidth = rect.width();
if (height() > maxHeight || width() > maxWidth) {
canEmbedScrollArea = false;
ui->hboxLayout->removeWidget(ui->tabWidgetStack);
QScrollArea* scrollArea = new QScrollArea(this);
scrollArea->setFrameShape(QFrame::NoFrame);
scrollArea->setWidgetResizable(true);
scrollArea->setWidget(ui->tabWidgetStack);
ui->hboxLayout->addWidget(scrollArea);
// if possible the minimum width should so that it doesn't show
// a horizontal scroll bar.
QScrollBar* bar = scrollArea->verticalScrollBar();
if (bar) {
int newWidth = width() + bar->width();
newWidth = std::min<int>(newWidth, maxWidth);
int newHeight = std::min<int>(height(), maxHeight-30);
QMetaObject::invokeMethod(this, "resizeWindow",
Qt::QueuedConnection,
QGenericReturnArgument(),
Q_ARG(int, newWidth),
Q_ARG(int, newHeight));
}
}
}
void QmitkFunctionality::CreatePartControl(void* parent)
{
// scrollArea
QScrollArea* scrollArea = new QScrollArea;
//QVBoxLayout* scrollAreaLayout = new QVBoxLayout(scrollArea);
scrollArea->setFrameShadow(QFrame::Plain);
scrollArea->setFrameShape(QFrame::NoFrame);
scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
scrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
// m_Parent
m_Parent = new QWidget;
//m_Parent->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding));
this->CreateQtPartControl(m_Parent);
//scrollAreaLayout->addWidget(m_Parent);
//scrollArea->setLayout(scrollAreaLayout);
// set the widget now
scrollArea->setWidgetResizable(true);
scrollArea->setWidget(m_Parent);
// add the scroll area to the real parent (the view tabbar)
QWidget* parentQWidget = static_cast<QWidget*>(parent);
QVBoxLayout* parentLayout = new QVBoxLayout(parentQWidget);
parentLayout->setMargin(0);
parentLayout->setSpacing(0);
parentLayout->addWidget(scrollArea);
// finally set the layout containing the scroll area to the parent widget (= show it)
parentQWidget->setLayout(parentLayout);
this->AfterCreateQtPartControl();
}
void SettingsDialog::AddPage(Page id, SettingsPage* page) {
// Connect page's signals to the settings dialog's signals
connect(page, SIGNAL(NotificationPreview(OSD::Behaviour,QString,QString)),
SIGNAL(NotificationPreview(OSD::Behaviour,QString,QString)));
connect(page, SIGNAL(SetWiimotedevInterfaceActived(bool)),
SIGNAL(SetWiimotedevInterfaceActived(bool)));
// Create the list item
QListWidgetItem* item = new QListWidgetItem(page->windowIcon(),
page->windowTitle());
ui_->list->addItem(item);
if (!page->IsEnabled()) {
item->setFlags(Qt::NoItemFlags);
}
// Create a scroll area containing the page
QScrollArea* area = new QScrollArea;
area->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
area->setWidget(page);
area->setWidgetResizable(true);
area->setFrameShape(QFrame::NoFrame);
area->setMinimumWidth(page->layout()->minimumSize().width());
// Add the page to the stack
ui_->stacked_widget->addWidget(area);
// Remember where the page is
PageData data;
data.index_ = ui_->list->row(item);
data.scroll_area_ = area;
data.page_ = page;
pages_[id] = data;
}
DocumentTypeSelectionPage::DocumentTypeSelectionPage(QWidget* parent) : QWizardPage(parent)
{
QVBoxLayout *vb = new QVBoxLayout;
QScrollArea *scroll = new QScrollArea;
scroll->setWidgetResizable(true);
scroll->setFocusPolicy(Qt::NoFocus);
scroll->setFrameShape(QFrame::NoFrame);
scroll->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
m_ui = new Ui::DocumentTypeSelector;
m_ui->setupUi(scroll);
vb->addWidget(scroll);
setLayout(vb);
registerField("documentsTypeSelectionPage_minimumSize", m_ui->minimumSize);
registerField("documentsTypeSelectionPage_allLocations", m_ui->allLocations, "checked");
registerField("documentsTypeSelectionPage_location", m_ui->location, "installationPath");
registerField("documentsTypeSelectionPage_allDocuments", m_ui->allDocuments);
registerField("documentsTypeSelectionPage_audioDocuments", m_ui->audioDocuments);
registerField("documentsTypeSelectionPage_imageDocuments", m_ui->imageDocuments);
registerField("documentsTypeSelectionPage_textDocuments", m_ui->textDocuments);
registerField("documentsTypeSelectionPage_videoDocuments", m_ui->videoDocuments);
connect(m_ui->allDocuments, SIGNAL(clicked(bool)), this, SLOT(alltypes(bool)));
connect(m_ui->allDocuments, SIGNAL(clicked()), this, SIGNAL(completeChanged()));
connect(m_ui->audioDocuments, SIGNAL(clicked()), this, SIGNAL(completeChanged()));
connect(m_ui->imageDocuments, SIGNAL(clicked()), this, SIGNAL(completeChanged()));
connect(m_ui->textDocuments, SIGNAL(clicked()), this, SIGNAL(completeChanged()));
connect(m_ui->videoDocuments, SIGNAL(clicked()), this, SIGNAL(completeChanged()));
}
MusicWebDJRadioCategoryWidget::MusicWebDJRadioCategoryWidget(QWidget *parent)
: QWidget(parent)
{
QHBoxLayout *layout = new QHBoxLayout(this);
layout->setSpacing(0);
layout->setContentsMargins(0, 0, 0, 0);
setLayout(layout);
QWidget *mainWindow = new QWidget(this);
QScrollArea *scrollArea = new QScrollArea(this);
scrollArea->verticalScrollBar()->setStyleSheet(MusicUIObject::MScrollBarStyle01);
scrollArea->setWidgetResizable(true);
scrollArea->setFrameShape(QFrame::NoFrame);
scrollArea->setAlignment(Qt::AlignLeft);
scrollArea->setWidget(mainWindow);
layout->addWidget(scrollArea);
m_gridLayout = new QGridLayout(mainWindow);
m_gridLayout->setVerticalSpacing(35);
mainWindow->setLayout(m_gridLayout);
m_categoryThread = new MusicDJRadioCategoryThread(this);
connect(m_categoryThread, SIGNAL(downLoadDataChanged(QString)), SLOT(createCategoryItems()));
}
void SettingsDialog::AddPage(Page id, SettingsPage* page) {
// Create the list item
QListWidgetItem* item = new QListWidgetItem(page->windowIcon(),
page->windowTitle());
ui_->list->addItem(item);
if (!page->IsEnabled()) {
item->setFlags(Qt::NoItemFlags);
}
// Create a scroll area containing the page
QScrollArea* area = new QScrollArea;
area->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
area->setWidget(page);
area->setWidgetResizable(true);
area->setFrameShape(QFrame::NoFrame);
area->setMinimumWidth(page->layout()->minimumSize().width());
// Add the page to the stack
ui_->stacked_widget->addWidget(area);
// Remember where the page is
PageData data;
data.index_ = ui_->list->row(item);
data.scroll_area_ = area;
data.page_ = page;
pages_[id] = data;
}
void MusicPlaylistFoundWidget::createPlaylistItem(const MusicResultsItem &item)
{
if(!m_firstInit)
{
delete m_statusLabel;
m_statusLabel = nullptr;
m_container->removeWidget(m_mainWindow);
QScrollArea *scrollArea = new QScrollArea(this);
scrollArea->setStyleSheet(MusicUIObject::MScrollBarStyle01);
scrollArea->setWidgetResizable(true);
scrollArea->setFrameShape(QFrame::NoFrame);
scrollArea->setAlignment(Qt::AlignLeft);
scrollArea->setWidget(m_mainWindow);
m_container->addWidget(scrollArea);
m_firstInit = true;
QHBoxLayout *mainlayout = MStatic_cast(QHBoxLayout*, m_mainWindow->layout());
QWidget *containTopWidget = new QWidget(m_mainWindow);
QHBoxLayout *containTopLayout = new QHBoxLayout(containTopWidget);
containTopLayout->setContentsMargins(30, 0, 30, 0);
m_categoryButton = new MusicPlaylistFoundCategoryPopWidget(m_mainWindow);
m_categoryButton->setCategory(m_downloadThread->getQueryServer(), this);
containTopLayout->addWidget(m_categoryButton);
containTopLayout->addStretch(1);
foreach(const QString &data, QStringList() << tr("Recommend") << tr("Top") << tr("Hot") << tr("New"))
{
QLabel *l = new QLabel(data, containTopWidget);
l->setStyleSheet(QString("QLabel::hover{%1}").arg(MusicUIObject::MColorStyle08));
QFrame *hline = new QFrame(containTopWidget);
hline->setFrameShape(QFrame::VLine);
hline->setStyleSheet(MusicUIObject::MColorStyle06);
containTopLayout->addWidget(l);
containTopLayout->addWidget(hline);
}
containTopWidget->setLayout(containTopLayout);
QFrame *line = new QFrame(m_mainWindow);
line->setFrameShape(QFrame::HLine);
line->setStyleSheet(MusicUIObject::MColorStyle06);
QWidget *containWidget = new QWidget(m_mainWindow);
m_gridLayout = new QGridLayout(containWidget);
m_gridLayout->setVerticalSpacing(35);
containWidget->setLayout(m_gridLayout);
mainlayout->addWidget(containTopWidget);
mainlayout->addWidget(line);
mainlayout->addWidget(containWidget);
m_pagingWidgetObject = new MusicPagingWidgetObject(m_mainWindow);
connect(m_pagingWidgetObject, SIGNAL(mapped(int)), SLOT(buttonClicked(int)));
int total = ceil(m_downloadThread->getPageTotal()*1.0/m_downloadThread->getPageSize());
mainlayout->addWidget(m_pagingWidgetObject->createPagingWidget(m_mainWindow, total));
mainlayout->addStretch(1);
}
//-----------------------------------------------------------------------------
// Function: AddressSpaceEditor::setupLayout()
//-----------------------------------------------------------------------------
void AddressSpaceEditor::setupLayout()
{
QScrollArea* scrollArea = new QScrollArea(this);
scrollArea->setWidgetResizable(true);
scrollArea->setFrameShape(QFrame::NoFrame);
QVBoxLayout* scrollLayout = new QVBoxLayout(this);
scrollLayout->addWidget(scrollArea);
scrollLayout->setContentsMargins(0, 0, 0, 0);
QWidget* topWidget = new QWidget(scrollArea);
topWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
QVBoxLayout* topLayout = new QVBoxLayout(topWidget);
QHBoxLayout* nameAndGeneralLayout = new QHBoxLayout();
nameAndGeneralLayout->addWidget(&nameEditor_, 0, Qt::AlignTop);
nameAndGeneralLayout->addWidget(&generalEditor_);
topLayout->addLayout(nameAndGeneralLayout);
topLayout->addWidget(&segmentsEditor_, 1);
topLayout->setContentsMargins(0, 0, 0, 0);
QWidget* bottomWidget = new QWidget(scrollArea);
bottomWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
QVBoxLayout* bottomLayout = new QVBoxLayout(bottomWidget);
bottomLayout->addWidget(&localMemMapEditor_);
bottomLayout->setContentsMargins(0, 0, 0, 0);
QSplitter* verticalSplitter = new QSplitter(Qt::Vertical, scrollArea);
verticalSplitter->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
verticalSplitter->addWidget(topWidget);
verticalSplitter->addWidget(bottomWidget);
verticalSplitter->setStretchFactor(1, 1);
QSplitterHandle* handle = verticalSplitter->handle(1);
QVBoxLayout* handleLayout = new QVBoxLayout(handle);
handleLayout->setSpacing(0);
handleLayout->setMargin(0);
QFrame* line = new QFrame(handle);
line->setLineWidth(2);
line->setMidLineWidth(2);
line->setFrameShape(QFrame::HLine);
line->setFrameShadow(QFrame::Sunken);
handleLayout->addWidget(line);
verticalSplitter->setHandleWidth(10);
scrollArea->setWidget(verticalSplitter);
}
void DenoisingWidget::on_pbPrepare_clicked()
{
// prepare widget
cleanWidget();
QLayout *layout;
if (Constants::showThresholdsWidgetSeparately) {
QScrollArea* scrollArea = new QScrollArea();
scrollArea->setBackgroundRole(QPalette::Window);
scrollArea->setFrameShadow(QFrame::Plain);
scrollArea->setFrameShape(QFrame::NoFrame);
scrollArea->setWidgetResizable(true);
QWidget* wdg = new QWidget();
wdg->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
wdg->setLayout(new QVBoxLayout(wdg));
scrollArea->setWidget(wdg);
scrollArea->show();
layout = wdg->layout();
} else {
if (!ui->scrollAreaWidgetContents->layout()) {
ui->scrollAreaWidgetContents->setLayout(new QVBoxLayout());
}
layout = ui->scrollAreaWidgetContents->layout();
}
// prepare signal (wavelet transform)
m_denoisingManager->setSignal(*m_noisedAudioSignal.data());
m_denoisingManager->prepareToDenoising(ui->cbWaveletType->currentText(), ui->sbLevel->value());
PlotManager::plot(ui->inputTransformedSignalWidget, m_denoisingManager->transformedSignal());
auto decomposition = m_denoisingManager->transformedDecomposition();
m_itemsCount = decomposition.size();
// initialize thresholds widgets
for (auto item : decomposition) {
auto wdg = new ThresholdsWidget(this);
m_widgets.push_back(wdg);
wdg->setSignalSource(item);
layout->addWidget(wdg);
}
Q_ASSERT(m_itemsCount == m_widgets.size());
}
QWidget *TilesetItemBox::makeCategory(const QString &categoryItem)
{
QTabWidget *TileSetsCategories = ui->TileSetsCategories;
QWidget *catWid;
QWidget *scrollWid;
QGridLayout *catLayout;
QLabel *grpLabel;
QComboBox *tilesetGroup;
QSpacerItem *spItem;
QScrollArea *TileSets;
FlowLayout *theLayOut;
catWid = new QWidget();
scrollWid = new QWidget();
catLayout = new QGridLayout(catWid);
catLayout->setSpacing(0);
catLayout->setContentsMargins(0, 0, 0, 0);
grpLabel = new QLabel(catWid);
grpLabel->setText(tr("Group:"));
catLayout->addWidget(grpLabel, 0, 0, 1, 1);
tilesetGroup = new QComboBox(catWid);
catLayout->addWidget(tilesetGroup, 0, 1, 1, 1);
tilesetGroup->setInsertPolicy(QComboBox::InsertAlphabetically);
spItem = new QSpacerItem(1283, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
catLayout->addItem(spItem, 0, 2, 1, 1);
TileSets = new QScrollArea(catWid);
TileSets->setWidget(scrollWid);
TileSets->setWidgetResizable(true);
TileSets->setFrameShape(QFrame::StyledPanel);
TileSets->setFrameShadow(QFrame::Raised);
TileSets->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
TileSets->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
theLayOut = new FlowLayout(scrollWid);
theLayOut->setSizeConstraint(QLayout::SetNoConstraint);
catLayout->addWidget(TileSets, 1, 0, 1, 3);
TileSetsCategories->addTab(catWid, QString());
TileSetsCategories->setTabText(TileSetsCategories->indexOf(catWid), categoryItem);
return catWid;
}
QTransferFunctionEditorByValues::QTransferFunctionEditorByValues(QWidget *parent)
: QTransferFunctionEditor(parent)
{
setupUi(this);
// Creem una scroll area per si hi ha molts intervals (no es pot crear des del Qt Designer)
QScrollArea *scrollArea = new QScrollArea(this);
qobject_cast<QBoxLayout*>(this->layout())->insertWidget(1, scrollArea);
m_intervalEditorsWidget = new QWidget(scrollArea);
QBoxLayout *layout = new QVBoxLayout(m_intervalEditorsWidget);
m_intervalEditorsLayout = new QVBoxLayout();
layout->addLayout(m_intervalEditorsLayout);
layout->addStretch();
layout->setMargin(0);
scrollArea->setWidget(m_intervalEditorsWidget);
scrollArea->setWidgetResizable(true);
scrollArea->setFrameShape(QFrame::NoFrame);
// Creem el primer interval
QTransferFunctionIntervalEditor *first = new QTransferFunctionIntervalEditor(m_intervalEditorsWidget);
first->setIsFirst(true);
first->setIsLast(true);
first->setObjectName("interval0");
m_intervalEditorsLayout->addWidget(first);
connect(first, SIGNAL(startChanged(int)), SLOT(markAsChanged()));
connect(first, SIGNAL(endChanged(int)), SLOT(markAsChanged()));
connect(first, SIGNAL(colorChanged(const QColor&)), SLOT(markAsChanged()));
// Mida mínima de la scroll area
QStyle *style = scrollArea->style();
int scrollBarWidth = style->pixelMetric(QStyle::PM_ScrollBarExtent);
scrollArea->setMinimumWidth(first->minimumSizeHint().width() + scrollBarWidth);
m_numberOfIntervals = 1;
m_changed = true;
connect(m_addPushButton, SIGNAL(clicked()), SLOT(addInterval()));
connect(m_removePushButton, SIGNAL(clicked()), SLOT(removeInterval()));
connect(m_nameLineEdit, SIGNAL(textChanged(const QString&)), SLOT(markAsChanged()));
}
KSaneDeviceDialog::KSaneDeviceDialog(QWidget *parent)
: KDialog(parent)
{
setButtons(KDialog::User1 | KDialog::Ok | KDialog::Cancel);
setButtonText(User1, i18n("Reload devices list"));
m_btnGroup = new QButtonGroup(this);
m_btnBox = new QGroupBox;
QVBoxLayout *layout = new QVBoxLayout;
m_btnContainer = new QWidget;
m_btnLayout = new QVBoxLayout(m_btnContainer);
QScrollArea *area = new QScrollArea;
m_btnBox->setLayout(layout);
QLabel *explanation =
new QLabel(i18n("<html>The SANE (Scanner Access Now Easy) system could not find any device.<br>"
"Check that the scanner is plugged in and turned on<br>"
"or check your systems scanner setup.<br>"
"For details about SANE see the "
"<a href='http://www.sane-project.org/'>SANE homepage</a>.</html>"));
explanation->setOpenExternalLinks(true);
int l,t,r,b;
layout->getContentsMargins(&l, &t, &r, &b);
explanation->setContentsMargins(l, t, r, b);
layout->addWidget(explanation);
m_btnBox->adjustSize(); // make sure to see the complete explanation text
layout->addWidget(area);
layout->setContentsMargins(0,0,0,0);
area->setWidgetResizable(true);
area->setFrameShape(QFrame::NoFrame);
area->setWidget(m_btnContainer);
setMainWidget(m_btnBox);
setMinimumHeight(200);
m_findDevThread = FindSaneDevicesThread::getInstance();
connect(m_findDevThread, SIGNAL(finished()), this, SLOT(updateDevicesList()));
connect(this, SIGNAL(user1Clicked()), this, SLOT(reloadDevicesList()));
reloadDevicesList();
}
void DeviceDetailView::preparePersistUiElements()
{
QVBoxLayout *layout = new QVBoxLayout(this);
layout->setSpacing(15);
m_proPanel = new DetailViewContentWidget(this);
m_proPanel->setFocusPolicy(Qt::NoFocus);
m_modifyApplyBtn = new QPushButton(this);
m_modifyApplyBtn->setAutoDefault(true);
#ifdef BLOCK_DEVICE
m_blockDeviceBtn = new QPushButton(this);
connect(m_blockDeviceBtn,SIGNAL(clicked()),this,SLOT(btnClicked()));
m_blockDeviceBtn->setAutoDefault(true);
#endif
m_closeBtn = new QPushButton(this);
m_closeBtn->setAutoDefault(true);
connect(m_modifyApplyBtn,SIGNAL(clicked()),this,SLOT(btnClicked()));
connect(m_closeBtn,SIGNAL(clicked()),this,SLOT(btnClicked()));
m_btnsLayout = new QHBoxLayout();
m_btnsLayout->setSpacing(20);
m_btnsLayout->addStretch(1);
m_btnsLayout->addWidget(m_modifyApplyBtn);
#ifdef BLOCK_DEVICE
m_btnsLayout->addWidget(m_blockDeviceBtn);
#endif
m_btnsLayout->addWidget(m_closeBtn);
m_btnsLayout->addStretch(1);
QScrollArea *scrollArea = new QScrollArea(this);
scrollArea->setFocusPolicy(Qt::NoFocus);
scrollArea->setWidget(m_proPanel);
scrollArea->setWidgetResizable(true);
scrollArea->setFrameShadow(QFrame::Plain);
scrollArea->setFrameShape(QFrame::NoFrame);
layout->addWidget(scrollArea);
layout->addLayout(m_btnsLayout);
}
TrackInfoWidget::TrackInfoWidget( const Tomahawk::query_ptr& query, QWidget* parent )
: QWidget( parent )
, ui( new Ui::TrackInfoWidget )
{
QWidget* widget = new QWidget;
m_headerWidget = new BasicHeader;
ui->setupUi( widget );
m_pixmap = TomahawkUtils::defaultPixmap( TomahawkUtils::DefaultTrackImage, TomahawkUtils::Original, QSize( 48, 48 ) );
m_relatedTracksModel = new PlayableModel( ui->trackView );
ui->trackView->trackView()->setPlayableModel( m_relatedTracksModel );
ui->trackView->setCaption( tr( "Similar Tracks" ) );
ui->trackView->setEmptyTip( tr( "Sorry, but we could not find similar tracks for this song!" ) );
ui->topHits->setStyleSheet( QString( "QListView { background-color: #f9f9f9; }" ) );
TomahawkStyle::stylePageFrame( ui->trackFrame );
ui->topHits->setVisible( false );
ui->topHitsLabel->setVisible( false );
{
QScrollArea* area = new QScrollArea();
area->setWidgetResizable( true );
area->setVerticalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
area->setWidget( widget );
QPalette pal = palette();
pal.setBrush( backgroundRole(), Qt::white );
area->setPalette( pal );
area->setAutoFillBackground( true );
area->setFrameShape( QFrame::NoFrame );
area->setAttribute( Qt::WA_MacShowFocusRect, 0 );
QVBoxLayout* layout = new QVBoxLayout();
layout->addWidget( m_headerWidget );
layout->addWidget( area );
setLayout( layout );
TomahawkUtils::unmarginLayout( layout );
}
load( query );
}
QWidget *StartWidget::createPluginsList()
{
QWidget * const circleWidget = new CircleWidget(QSize(70, 70), ":/mainWindow/images/startTab/new.svg");
circleWidget->setStyleSheet(BrandManager::styles()->startTabButtonStyle());
QVBoxLayout * const innerLayout = new QVBoxLayout;
innerLayout->addStretch();
foreach (const Id &editor, mMainWindow->editorManager().editors()) {
const Id editorTmpId = Id::loadFromString("qrm:/" + editor.editor());
foreach (const Id &diagram, mMainWindow->editorManager().diagrams(editorTmpId)) {
QWidget * const pluginWidget = createPluginButton(editor, diagram, circleWidget);
innerLayout->addWidget(pluginWidget);
}
}
innerLayout->addStretch();
innerLayout->setContentsMargins(0, 0, 0, 0);
innerLayout->setMargin(0);
innerLayout->setSpacing(0);
QWidget *innerWidget = new QWidget;
innerWidget->setLayout(innerLayout);
QScrollArea *scrollArea = new QScrollArea;
scrollArea->setFrameShape(QFrame::NoFrame);
scrollArea->setWidgetResizable(true);
scrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
scrollArea->setWidget(innerWidget);
QHBoxLayout * const mainLayout = new QHBoxLayout;
mainLayout->addWidget(circleWidget, Qt::AlignCenter);
mainLayout->addWidget(scrollArea);
mainLayout->setStretch(0, 0);
mainLayout->setStretch(1, 10);
mainLayout->setMargin(0);
QWidget * const result = new QWidget;
result->setLayout(mainLayout);
return result;
}
void SettingsTab::addPage(SettingsPage *page)
{
if (!page)
return;
if (m_ids.contains(page->id()))
return;
QListWidgetItem *item = new QListWidgetItem(page->icon(), page->name(), m_contents);
m_items.append(item);
m_ids.append(page->id());
QScrollArea *scroll = new QScrollArea(this);
scroll->setWidget(page);
scroll->setWidgetResizable(true);
scroll->setFrameShape(QFrame::NoFrame);
m_pages->addWidget(scroll);
SettingsTabHook::add(page);
}
void PrettyImage::ShowFullsize() {
// Work out how large to make the window, based on the size of the screen
QRect desktop_rect(QApplication::desktop()->availableGeometry(this));
QSize window_size(qMin(desktop_rect.width() - 20, image_.width()),
qMin(desktop_rect.height() - 20, image_.height()));
// Create the window
QScrollArea* window = new QScrollArea;
window->setAttribute(Qt::WA_DeleteOnClose, true);
window->setWindowTitle(tr("Clementine image viewer"));
window->resize(window_size);
// Create the label that displays the image
QLabel* label = new QLabel(window);
label->setPixmap(QPixmap::fromImage(image_));
// Show the label in the window
window->setWidget(label);
window->setFrameShape(QFrame::NoFrame);
window->show();
}
ArtistInfoWidget::ArtistInfoWidget( const Tomahawk::artist_ptr& artist, QWidget* parent )
: QWidget( parent )
, ui( new Ui::ArtistInfoWidget )
, m_artist( artist )
{
QWidget* widget = new QWidget;
ui->setupUi( widget );
QPalette pal = palette();
pal.setColor( QPalette::Window, QColor( "#393840" ) );
widget->setPalette( pal );
widget->setAutoFillBackground( true );
/* TomahawkUtils::unmarginLayout( ui->layoutWidget->layout() );
TomahawkUtils::unmarginLayout( ui->layoutWidget1->layout() );
TomahawkUtils::unmarginLayout( ui->layoutWidget2->layout() );
TomahawkUtils::unmarginLayout( ui->albumHeader->layout() );*/
m_albumsModel = new PlayableModel( ui->albums );
ui->albums->setPlayableModel( m_albumsModel );
ui->albums->setEmptyTip( tr( "Sorry, we could not find any albums for this artist!" ) );
m_relatedModel = new PlayableModel( ui->relatedArtists );
ui->relatedArtists->setPlayableModel( m_relatedModel );
ui->relatedArtists->proxyModel()->sort( -1 );
ui->relatedArtists->setEmptyTip( tr( "Sorry, we could not find any related artists!" ) );
m_topHitsModel = new PlaylistModel( ui->topHits );
ui->topHits->proxyModel()->setStyle( PlayableProxyModel::Short );
ui->topHits->setPlayableModel( m_topHitsModel );
ui->topHits->setSortingEnabled( false );
ui->topHits->setEmptyTip( tr( "Sorry, we could not find any top hits for this artist!" ) );
ui->relatedArtists->setAutoFitItems( false );
ui->relatedArtists->setWrapping( false );
ui->relatedArtists->setVerticalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
ui->relatedArtists->setHorizontalScrollBarPolicy( Qt::ScrollBarAsNeeded );
ui->relatedArtists->delegate()->setItemSize( QSize( 170, 170 ) );
ui->albums->setAutoFitItems( false );
ui->albums->setWrapping( false );
ui->albums->setVerticalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
ui->albums->setHorizontalScrollBarPolicy( Qt::ScrollBarAsNeeded );
ui->albums->delegate()->setItemSize( QSize( 170, 170 ) );
ui->albums->proxyModel()->setHideDupeItems( true );
ui->topHits->setFrameShape( QFrame::StyledPanel );
ui->topHits->setAttribute( Qt::WA_MacShowFocusRect, 0 );
m_pixmap = TomahawkUtils::defaultPixmap( TomahawkUtils::DefaultArtistImage, TomahawkUtils::Original, QSize( 48, 48 ) );
ui->cover->setPixmap( TomahawkUtils::defaultPixmap( TomahawkUtils::DefaultArtistImage, TomahawkUtils::Grid ) );
ui->cover->setShowText( true );
QFont f = font();
f.setPointSize( f.pointSize() + 1 );
ui->biography->setOpenLinks( false );
ui->biography->setOpenExternalLinks( true );
ui->biography->setFrameShape( QFrame::NoFrame );
ui->biography->setAttribute( Qt::WA_MacShowFocusRect, 0 );
ui->biography->setFont( f );
TomahawkUtils::styleScrollBar( ui->biography->verticalScrollBar() );
QPalette p = ui->biography->palette();
p.setColor( QPalette::Foreground, Qt::white );
p.setColor( QPalette::Text, Qt::gray );
ui->biography->setPalette( p );
ui->label->setPalette( p );
ui->label_2->setPalette( p );
ui->label_3->setPalette( p );
QScrollArea* area = new QScrollArea();
area->setWidgetResizable( true );
area->setWidget( widget );
area->setStyleSheet( "QScrollArea { background-color: #454e59; }" );
area->setFrameShape( QFrame::NoFrame );
area->setAttribute( Qt::WA_MacShowFocusRect, 0 );
QVBoxLayout* layout = new QVBoxLayout();
layout->addWidget( area );
setLayout( layout );
TomahawkUtils::unmarginLayout( layout );
TomahawkUtils::styleScrollBar( ui->albums->horizontalScrollBar() );
TomahawkUtils::styleScrollBar( ui->relatedArtists->horizontalScrollBar() );
ui->biography->setStyleSheet( "QTextBrowser#biography { background-color: transparent; }" );
ui->biography->document()->setDefaultStyleSheet( "a { text-decoration: none; font-weight: bold; color: #ffffff; }" );
ui->albums->setStyleSheet( "QListView { background-color: transparent; }" );
ui->albumFrame->setStyleSheet( "QFrame#albumFrame { background-color: transparent; }"
"QFrame#albumFrame { "
"border-image: url(" RESPATH "images/scrollbar-vertical-handle.png) 3 3 3 3 stretch stretch;"
"border-top: 3px transparent; border-bottom: 3px transparent; border-right: 3px transparent; border-left: 3px transparent; }" );
ui->relatedArtists->setStyleSheet( "QListView { background-color: transparent; }" );
ui->artistFrame->setStyleSheet( "QFrame#artistFrame { background-color: transparent; }"
"QFrame#artistFrame { "
"border-image: url(" RESPATH "images/scrollbar-vertical-handle.png) 3 3 3 3 stretch stretch;"
"border-top: 3px transparent; border-bottom: 3px transparent; border-right: 3px transparent; border-left: 3px transparent; }" );
// ui->topHits->setStyleSheet( "QTreeView#topHits { background-color: transparent; }" );
ui->trackFrame->setStyleSheet( "QFrame#trackFrame { background-color: transparent; }"
"QFrame#trackFrame { "
"border-image: url(" RESPATH "images/scrollbar-vertical-handle.png) 3 3 3 3 stretch stretch;"
"border-top: 3px transparent; border-bottom: 3px transparent; border-right: 3px transparent; border-left: 3px transparent; }" );
connect( ui->biography, SIGNAL( anchorClicked( QUrl ) ), SLOT( onBiographyLinkClicked( QUrl ) ) );
MetaPlaylistInterface* mpl = new MetaPlaylistInterface();
mpl->addChildInterface( ui->relatedArtists->playlistInterface() );
mpl->addChildInterface( ui->topHits->playlistInterface() );
mpl->addChildInterface( ui->albums->playlistInterface() );
m_plInterface = playlistinterface_ptr( mpl );
load( artist );
}
AlbumInfoWidget::AlbumInfoWidget( const Tomahawk::album_ptr& album, QWidget* parent )
: QWidget( parent )
, ui( new Ui::AlbumInfoWidget )
{
QWidget* widget = new QWidget;
ui->setupUi( widget );
m_pixmap = TomahawkUtils::defaultPixmap( TomahawkUtils::DefaultAlbumCover, TomahawkUtils::Original, QSize( 48, 48 ) );
ui->cover->setPixmap( TomahawkUtils::defaultPixmap( TomahawkUtils::DefaultAlbumCover, TomahawkUtils::Grid, ui->cover->size() ) );
ui->cover->setShowText( false );
ui->lineAbove->setStyleSheet( QString( "QFrame { border: 1px solid %1; }" ).arg( TomahawkStyle::HEADER_BACKGROUND.name() ) );
ui->lineBelow->setStyleSheet( QString( "QFrame { border: 1px solid black; }" ) );
{
m_tracksModel = new TreeModel( ui->tracks );
m_tracksModel->setMode( Mixed );
AlbumItemDelegate* del = new AlbumItemDelegate( ui->tracks, ui->tracks->proxyModel() );
ui->tracks->setPlaylistItemDelegate( del );
ui->tracks->setEmptyTip( tr( "Sorry, we could not find any tracks for this album!" ) );
ui->tracks->proxyModel()->setStyle( PlayableProxyModel::Large );
ui->tracks->setAutoResize( true );
ui->tracks->setPlayableModel( m_tracksModel );
ui->tracks->setAlternatingRowColors( false );
QPalette p = ui->tracks->palette();
p.setColor( QPalette::Text, TomahawkStyle::PAGE_TRACKLIST_TRACK_SOLVED );
p.setColor( QPalette::BrightText, TomahawkStyle::PAGE_TRACKLIST_TRACK_UNRESOLVED );
p.setColor( QPalette::Foreground, TomahawkStyle::PAGE_TRACKLIST_NUMBER );
p.setColor( QPalette::Highlight, TomahawkStyle::PAGE_TRACKLIST_HIGHLIGHT );
p.setColor( QPalette::HighlightedText, TomahawkStyle::PAGE_TRACKLIST_HIGHLIGHT_TEXT );
ui->tracks->setPalette( p );
TomahawkStyle::styleScrollBar( ui->tracks->horizontalScrollBar() );
TomahawkStyle::stylePageFrame( ui->tracks );
TomahawkStyle::stylePageFrame( ui->trackFrame );
}
{
m_albumsModel = new PlayableModel( ui->albums );
ui->albums->setPlayableModel( m_albumsModel );
ui->albums->setEmptyTip( tr( "Sorry, we could not find any other albums for this artist!" ) );
/* ui->albums->setAutoFitItems( true );
* ui->albums->setWrapping( false );
* ui->albums->setVerticalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
* ui->albums->setHorizontalScrollBarPolicy( Qt::ScrollBarAsNeeded );*/
ui->albums->delegate()->setItemSize( QSize( 170, 170 ) );
ui->albums->proxyModel()->setHideDupeItems( true );
TomahawkStyle::styleScrollBar( ui->albums->verticalScrollBar() );
TomahawkStyle::stylePageFrame( ui->albums );
TomahawkStyle::stylePageFrame( ui->albumFrame );
}
{
QFont f = ui->biography->font();
f.setFamily( "Titillium Web" );
QPalette p = ui->biography->palette();
p.setColor( QPalette::Text, TomahawkStyle::HEADER_TEXT );
ui->biography->setFont( f );
ui->biography->setPalette( p );
ui->biography->setOpenLinks( false );
ui->biography->setOpenExternalLinks( true );
ui->biography->document()->setDefaultStyleSheet( QString( "a { text-decoration: none; font-weight: bold; color: %1; }" ).arg( TomahawkStyle::HEADER_LINK.name() ) );
TomahawkStyle::stylePageFrame( ui->biography );
TomahawkStyle::styleScrollBar( ui->biography->verticalScrollBar() );
// connect( ui->biography, SIGNAL( anchorClicked( QUrl ) ), SLOT( onBiographyLinkClicked( QUrl ) ) );
}
{
QFont f = ui->albumLabel->font();
f.setFamily( "Titillium Web" );
QPalette p = ui->albumLabel->palette();
p.setColor( QPalette::Foreground, TomahawkStyle::HEADER_LABEL );
ui->albumLabel->setFont( f );
ui->albumLabel->setPalette( p );
}
{
ui->artistLabel->setContentsMargins( 6, 2, 6, 2 );
ui->artistLabel->setElideMode( Qt::ElideMiddle );
ui->artistLabel->setType( QueryLabel::Artist );
connect( ui->artistLabel, SIGNAL( clickedArtist() ), SLOT( onArtistClicked() ) );
QFont f = ui->artistLabel->font();
f.setFamily( "Titillium Web" );
QPalette p = ui->artistLabel->palette();
p.setColor( QPalette::Foreground, TomahawkStyle::HEADER_TEXT );
ui->artistLabel->setFont( f );
ui->artistLabel->setPalette( p );
}
{
QFont f = ui->label->font();
f.setFamily( "Pathway Gothic One" );
QPalette p = ui->label->palette();
p.setColor( QPalette::Foreground, TomahawkStyle::PAGE_CAPTION );
ui->label->setFont( f );
ui->label_2->setFont( f );
ui->label->setPalette( p );
ui->label_2->setPalette( p );
}
{
QScrollArea* area = new QScrollArea();
area->setWidgetResizable( true );
area->setVerticalScrollBarPolicy( Qt::ScrollBarAlwaysOn );
area->setWidget( widget );
QPalette pal = palette();
pal.setBrush( backgroundRole(), TomahawkStyle::HEADER_BACKGROUND );
area->setPalette( pal );
area->setAutoFillBackground( true );
area->setFrameShape( QFrame::NoFrame );
area->setAttribute( Qt::WA_MacShowFocusRect, 0 );
QVBoxLayout* layout = new QVBoxLayout();
layout->addWidget( area );
setLayout( layout );
TomahawkUtils::unmarginLayout( layout );
}
{
QPalette pal = palette();
pal.setBrush( backgroundRole(), TomahawkStyle::PAGE_BACKGROUND );
ui->widget->setPalette( pal );
ui->widget->setAutoFillBackground( true );
}
MetaPlaylistInterface* mpl = new MetaPlaylistInterface();
mpl->addChildInterface( ui->tracks->playlistInterface() );
mpl->addChildInterface( ui->albums->playlistInterface() );
m_playlistInterface = playlistinterface_ptr( mpl );
load( album );
}
KeyBinder::KeyBinder(QWidget * parent, const QString & helpText, const QString & defaultText, const QString & resetButtonText) : QWidget(parent)
{
this->defaultText = defaultText;
enableSignal = false;
// Two-column tab layout
QHBoxLayout * pageKeysLayout = new QHBoxLayout(this);
pageKeysLayout->setSpacing(0);
pageKeysLayout->setContentsMargins(0, 0, 0, 0);
// Table for category list
QVBoxLayout * catListContainer = new QVBoxLayout();
catListContainer->setContentsMargins(10, 10, 10, 10);
catList = new QListWidget();
catList->setFixedWidth(180);
catList->setStyleSheet("QListWidget::item { font-size: 14px; } QListWidget:hover { border-color: #F6CB1C; } QListWidget::item:selected { background: #150A61; color: yellow; }");
catList->setFocusPolicy(Qt::NoFocus);
connect(catList, SIGNAL(currentRowChanged(int)), this, SLOT(changeBindingsPage(int)));
catListContainer->addWidget(catList);
pageKeysLayout->addLayout(catListContainer);
// Reset all binds button
if (!resetButtonText.isEmpty())
{
QPushButton * btnResetAll = new QPushButton(resetButtonText);
catListContainer->addWidget(btnResetAll);
btnResetAll->setFixedHeight(40);
catListContainer->setStretch(1, 0);
catListContainer->setSpacing(10);
connect(btnResetAll, SIGNAL(clicked()), this, SIGNAL(resetAllBinds()));
}
// Container for pages of key bindings
QWidget * bindingsPagesContainer = new QWidget();
QVBoxLayout * rightLayout = new QVBoxLayout(bindingsPagesContainer);
// Scroll area for key bindings
QScrollArea * scrollArea = new QScrollArea();
scrollArea->setContentsMargins(0, 0, 0, 0);
scrollArea->setWidget(bindingsPagesContainer);
scrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
scrollArea->setWidgetResizable(true);
scrollArea->setFrameShape(QFrame::NoFrame);
scrollArea->setStyleSheet("background: #130F2A;");
// Add key binding pages to bindings tab
pageKeysLayout->addWidget(scrollArea);
pageKeysLayout->setStretch(1, 1);
// Custom help text
QLabel * helpLabel = new QLabel();
helpLabel->setText(helpText);
helpLabel->setStyleSheet("color: #130F2A; background: #F6CB1C; border: solid 4px #F6CB1C; border-radius: 10px; padding: auto 20px;");
helpLabel->setFixedHeight(24);
rightLayout->addWidget(helpLabel, 0, Qt::AlignCenter);
// Category list and bind table row heights
const int rowHeight = 20;
QSize catSize, headerSize;
catSize.setHeight(36);
headerSize.setHeight(24);
// Category list header
QListWidgetItem * catListHeader = new QListWidgetItem(tr("Category"));
catListHeader->setSizeHint(headerSize);
catListHeader->setFlags(Qt::NoItemFlags);
catListHeader->setForeground(QBrush(QColor("#130F2A")));
catListHeader->setBackground(QBrush(QColor("#F6CB1C")));
catListHeader->setTextAlignment(Qt::AlignCenter);
catList->addItem(catListHeader);
// Populate
bindingsPages = new QHBoxLayout();
bindingsPages->setContentsMargins(0, 0, 0, 0);
rightLayout->addLayout(bindingsPages);
QWidget * curPage = NULL;
QVBoxLayout * curLayout = NULL;
QTableWidget * curTable = NULL;
bool bFirstPage = true;
selectedBindTable = NULL;
bindComboBoxCellMappings = new QHash<QObject *, QTableWidgetItem *>();
bindCellComboBoxMappings = new QHash<QTableWidgetItem *, QComboBox *>();
for (int i = 0; i < BINDS_NUMBER; i++)
{
if (cbinds[i].category != NULL)
{
// Add stretch at end of previous layout
if (curLayout != NULL) curLayout->insertStretch(-1, 1);
// Category list item
QListWidgetItem * catItem = new QListWidgetItem(HWApplication::translate("binds (categories)", cbinds[i].category));
catItem->setSizeHint(catSize);
catList->addItem(catItem);
// Create new page
curPage = new QWidget();
curLayout = new QVBoxLayout(curPage);
curLayout->setSpacing(2);
bindingsPages->addWidget(curPage);
if (!bFirstPage) curPage->setVisible(false);
}
// Description
if (cbinds[i].description != NULL)
{
QLabel * desc = new QLabel(HWApplication::translate("binds (descriptions)", cbinds[i].description));
curLayout->addWidget(desc, 0);
QFrame * divider = new QFrame();
divider->setFrameShape(QFrame::HLine);
divider->setFrameShadow(QFrame::Plain);
curLayout->addWidget(divider, 0);
}
// New table
if (cbinds[i].category != NULL || cbinds[i].description != NULL)
{
curTable = new QTableWidget(0, 2);
curTable->verticalHeader()->setVisible(false);
curTable->horizontalHeader()->setVisible(false);
curTable->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
curTable->verticalHeader()->setDefaultSectionSize(rowHeight);
curTable->setShowGrid(false);
curTable->setStyleSheet("QTableWidget { border: none; } ");
curTable->setSelectionBehavior(QAbstractItemView::SelectRows);
curTable->setSelectionMode(QAbstractItemView::SingleSelection);
curTable->setFocusPolicy(Qt::NoFocus);
connect(curTable, SIGNAL(itemSelectionChanged()), this, SLOT(bindSelectionChanged()));
connect(curTable, SIGNAL(itemClicked(QTableWidgetItem *)), this, SLOT(bindCellClicked(QTableWidgetItem *)));
curLayout->addWidget(curTable, 0);
}
// Hidden combo box
QComboBox * comboBox = CBBind[i] = new QComboBox(curTable);
comboBox->setModel((QAbstractItemModel*)DataManager::instance().bindsModel());
comboBox->setVisible(false);
comboBox->setFixedWidth(200);
// Table row
int row = curTable->rowCount();
QTableWidgetItem * nameCell = new QTableWidgetItem(HWApplication::translate("binds", cbinds[i].name));
nameCell->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
curTable->insertRow(row);
curTable->setItem(row, 0, nameCell);
QTableWidgetItem * bindCell = new QTableWidgetItem(comboBox->currentText());
bindCell->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
curTable->setItem(row, 1, bindCell);
curTable->resizeColumnsToContents();
curTable->setFixedHeight(curTable->verticalHeader()->length() + 10);
// Updates the text in the table cell
connect(comboBox, SIGNAL(currentIndexChanged(const QString &)), this, SLOT(bindChanged(const QString &)));
// Map combo box and that row's cells to each other
bindComboBoxCellMappings->insert(comboBox, bindCell);
bindCellComboBoxMappings->insert(nameCell, comboBox);
bindCellComboBoxMappings->insert(bindCell, comboBox);
}
void CloudDialog::createWidgets()
{
QLabel * label = 0;
bool isConnected = false;
m_amazonProviderWidget = new AmazonProviderWidget(this);
m_blankProviderWidget = new BlankProviderWidget(this);
m_vagrantProviderWidget = new VagrantProviderWidget(this);
// BLANK PAGE
QWidget * blankPageWidget = new QWidget();
// LOGIN PAGE
QHBoxLayout * mainLoginLayout = new QHBoxLayout;
mainLoginLayout->setContentsMargins(QMargins(0,0,0,0));
mainLoginLayout->setSpacing(5);
QWidget * loginPageWidget = new QWidget;
loginPageWidget->setLayout(mainLoginLayout);
// LEFT LOGIN LAYOUT
m_leftLoginLayout = new QVBoxLayout();
mainLoginLayout->addLayout(m_leftLoginLayout);
label = new QLabel;
label->setObjectName("H2");
label->setText("Cloud Resources");
m_leftLoginLayout->addWidget(label,0,Qt::AlignTop | Qt::AlignLeft);
m_cloudResourceComboBox = new QComboBox();
m_leftLoginLayout->addWidget(m_cloudResourceComboBox,0,Qt::AlignTop | Qt::AlignLeft);
//m_cloudResourceComboBox->addItem(NO_PROVIDER);
if(showVagrant()) m_cloudResourceComboBox->addItem(VAGRANT_PROVIDER);
m_cloudResourceComboBox->addItem(AMAZON_PROVIDER);
isConnected = connect(m_cloudResourceComboBox, SIGNAL(currentIndexChanged(const QString &)),
this, SLOT(cloudResourceChanged(const QString &)));
OS_ASSERT(isConnected);
// LOGIN STACKED WIDGET
m_loginStackedWidget = new QStackedWidget();
m_leftLoginLayout->addWidget(m_loginStackedWidget);
m_loginStackedWidget->addWidget(m_blankProviderWidget->m_loginWidget);
m_loginStackedWidget->addWidget(m_vagrantProviderWidget->m_loginWidget);
m_loginStackedWidget->addWidget(m_amazonProviderWidget->m_loginWidget);
m_loginStackedWidget->setCurrentIndex(m_blankProviderIdx);
// RIGHT LOGIN LAYOUT
m_rightLoginLayout = new QVBoxLayout();
mainLoginLayout->addLayout(m_rightLoginLayout);
m_legalAgreement = new QLabel;
m_legalAgreement->hide();
m_legalAgreement->setWordWrap(true);
AWSSettings awsSettings;
m_legalAgreement->setText(awsSettings.userAgreementText().c_str());
QScrollArea * scrollArea = new QScrollArea();
scrollArea->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding);
scrollArea->setFixedWidth(TEXT_WIDTH + 15);
scrollArea->setMinimumHeight(TEXT_HEIGHT);
scrollArea->setStyleSheet("background-color:transparent;");
scrollArea->setWidget(m_legalAgreement);
scrollArea->setWidgetResizable(true);
scrollArea->setAlignment(Qt::AlignTop);
scrollArea->setFrameShape(QFrame::NoFrame);
m_rightLoginLayout->addWidget(scrollArea);
m_iAcceptCheckBox = new QCheckBox("I Agree");
m_iAcceptCheckBox->hide();
m_rightLoginLayout->addWidget(m_iAcceptCheckBox,0,Qt::AlignTop | Qt::AlignLeft);
m_rightLoginLayout->addSpacing(5);
isConnected = connect(m_iAcceptCheckBox, SIGNAL(clicked(bool)),
this, SLOT(iAcceptClicked(bool)));
OS_ASSERT(isConnected);
m_rightLoginLayout->addSpacing(5);
// SETTINGS PAGE
m_mainSettingsLayout = new QVBoxLayout;
m_mainSettingsLayout->setContentsMargins(QMargins(0,0,0,0));
m_mainSettingsLayout->setSpacing(5);
QWidget * settingsPageWidget = new QWidget;
settingsPageWidget->setLayout(m_mainSettingsLayout);
// SETTINGS STACKED WIDGET
m_settingsStackedWidget = new QStackedWidget();
m_mainSettingsLayout->addWidget(m_settingsStackedWidget);
QWidget * widget = new QWidget();
QHBoxLayout * hLayout = new QHBoxLayout;
hLayout->setContentsMargins(QMargins(0,0,0,0));
hLayout->setSpacing(5);
widget->setLayout(hLayout);
hLayout->addWidget(m_blankProviderWidget->m_leftSettingsWidget);
hLayout->addWidget(m_blankProviderWidget->m_rightSettingsWidget);
m_settingsStackedWidget->addWidget(widget);
widget = new QWidget();
hLayout = new QHBoxLayout;
hLayout->setContentsMargins(QMargins(0,0,0,0));
hLayout->setSpacing(5);
widget->setLayout(hLayout);
hLayout->addWidget(m_vagrantProviderWidget->m_leftSettingsWidget);
hLayout->addWidget(m_vagrantProviderWidget->m_rightSettingsWidget);
m_settingsStackedWidget->addWidget(widget);
widget = new QWidget();
hLayout = new QHBoxLayout;
hLayout->setContentsMargins(QMargins(0,0,0,0));
hLayout->setSpacing(5);
widget->setLayout(hLayout);
hLayout->addWidget(m_amazonProviderWidget->m_leftSettingsWidget);
hLayout->addWidget(m_amazonProviderWidget->m_rightSettingsWidget);
m_settingsStackedWidget->addWidget(widget);
m_settingsStackedWidget->setCurrentIndex(m_blankProviderIdx);
// PAGE STACKED WIDGET
m_pageStackedWidget = new QStackedWidget();
upperLayout()->addWidget(m_pageStackedWidget);
m_blankPageIdx = m_pageStackedWidget->addWidget(blankPageWidget);
m_loginPageIdx = m_pageStackedWidget->addWidget(loginPageWidget);
m_settingsPageIdx = m_pageStackedWidget->addWidget(settingsPageWidget);
m_pageStackedWidget->setCurrentIndex(m_loginPageIdx);
// BUTTONS
this->okButton()->setText("Save");
this->backButton()->setText("Continue");
this->backButton()->setEnabled(false);
this->backButton()->show();
// OS SETTINGS
#ifdef Q_OS_MAC
setWindowFlags(Qt::FramelessWindowHint);
#elif defined(Q_OS_WIN32)
setWindowFlags(Qt::WindowCloseButtonHint | Qt::MSWindowsFixedSizeDialogHint);
#endif
cloudResourceChanged(m_cloudResourceComboBox->currentText());
}
Dashboard::Dashboard( QWidget* parent )
: QWidget( parent )
, ui( new Ui::Dashboard )
, m_header( new BasicHeader( this ) )
{
QWidget* widget = new QWidget;
ui->setupUi( widget );
m_header->setPixmap( ImageRegistry::instance()->pixmap( RESPATH "images/dashboard.svg", QSize( 0, 0 ) ) );
m_header->setCaption( tr( "Dashboard" ) );
m_header->setDescription( tr( "An overview of your recent activity" ) );
RecentPlaylistsModel* model = new RecentPlaylistsModel( HISTORY_PLAYLIST_ITEMS, this );
QPalette trackViewPal = ui->tracksView->palette();
trackViewPal.setColor( QPalette::Foreground, TomahawkStyle::PAGE_FOREGROUND );
trackViewPal.setColor( QPalette::Text, TomahawkStyle::PAGE_FOREGROUND );
trackViewPal.setColor( QPalette::Highlight, QColor( "#252020" ) );
trackViewPal.setColor( QPalette::HighlightedText, Qt::white );
ui->playlistWidget->setFrameShape( QFrame::NoFrame );
ui->playlistWidget->setAttribute( Qt::WA_MacShowFocusRect, 0 );
ui->playlistWidget->setItemDelegate( new PlaylistDelegate() );
ui->playlistWidget->setModel( model );
ui->playlistWidget->overlay()->resize( 380, 86 );
ui->playlistWidget->setVerticalScrollMode( QAbstractItemView::ScrollPerPixel );
ui->playlistWidget->setPalette( trackViewPal );
ui->playlistWidget->setMinimumHeight( 400 );
updatePlaylists();
m_tracksModel = new RecentlyPlayedModel( ui->tracksView, HISTORY_TRACK_ITEMS );
ui->tracksView->proxyModel()->setStyle( PlayableProxyModel::ShortWithAvatars );
ui->tracksView->overlay()->setEnabled( false );
ui->tracksView->setPlaylistModel( m_tracksModel );
ui->tracksView->setAutoResize( true );
m_tracksModel->setSource( source_ptr() );
ui->tracksView->setPalette( trackViewPal );
ui->tracksView->setAlternatingRowColors( false );
ui->tracksView->setFrameShape( QFrame::NoFrame );
ui->tracksView->setAttribute( Qt::WA_MacShowFocusRect, 0 );
m_recentAlbumsModel = new AlbumModel( ui->additionsView );
ui->additionsView->setPlayableModel( m_recentAlbumsModel );
ui->additionsView->proxyModel()->sort( -1 );
QScrollArea* area = new QScrollArea();
area->setWidgetResizable( true );
area->setVerticalScrollBarPolicy( Qt::ScrollBarAlwaysOn );
area->setWidget( widget );
QPalette pal = palette();
// background: qradialgradient(cx: 0.5, cy: -1.8, fx: 0.5, fy: 0, radius: 2, stop: 0 %1, stop: 1 %2);
pal.setBrush( backgroundRole(), TomahawkStyle::PAGE_BACKGROUND );
area->setPalette( pal );
area->setAutoFillBackground( true );
area->setFrameShape( QFrame::NoFrame );
area->setAttribute( Qt::WA_MacShowFocusRect, 0 );
QVBoxLayout* layout = new QVBoxLayout();
layout->addWidget( m_header );
layout->addWidget( area );
setLayout( layout );
TomahawkUtils::unmarginLayout( layout );
TomahawkStyle::styleScrollBar( ui->playlistWidget->verticalScrollBar() );
TomahawkStyle::styleScrollBar( ui->additionsView->verticalScrollBar() );
QFont f;
f.setBold( true );
QFontMetrics fm( f );
ui->tracksView->setMinimumWidth( fm.width( tr( "Recently played tracks" ) ) * 2 );
QPalette p = ui->label->palette();
p.setColor( QPalette::Foreground, TomahawkStyle::PAGE_FOREGROUND );
p.setColor( QPalette::Text, TomahawkStyle::PAGE_TEXT );
ui->label->setPalette( p );
ui->label_2->setPalette( p );
ui->label_3->setPalette( p );
ui->playlistWidget->setStyleSheet( "QListView { background-color: transparent; }" );
TomahawkStyle::stylePageFrame( ui->playlistFrame );
ui->additionsView->setStyleSheet( "QListView { background-color: transparent; }" );
TomahawkStyle::stylePageFrame( ui->additionsFrame );
ui->tracksView->setStyleSheet( "QTreeView { background-color: transparent; }" );
TomahawkStyle::stylePageFrame( ui->trackFrame );
MetaPlaylistInterface* mpl = new MetaPlaylistInterface();
mpl->addChildInterface( ui->tracksView->playlistInterface() );
mpl->addChildInterface( ui->additionsView->playlistInterface() );
m_playlistInterface = playlistinterface_ptr( mpl );
connect( SourceList::instance(), SIGNAL( ready() ), SLOT( onSourcesReady() ) );
connect( SourceList::instance(), SIGNAL( sourceAdded( Tomahawk::source_ptr ) ), SLOT( onSourceAdded( Tomahawk::source_ptr ) ) );
connect( ui->playlistWidget, SIGNAL( activated( QModelIndex ) ), SLOT( onPlaylistActivated( QModelIndex ) ) );
connect( model, SIGNAL( emptinessChanged( bool ) ), this, SLOT( updatePlaylists() ) );
}
int KMessageBox::createKMessageBox(KDialog *dialog, const QIcon &icon,
const QString &text, const QStringList &strlist,
const QString &ask, bool *checkboxReturn, Options options,
const QString &details, QMessageBox::Icon notifyType)
{
QWidget *mainWidget = new QWidget(dialog);
QVBoxLayout *mainLayout = new QVBoxLayout(mainWidget);
mainLayout->setSpacing(KDialog::spacingHint() * 2); // provide extra spacing
mainLayout->setMargin(0);
QHBoxLayout *hLayout = new QHBoxLayout();
hLayout->setMargin(0);
hLayout->setSpacing(-1); // use default spacing
mainLayout->addLayout(hLayout,5);
QLabel *iconLabel = new QLabel(mainWidget);
if (!icon.isNull()) {
QStyleOption option;
option.initFrom(mainWidget);
iconLabel->setPixmap(icon.pixmap(mainWidget->style()->pixelMetric(QStyle::PM_MessageBoxIconSize, &option, mainWidget)));
}
QVBoxLayout *iconLayout = new QVBoxLayout();
iconLayout->addStretch(1);
iconLayout->addWidget(iconLabel);
iconLayout->addStretch(5);
hLayout->addLayout(iconLayout,0);
hLayout->addSpacing(KDialog::spacingHint());
QLabel *messageLabel = new QLabel(text, mainWidget);
messageLabel->setOpenExternalLinks(options & KMessageBox::AllowLink);
Qt::TextInteractionFlags flags = Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard;
if (options & KMessageBox::AllowLink) {
flags |= Qt::LinksAccessibleByMouse | Qt::LinksAccessibleByKeyboard;
}
messageLabel->setTextInteractionFlags(flags);
QRect desktop = KGlobalSettings::desktopGeometry(dialog);
bool usingSqueezedTextLabel = false;
if (messageLabel->sizeHint().width() > desktop.width() * 0.5) {
// enable automatic wrapping of messages which are longer than 50% of screen width
messageLabel->setWordWrap(true);
// display a text widget with scrollbar if still too wide
usingSqueezedTextLabel = messageLabel->sizeHint().width() > desktop.width() * 0.85;
if (usingSqueezedTextLabel)
{
delete messageLabel;
messageLabel = new KSqueezedTextLabel(text, mainWidget);
messageLabel->setOpenExternalLinks(options & KMessageBox::AllowLink);
messageLabel->setTextInteractionFlags(flags);
}
}
QPalette messagePal(messageLabel->palette());
messagePal.setColor(QPalette::Window, Qt::transparent);
messageLabel->setPalette(messagePal);
bool usingScrollArea=desktop.height() / 3 < messageLabel->sizeHint().height();
if (usingScrollArea)
{
QScrollArea* messageScrollArea = new QScrollArea(mainWidget);
messageScrollArea->setWidget(messageLabel);
messageScrollArea->setFrameShape(QFrame::NoFrame);
messageScrollArea->setWidgetResizable(true);
QPalette scrollPal(messageScrollArea->palette());
scrollPal.setColor(QPalette::Window, Qt::transparent);
messageScrollArea->viewport()->setPalette(scrollPal);
hLayout->addWidget(messageScrollArea,5);
}
else
hLayout->addWidget(messageLabel,5);
const bool usingListWidget=!strlist.isEmpty();
if (usingListWidget) {
// enable automatic wrapping since the listwidget has already a good initial width
messageLabel->setWordWrap(true);
QListWidget *listWidget = new QListWidget(mainWidget);
listWidget->addItems(strlist);
QStyleOptionViewItem styleOption;
styleOption.initFrom(listWidget);
QFontMetrics fm(styleOption.font);
int w = listWidget->width();
Q_FOREACH(const QString &str, strlist) {
w = qMax(w, fm.width(str));
}
const int borderWidth = listWidget->width() - listWidget->viewport()->width() + listWidget->verticalScrollBar()->height();
w += borderWidth;
if (w > desktop.width() * 0.85) { // limit listWidget size to 85% of screen width
w = qRound(desktop.width() * 0.85);
}
listWidget->setMinimumWidth(w);
mainLayout->addWidget(listWidget,usingScrollArea?10:50);
listWidget->setSelectionMode(QListWidget::NoSelection);
messageLabel->setSizePolicy(QSizePolicy::Preferred,QSizePolicy::Minimum);
}
/// continue the creation of the widgets once the pieces XML was loaded.
/// this is where all the work of creating the family tabs and their content is performed.
void PicsSelectWidget::continueCreate()
{
const PicBucket& bucket = PicBucket::instance();
m_tabs = new QTabWidget(this);
connect(m_tabs, SIGNAL(currentChanged(int)), this, SLOT(updateSetsSpinBox(int)));
m_layout->addWidget(m_tabs);
m_groups.resize(bucket.grps.size());
for (int f = 0; f < bucket.families.size(); ++f)
{
const PicFamily &fam = bucket.families[f];
SizedWidget *tab = new SizedWidget(QSize(6 * BOT_TOTAL_X + BOT_OFFS_X + FRAME_OFFS_SPACE_RIGHT - 5, NUM_DEFS * BOT_TOTAL_Y + FRAME_OFFS_Y), nullptr);
//QWidget *tab = new QWidget();
//tab->resize(QSize(6 * BOT_TOTAL_X + BOT_OFFS_X + FRAME_OFFS_SPACE_RIGHT, NUM_DEFS * BOT_TOTAL_Y + FRAME_OFFS_Y));
QScrollArea *scroll = new QScrollArea();
scroll->setWidget(tab);
// the following is the voodoo needed to make the scroll area the same color as the tab
// if this wasn't here, the scroll area would have gotten the default window color
// this is significant in Windows XP with new apperance style where the tab color is
// different from the default window color
scroll->viewport()->setAutoFillBackground(false);
tab->setAutoFillBackground(false);
// scroll area has a frame by default. get rid of it.
scroll->setFrameShape(QFrame::NoFrame);
m_tabs->addTab(scroll, fam.name.c_str());
for (int g = fam.startIndex; g < fam.startIndex + fam.numGroups; ++g)
{
const PicGroupDef *grp = &(bucket.grps[g]);
GroupCtrl &grpctrl = m_groups[g];
int normg = (g - fam.startIndex); // normalized g with start of family
QGroupBox *groupbox = new QGroupBox(grp->name.c_str(), tab);
groupbox->move(BOT_OFFS_X-FRAME_OFFS_SPACE_LEFT, FRAME_OFFS_Y + normg*BOT_TOTAL_Y - 30);
groupbox->resize(FRAME_OFFS_SPACE_RIGHT + grp->numPics() * BOT_TOTAL_X, BOT_Y + 55);
grpctrl.num = new DataSpinBox(g, tab);
grpctrl.num->move(grp->numPics() * BOT_TOTAL_X + BOT_OFFS_X + FRAME_OFFS_SPACE_RIGHT - 65, BOT_OFFS_Y + normg*BOT_TOTAL_Y + 40);
grpctrl.num->resize(45, 23);
grpctrl.num->setButtonSymbols(QAbstractSpinBox::PlusMinus);
grpctrl.num->setRange(-1, MAX_IDENTICAL_PIECES);
grpctrl.num->setSpecialValueText("X");
connect(grpctrl.num, SIGNAL(dvalueChanged(int, int)), this, SLOT(changedGrpBox(int, int)));
for (int p = 0; p < bucket.grps[g].numPics(); ++p)
{
const PicDef* pic = &(grp->getPic(p));
PicCtrl picctrl;
int data = (g << 16) | p;
DataPushButton *button = new DataPushButton(data, QIcon(pic->pixmap), QString(), tab);
picctrl.bot = button;
button->setCheckable(true);
button->move(BOT_OFFS_X + p*BOT_TOTAL_X, BOT_OFFS_Y + normg * BOT_TOTAL_Y); // g normalized to start of family
button->resize(BOT_X, BOT_Y);
button->setIconSize(pic->pixmap.size()); // +1 because it's the texture + line, from Pieces.h
connect(button, SIGNAL(pclicked(int, bool)), this, SLOT(pressedPicButton(int, bool)));
DataSpinBox *spinbox = new DataSpinBox(data, tab);
picctrl.num = spinbox;
spinbox->setRange(0, MAX_IDENTICAL_PIECES);
spinbox->move(BOT_OFFS_X + p*BOT_TOTAL_X + (BOT_X/5*2 + 2), BOT_OFFS_Y + normg*BOT_TOTAL_Y + BOT_Y + 5);
spinbox->resize(BOT_X/5*3 - 4, EDIT_THICK + 1);
spinbox->setButtonSymbols(QAbstractSpinBox::PlusMinus);
connect(spinbox, SIGNAL(dvalueChanged(int, int)), this, SLOT(changedNumBox(int, int)));
QLabel *solnum = new QLabel("0", tab);
picctrl.snum = solnum;
solnum->move(BOT_OFFS_X + p*BOT_TOTAL_X + 2, BOT_OFFS_Y + normg*BOT_TOTAL_Y + BOT_Y + 6);
solnum->resize(BOT_X/5*2 - 4, EDIT_THICK);
solnum->setAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
solnum->setFrameShadow(QFrame::Sunken);
solnum->setFrameShape(QFrame::Panel);
solnum->setPalette(*m_slvPalette);
solnum->setVisible(false);
grpctrl.pics.push_back(picctrl);
}
}
}
setBuildTilesCount(m_doc->getBuild().tilesCount());
// prevent the build Help sidebar to get notifications. it might not be there yet.
// eventually the sidebar will take care of itself.
blockSignals(true);
changeToResetValues();
blockSignals(false);
m_bFinishedCreate = true;
}
void EspressoPWscfConfig::setupSystem () {
QWidget *ret = new QWidget;
QScrollArea *sa = new QScrollArea;
sa->setFrameShape(QFrame::NoFrame);
QFormLayout *layout = new QFormLayout;
QWidget *editor = 0;
editor = new QSpinBox; editor->setObjectName("nat"); layout->addRow("nat", editor);
editor = new QSpinBox; editor->setObjectName("ntyp"); layout->addRow("ntyp", editor);
editor = new QSpinBox; editor->setObjectName("nbnd"); layout->addRow("nbnd", editor);
editor = new QDoubleSpinBox; editor->setObjectName("tot_charge"); layout->addRow("tot_charge", editor);
editor = new QDoubleSpinBox; editor->setObjectName("tot_magnetization"); layout->addRow("tot_magnetization", editor);
editor = new QDoubleSpinBox; editor->setObjectName("starting_magnetization(i),i=1,ntyp"); layout->addRow("starting_magnetization(i),i=1,ntyp", editor);
editor = new QDoubleSpinBox; editor->setObjectName("ecutwfc"); layout->addRow("ecutwfc", editor);
editor = new QDoubleSpinBox; editor->setObjectName("ecutrho"); layout->addRow("ecutrho", editor);
editor = new QDoubleSpinBox; editor->setObjectName("ecutfock"); layout->addRow("ecutfock", editor);
editor = new QSpinBox; editor->setObjectName("nr1"); layout->addRow("nr1", editor);
editor = new QSpinBox; editor->setObjectName("nr2"); layout->addRow("nr2", editor);
editor = new QSpinBox; editor->setObjectName("nr3"); layout->addRow("nr3", editor);
editor = new QSpinBox; editor->setObjectName("nr1s"); layout->addRow("nr1s", editor);
editor = new QSpinBox; editor->setObjectName("nr2s"); layout->addRow("nr2s", editor);
editor = new QSpinBox; editor->setObjectName("nr3s"); layout->addRow("nr3s", editor);
editor = boolCombo(); editor->setObjectName("nosym"); layout->addRow("nosym", editor);
editor = boolCombo(); editor->setObjectName("nosym_evc"); layout->addRow("nosym_evc", editor);
editor = boolCombo(); editor->setObjectName("noinv"); layout->addRow("noinv", editor);
editor = boolCombo(); editor->setObjectName("no_t_rev"); layout->addRow("no_t_rev", editor);
editor = boolCombo(); editor->setObjectName("force_symmorphic"); layout->addRow("force_symmorphic", editor);
editor = boolCombo(); editor->setObjectName("use_all_frac"); layout->addRow("use_all_frac", editor);
editor = new QLineEdit; editor->setObjectName("occupations"); layout->addRow("occupations", editor);
editor = boolCombo(); editor->setObjectName("one_atom_occupations"); layout->addRow("one_atom_occupations", editor);
editor = boolCombo(); editor->setObjectName("starting_spin_angle"); layout->addRow("starting_spin_angle", editor);
editor = new QDoubleSpinBox; editor->setObjectName("degauss"); layout->addRow("degauss", editor);
editor = new QLineEdit; editor->setObjectName("smearing"); layout->addRow("smearing", editor);
editor = new QSpinBox; editor->setObjectName("nspin"); layout->addRow("nspin", editor);
editor = boolCombo(); editor->setObjectName("noncolin"); layout->addRow("noncolin", editor);
editor = new QDoubleSpinBox; editor->setObjectName("ecfixed"); layout->addRow("ecfixed", editor);
editor = new QLineEdit; editor->setObjectName("input_dft"); layout->addRow("input_dft", editor);
editor = new QDoubleSpinBox; editor->setObjectName("exx_fraction"); layout->addRow("exx_fraction", editor);
editor = new QDoubleSpinBox; editor->setObjectName("screening_parameter"); layout->addRow("screening_parameter", editor);
editor = new QLineEdit; editor->setObjectName("exxdiv_treatment"); layout->addRow("exxdiv_treatment", editor);
editor = new QDoubleSpinBox; editor->setObjectName("ecutvcut"); layout->addRow("ecutvcut", editor);
editor = new QSpinBox; editor->setObjectName("nqx1,nqx2,nqx3"); layout->addRow("nqx1,nqx2,nqx3", editor);
editor = boolCombo(); editor->setObjectName("lda_plus_u"); layout->addRow("lda_plus_u", editor);
editor = new QSpinBox; editor->setObjectName("lda_plus_u_kind"); layout->addRow("lda_plus_u_kind", editor);
editor = new QDoubleSpinBox; editor->setObjectName("Hubbard_U(i),i=1,ntyp"); layout->addRow("Hubbard_U(i),i=1,ntyp", editor);
editor = new QDoubleSpinBox; editor->setObjectName("Hubbard_alpha(i),i=1,ntyp"); layout->addRow("Hubbard_alpha(i),i=1,ntyp", editor);
editor = new QDoubleSpinBox; editor->setObjectName("Hubbard_J(i,ityp)"); layout->addRow("Hubbard_J(i,ityp)", editor);
editor = new QDoubleSpinBox; editor->setObjectName("starting_ns_eigenvalue(m,ispin,I)"); layout->addRow("starting_ns_eigenvalue(m,ispin,I)", editor);
editor = new QLineEdit; editor->setObjectName("U_projection_type"); layout->addRow("U_projection_type", editor);
editor = new QSpinBox; editor->setObjectName("edir"); layout->addRow("edir", editor);
editor = new QDoubleSpinBox; editor->setObjectName("emaxpos"); layout->addRow("emaxpos", editor);
editor = new QDoubleSpinBox; editor->setObjectName("eopreg"); layout->addRow("eopreg", editor);
editor = new QDoubleSpinBox; editor->setObjectName("eamp"); layout->addRow("eamp", editor);
editor = new QDoubleSpinBox; editor->setObjectName("angle1(i),i=1,ntyp"); layout->addRow("angle1(i),i=1,ntyp", editor);
editor = new QDoubleSpinBox; editor->setObjectName("angle2(i),i=1,ntyp"); layout->addRow("angle2(i),i=1,ntyp", editor);
editor = new QLineEdit; editor->setObjectName("constrained_magnetization"); layout->addRow("constrained_magnetization", editor);
editor = new QDoubleSpinBox; editor->setObjectName("fixed_magnetization(1)"); layout->addRow("fixed_magnetization(1)", editor);
editor = new QDoubleSpinBox; editor->setObjectName("fixed_magnetization(2)"); layout->addRow("fixed_magnetization(2)", editor);
editor = new QDoubleSpinBox; editor->setObjectName("fixed_magnetization(3)"); layout->addRow("fixed_magnetization(3)", editor);
editor = new QDoubleSpinBox; editor->setObjectName("lambda"); layout->addRow("lambda", editor);
editor = new QSpinBox; editor->setObjectName("report"); layout->addRow("report", editor);
editor = boolCombo(); editor->setObjectName("lspinorb"); layout->addRow("lspinorb", editor);
editor = new QLineEdit; editor->setObjectName("assume_isolated"); layout->addRow("assume_isolated", editor);
editor = new QLineEdit; editor->setObjectName("esm_bc"); layout->addRow("esm_bc", editor);
editor = new QDoubleSpinBox; editor->setObjectName("esm_w"); layout->addRow("esm_w", editor);
editor = new QDoubleSpinBox; editor->setObjectName("esm_efield"); layout->addRow("esm_efield", editor);
editor = new QSpinBox; editor->setObjectName("esm_nfit"); layout->addRow("esm_nfit", editor);
editor = boolCombo(); editor->setObjectName("london"); layout->addRow("london", editor);
editor = new QDoubleSpinBox; editor->setObjectName("london_s6"); layout->addRow("london_s6", editor);
ret->setLayout(layout);
sa->setWidget(ret);
m_systemWidget = sa;
}
