void PatternAnalysisWizard::initFeatureGroup(void)
{
if(!m_table) return;
featureGroup->setExclusive(false);
bool zernike_added = false;
for (int c=0; c<m_table->GetNumberOfColumns(); ++c)
{
const char * name = m_table->GetColumnName(c);
std::string current_name = name;
if( current_name.find("train")!=std::string::npos || current_name.find("prediction")!=std::string::npos || current_name.find("confidence")!=std::string::npos || current_name.find("time")!=std::string::npos)
continue;
if( current_name.find("Zern")!=std::string::npos)
{
if(zernike_added == false)
{
QCheckBox * check = new QCheckBox("zernike moments");
check->setObjectName("zernikeMoments");
check->setChecked(true);
featureGroup->addButton(check, 0);
zernike_added = true;
}
continue;
}
QCheckBox * check = new QCheckBox(QString(name));
check->setObjectName(QString(name));
check->setChecked(true);
featureGroup->addButton(check, c);
}
}
void PatternAnalysisWizard::disabledFeatureGroup(void)
{
if(!m_table) return;
featureGroup->setExclusive(false);
bool zernike_added = false;
for (int d=0; d<mod_table->GetNumberOfColumns(); ++d)
{
const char * mod_name = mod_table->GetColumnName(d);
std::string model_name = mod_name;
if(model_name.find("Zern")!=std::string::npos)
{
if(zernike_added == false)
{
QCheckBox * check = new QCheckBox("zernike moments");
check->setObjectName("zernikeMoments");
check->setCheckable(false);
featureGroup->addButton(check);
zernike_added = true;
}
continue;
}
QCheckBox * check = new QCheckBox(QString(mod_name));
check->setObjectName(mod_name);
check->setCheckable(false);
featureGroup->addButton(check);
}
}
void DkAdvancedPreference::createLayout() {
// load RAW radio buttons
QVector<QRadioButton*> loadRawButtons;
loadRawButtons.resize(DkSettings::raw_thumb_end);
loadRawButtons[DkSettings::raw_thumb_always] = new QRadioButton(tr("Always Load JPG if Embedded"), this);
loadRawButtons[DkSettings::raw_thumb_if_large] = new QRadioButton(tr("Load JPG if it Fits the Screen Resolution"), this);
loadRawButtons[DkSettings::raw_thumb_never] = new QRadioButton(tr("Always Load RAW Data"), this);
// check wrt the current settings
loadRawButtons[Settings::param().resources().loadRawThumb]->setChecked(true);
QButtonGroup* loadRawButtonGroup = new QButtonGroup(this);
loadRawButtonGroup->setObjectName("loadRaw");
loadRawButtonGroup->addButton(loadRawButtons[DkSettings::raw_thumb_always], DkSettings::raw_thumb_always);
loadRawButtonGroup->addButton(loadRawButtons[DkSettings::raw_thumb_if_large], DkSettings::raw_thumb_if_large);
loadRawButtonGroup->addButton(loadRawButtons[DkSettings::raw_thumb_never], DkSettings::raw_thumb_never);
QCheckBox* cbFilterRaw = new QCheckBox(tr("Apply Noise Filtering to RAW Images"), this);
cbFilterRaw->setObjectName("filterRaw");
cbFilterRaw->setToolTip(tr("If checked, a noise filter is applied which reduced color noise"));
cbFilterRaw->setChecked(Settings::param().resources().filterRawImages);
DkGroupWidget* loadRawGroup = new DkGroupWidget(tr("RAW Loader Settings"), this);
loadRawGroup->addWidget(loadRawButtons[DkSettings::raw_thumb_always]);
loadRawGroup->addWidget(loadRawButtons[DkSettings::raw_thumb_if_large]);
loadRawGroup->addWidget(loadRawButtons[DkSettings::raw_thumb_never]);
loadRawGroup->addSpace();
loadRawGroup->addWidget(cbFilterRaw);
// file loading
QCheckBox* cbSaveDeleted = new QCheckBox(tr("Ask to Save Deleted Files"), this);
cbSaveDeleted->setObjectName("saveDeleted");
cbSaveDeleted->setToolTip(tr("If checked, nomacs asked to save files which were deleted by other applications"));
cbSaveDeleted->setChecked(Settings::param().global().askToSaveDeletedFiles);
QCheckBox* cbIgnoreExif = new QCheckBox(tr("Ignore Exif Orientation when Loading"), this);
cbIgnoreExif->setObjectName("ignoreExif");
cbIgnoreExif->setToolTip(tr("If checked, images are NOT rotated with respect to their Exif orientation"));
cbIgnoreExif->setChecked(Settings::param().metaData().ignoreExifOrientation);
QCheckBox* cbSaveExif = new QCheckBox(tr("Save Exif Orientation"), this);
cbSaveExif->setObjectName("saveExif");
cbSaveExif->setToolTip(tr("If checked, orientation is written to the Exif rather than rotating the image Matrix\n") +
tr("NOTE: this allows for rotating JPGs without loosing information."));
cbSaveExif->setChecked(Settings::param().metaData().saveExifOrientation);
DkGroupWidget* loadFileGroup = new DkGroupWidget(tr("File Loading/Saving"), this);
loadFileGroup->addWidget(cbSaveDeleted);
loadFileGroup->addWidget(cbIgnoreExif);
loadFileGroup->addWidget(cbSaveExif);
QVBoxLayout* layout = new QVBoxLayout(this);
layout->addWidget(loadRawGroup);
layout->addWidget(loadFileGroup);
}
void
PluginsPage::initializePage()
{
#ifdef Q_OS_WIN32
QList<IPluginInfo*> supportedPlugins = wizard()->pluginList()->supportedList();
foreach( IPluginInfo* plugin, supportedPlugins )
{
QCheckBox* cb;
m_pluginsLayout->addWidget( cb = new QCheckBox( plugin->name(), this ));
connect( cb, SIGNAL(toggled(bool)), plugin, SLOT(install(bool)));
connect( cb, SIGNAL(toggled(bool)), SLOT(checkPluginsSelected()));
cb->setObjectName( plugin->id() );
cb->setChecked( plugin->isAppInstalled() );
cb->style()->polish( cb );
if ( plugin->isInstalled() )
{
if ( plugin->version() > plugin->installedVersion() )
{
cb->setChecked( true );
cb->setText( cb->text() + " " + tr( "(newer version)" ));
}
else
{
cb->setChecked( false );
cb->setText( cb->text() + " " + tr( "(Plugin installed tick to reinstall)" ));
}
}
}
//加载完成
void SearchThread::slot_LoadFinished( QNetworkReply *replay )
{
QTextCodec *codec = QTextCodec::codecForName("utf8"); //转换成utf8编码格式
QString searchStr = codec->toUnicode(replay->readAll());
if (searchStr == "")
{
emit sig_SearchTimeout(); //搜索超时
return;
}
searchStr = QUrl::fromPercentEncoding(searchStr.toAscii()); //百分比编码
//解析Json
QJson::Parser parser;
bool ok;
QVariantMap result = parser.parse(searchStr.toUtf8(), &ok).toMap();
if (!ok)
{
qDebug() << "转换成QVariantMap失败";
return;
}
//搜索到的数量
m_nMusicNum = result["total"].toInt();
emit sig_SearchNum(m_nMusicNum);
//得到结果数组
QVariantList resultList = result["results"].toList();
foreach (QVariant var, resultList)
{
QVariantMap resultMap = var.toMap(); //得到每一项的map
//歌曲名
QCheckBox *musicNameCheckBox = new QCheckBox(resultMap["song_name"].toString());
musicNameCheckBox->setObjectName(tr("musicNameCheckBox"));
musicNameCheckBox->setToolTip(resultMap["song_name"].toString());
musicNameCheckBox->setFont(QFont("微软雅黑", 10));
musicNameCheckBox->setStyleSheet("QCheckBox{color:white;}"
"QCheckBox::indicator{width:10px;height:10px;border: 1px solid white;border-radius:2px}"
"QCheckBox::indicator:checked {image: url(:/app/images/checked2.png);}");
//艺人
QTableWidgetItem *artistItem = new QTableWidgetItem(resultMap["artist_name"].toString());
artistItem->setTextAlignment(Qt::AlignCenter);
artistItem->setToolTip(resultMap["artist_name"].toString());
artistItem->setFont(QFont("微软雅黑", 10));
//专辑
QTableWidgetItem *albumItem = new QTableWidgetItem("《" + resultMap["album_name"].toString() + "》");
albumItem->setTextAlignment(Qt::AlignLeft | Qt::AlignVCenter);
albumItem->setToolTip("《" + resultMap["album_name"].toString() + "》");
albumItem->setFont(QFont("微软雅黑", 10));
//插入播放列表
int currentRows = m_searchList->rowCount();//返回列表中的行数
m_searchList->insertRow(currentRows);//从播放列表中的当前行插入
m_searchList->setCellWidget(currentRows, 0, musicNameCheckBox);
m_searchList->setItem(currentRows, 1, artistItem);
m_searchList->setItem(currentRows, 2, albumItem);
}
QCheckBox* LayoutManager::copyCheckBox(QObject* obj) {
QCheckBox *oldCheckBox = qobject_cast<QCheckBox*>(obj);
QCheckBox *newCheckBox = new QCheckBox();
newCheckBox->setText(oldCheckBox->text());
newCheckBox->setObjectName(oldCheckBox->objectName() + " " + QString::number(keyLayouts.size()));
return newCheckBox;
}
QWidget* CheckBoxListDelegate::createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const
{
// Create check box as our editor.
QCheckBox* editor = new QCheckBox(parent);
editor->setObjectName("checkBoxListItem");
connect(editor, SIGNAL(stateChanged(int)), this, SLOT(checkBoxStateChanged()));
return editor;
}
void TestQTestComplex::pl_checkbox_text()
{
QCheckBox *cb = new QCheckBox();
cb->setObjectName("cb");
cb->setText("Let's cause a memory leak!");
delete cb;
}
bool KvsObject_checkBox::init(KviKvsRunTimeContext *,KviKvsVariantList *)
{
QCheckBox * cb = new QCheckBox(parentScriptWidget());
cb->setObjectName(getName().toUtf8().data());
setObject(cb, true);
connect(cb,SIGNAL(toggled(bool)),this,SLOT(toggled(bool)));
connect(widget(),SIGNAL(clicked()),this,SLOT(slotClicked()));
return true;
}
QWidget *ServerDialog::createPackageTab() {
extension_group = new QButtonGroup;
extension_group->setExclusive(false);
QStringList extensions = Sanguosha->getExtensions();
QSet<QString> ban_packages = Config.BanPackages.toSet();
QGroupBox *box1 = new QGroupBox(tr("General package"));
QGroupBox *box2 = new QGroupBox(tr("Card package"));
QVBoxLayout *layout1 = new QVBoxLayout;
QVBoxLayout *layout2 = new QVBoxLayout;
box1->setLayout(layout1);
box2->setLayout(layout2);
foreach(QString extension, extensions) {
const Package *package = Sanguosha->findChild<const Package *>(extension);
if(package == NULL)
continue;
QCheckBox *checkbox = new QCheckBox;
checkbox->setObjectName(extension);
checkbox->setText(Sanguosha->translate(extension));
checkbox->setChecked(! ban_packages.contains(extension));
extension_group->addButton(checkbox);
switch(package->getType()) {
case Package::GeneralPack: {
layout1->addWidget(checkbox);
break;
}
case Package::CardPack: {
layout2->addWidget(checkbox);
break;
}
default:
break;
}
}
layout1->addStretch();
layout2->addStretch();
QWidget *widget = new QWidget;
QHBoxLayout *layout = new QHBoxLayout;
layout->addWidget(box1);
layout->addWidget(box2);
widget->setLayout(layout);
return widget;
}
QWidget* PropertyEditor::createWidgetForBool(const QString& name, bool value, const QString &detail, QWidget* parent)
{
mProperties[name] = value;
QCheckBox *box = new QCheckBox(QObject::tr(name.toUtf8().constData()), parent);
if (!detail.isEmpty())
box->setToolTip(detail);
box->setObjectName(name);
box->setChecked(value);
connect(box, SIGNAL(clicked(bool)), SLOT(onBoolChange(bool)));
return box;
}
void MainWindow::addNewItem()
{
// copied from ui_itemFrame.h
QHBoxLayout *itemLayout = new QHBoxLayout();
itemLayout->setObjectName(QString::fromUtf8("itemLayout"));
itemLayout->setSizeConstraint(QLayout::SetFixedSize);
QCheckBox *haveFoundCheckBox = new QCheckBox();
haveFoundCheckBox->setObjectName(QString::fromUtf8("haveFoundCheckBox"));
haveFoundCheckBox->setMinimumHeight(30);
itemLayout->addWidget(haveFoundCheckBox);
QLineEdit *amountBox = new QLineEdit();
amountBox->setObjectName(QString::fromUtf8("amountBox"));
amountBox->setMaximumSize(QSize(80, 16777215));
amountBox->setMinimumHeight(38);
amountBox->setMinimumWidth(100);
itemLayout->addWidget(amountBox);
QLineEdit *itemName = new QLineEdit();
itemName->setObjectName(QString::fromUtf8("itemName"));
itemName->setMinimumHeight(38);
itemName->setMinimumWidth(300);
itemLayout->addWidget(itemName);
QSpacerItem *horizontalSpacer = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
itemLayout->addItem(horizontalSpacer);
QPushButton *deleteButton = new QPushButton();
deleteButton->setObjectName(QString::fromUtf8("deleteButton"));
deleteButton->setText("Remove");
deleteButton->setMinimumHeight(38);
//deleteButton->setCenterButtons(false);
itemLayout->addWidget(deleteButton);
// end of copied from ui_itemFrame.h
// Doesn't work atm?
//QObject::connect(deleteButton, SIGNAL(clicked(QAbstractButton*)), haveFoundCheckBox, SLOT(deleteLater()));
QObject::connect(deleteButton, SIGNAL(clicked()), amountBox, SLOT(deleteLater()));
QObject::connect(deleteButton, SIGNAL(clicked()), itemName, SLOT(deleteLater()));
QObject::connect(deleteButton, SIGNAL(clicked()), deleteButton, SLOT(deleteLater()));
QObject::connect(deleteButton, SIGNAL(clicked()), haveFoundCheckBox, SLOT(deleteLater()));
QObject::connect(deleteButton, SIGNAL(clicked()), itemLayout, SLOT(deleteLater()));
QObject::connect(deleteButton, SIGNAL(clicked()), this,SLOT(itemWasRemoved()));
ui->mainLayout->addLayout(itemLayout);
widgetsize+=80; // in principle should also reduce when removing item, need to create a slot...
ui->scrollAreaContents->setFixedHeight(widgetsize);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void QCheckboxDialog::setupGui()
{
QVBoxLayout* verticalLayout_2 = new QVBoxLayout(this);
foreach(QString str, m_List)
{
QCheckBox* cb = new QCheckBox(this);
cb->setText(str);
cb->setObjectName(str);
cb->setChecked(true);
verticalLayout_2->addWidget(cb);
m_WidgetMap.insert(str, cb);
}
Content::Content(QWidget *parent) :
QWidget(parent)
{
//
VGroup1 = new QGroupBox(tr("Параметры"));
Param=new params();
verLayot1= new QVBoxLayout();
verLayot2= new QVBoxLayout();
for(int i=0; i<Param->getListofparam().length(); i++ )
{
param tec_name=Param->getListofparam()[i];
if(tec_name.type=="QCheckBox")
{
QCheckBox *Checkparam =new QCheckBox();
Checkparam->setText(tec_name.printValue);
Checkparam->setObjectName(tec_name.name);
verLayot1->addWidget(Checkparam);
connect(Checkparam,SIGNAL(stateChanged(int)),this,SLOT(SetParamCheckBox(int)));
}
if(tec_name.type=="QLineEdit")
{
QLineEdit *LineEdit =new QLineEdit();
LineEdit->setText(tec_name.printValue);
LineEdit->setObjectName(tec_name.name);
verLayot1->addWidget(LineEdit);
connect(LineEdit,SIGNAL(textChanged(QString)),this,SLOT(SetTextEdit(QString)));
}
if(tec_name.type=="QLabel")
{
QLabel *Labelparam=new QLabel();
Labelparam->setText(tec_name.printValue);
Labelparam->setObjectName(tec_name.name);
// connect(Param,SIGNAL(FolderChange(QString)),this,SLOT(SetLabelName(QString)));
verLayot2->addWidget(Labelparam);
}
}
void PreferencesDialog::initialize(PreferencesTab initialTab, const Persistence::Settings *settings, const QMap<QString, QString> &jamRecorders)
{
Q_UNUSED(initialTab);
this->settings = settings;
this->jamRecorders = jamRecorders;
this->jamRecorderCheckBoxes = QMap<QCheckBox *, QString>();
foreach(const QString &jamRecorder, jamRecorders.keys()) {
QCheckBox *myCheckBox = new QCheckBox(this);
myCheckBox->setObjectName(jamRecorder);
myCheckBox->setText(jamRecorders.value(jamRecorder));
ui->layoutRecorders->addWidget(myCheckBox);
jamRecorderCheckBoxes[myCheckBox] = jamRecorder;
}
setupSignals();
populateAllTabs();
}
void PreferencesDialog::initialize(PreferencesTab initialTab, const persistence::Settings *settings, const QMap<QString, QString> &jamRecorders)
{
Q_UNUSED(initialTab);
this->settings = settings;
this->jamRecorders = jamRecorders;
this->jamRecorderCheckBoxes = QMap<QCheckBox *, QString>();
this->jamDateFormatRadioButtons = QMap<const QRadioButton *, QString>();
for (const auto &jamRecorder : jamRecorders.keys()) {
QCheckBox *myCheckBox = new QCheckBox(this);
myCheckBox->setObjectName(jamRecorder);
myCheckBox->setText(jamRecorders.value(jamRecorder));
ui->layoutRecorders->addWidget(myCheckBox);
jamRecorderCheckBoxes[myCheckBox] = jamRecorder;
}
QDateTime now = QDateTime::currentDateTime();
Qt::DateFormat dateFormat;
QString nowString;
QRadioButton *myRadioButton;
dateFormat = Qt::TextDate;
nowString = "Jam-" + now.toString(dateFormat).replace(QRegExp("[/:]"), "-").replace(QRegExp("[ ]"), "_");
myRadioButton = new QRadioButton(this);
myRadioButton->setObjectName("rbdfTextDate");
myRadioButton->setText(nowString);
myRadioButton->setProperty("buttonGroup", "rbDateFormat");
ui->layoutDateFormats->addWidget(myRadioButton);
jamDateFormatRadioButtons[myRadioButton] = "Qt::TextDate";
dateFormat = Qt::ISODate;
nowString = "Jam-" + now.toString(dateFormat).replace(QRegExp("[/:]"), "-").replace(QRegExp("[ ]"), "_");
myRadioButton = new QRadioButton(this);
myRadioButton->setObjectName("rbdfISODate");
myRadioButton->setText(nowString);
myRadioButton->setProperty("buttonGroup", "rbDateFormat");
ui->layoutDateFormats->addWidget(myRadioButton);
jamDateFormatRadioButtons[myRadioButton] = "Qt::ISODate";
setupSignals();
populateAllTabs();
}
void ItemHandlerCheckbox::Handle (const QDomElement& item,
QWidget *pwidget)
{
QGridLayout *lay = qobject_cast<QGridLayout*> (pwidget->layout ());
QCheckBox *box = new QCheckBox (XSD_->GetLabel (item));
box->setObjectName (item.attribute ("property"));
QVariant value = XSD_->GetValue (item);
box->setCheckState (value.toBool () ? Qt::Checked : Qt::Unchecked);
connect (box,
SIGNAL (stateChanged (int)),
this,
SLOT (updatePreferences ()));
box->setProperty ("ItemHandler",
QVariant::fromValue<QObject*> (this));
lay->addWidget (box, lay->rowCount (), 0, 1, 2, Qt::AlignTop);
}
void ClassifiersWidget::slotUpdateContent(){
QDir* d = new QDir(Settings::octaveScriptsRoot()+"/Classifiers");
if(d->exists()){
manageCheckboxConnections(false);
boxes->clear();
if(dataPane!=NULL){
stackedLayout->removeWidget(dataPane);
delete dataPane;
dataPane = NULL;
}
dataPane = new QWidget(this);
QFormLayout* formLayout = new QFormLayout();
qDebug()<<"Classifiers directory exists";
dataPane->setLayout(formLayout);
QDirIterator dirs(d->absolutePath(), QDir::Dirs|QDir::NoDotAndDotDot ,QDirIterator::NoIteratorFlags);
while(dirs.hasNext()){
dirs.next();
QString name = dirs.fileName();
name = name.right(name.length()-1);
qDebug() << name;
Settings::addRuntimeClassifier(name);
QCheckBox* cb = new QCheckBox();
cb->setObjectName(name);
if(Settings::classifierEnabled(name)){
cb->setChecked(true);
}
QLabel* label = new QLabel(name);
formLayout->addRow(label, cb);
boxes->append(cb);
}
dataPane->setLayout(formLayout);
stackedLayout->insertWidget(1, dataPane);
stackedLayout->setCurrentIndex(1);
manageCheckboxConnections(true);
}else{
stackedLayout->setCurrentIndex(0);
}
}
void MainWindow::populateLineGraphActorsList()
{
QCheckBox * actor;
lineGraphActorsCheckBoxList.clear();
lineGraphCheckedActorsIdList.clear();
lineActorCBList.clear();
QWidget* widget = new QWidget;
QVBoxLayout *layout = new QVBoxLayout(widget);
for(int actorsCount = 0; actorsCount < actorsName.count(); ++actorsCount)
{
actor = new QCheckBox(actorsName.at(actorsCount));
actor->setChecked(true);
QColor mycolor = colorsList.at(actorsCount);
QString style = "background: rgb(%1, %2, %3);";
style = style.arg(mycolor.red()).arg(mycolor.green()).arg(mycolor.blue());
style += "color:white; font-size:15px;";
style += "font-weight:bold;";
actor->setStyleSheet(style);
actor->setObjectName(QString::number(actorsCount));
layout->addWidget(actor);
layout->stretch(0);
lineGraphActorsCheckBoxList.append(actor);
//setting all checkboxes as checked as initial condition
lineGraphCheckedActorsIdList.append(true);
connect(actor,SIGNAL(toggled(bool)),this,SLOT(lineGraphActorsCheckboxClicked(bool)));
lineActorCBList.append(actor);
}
lineGraphActorsScrollArea->setWidget(widget);
}
QCheckBox* VOptionable::addCheckBox(QLayout* layout, QString objectName, QString text, bool value)
{
QWidget* parentWidget = layout->parentWidget();
if (parentWidget == NULL)
{
LOG_FATAL("parentWidget is null(%s)", qPrintable(objectName));
return NULL;
}
if (parentWidget->findChild<QObject*>(objectName) != NULL)
{
LOG_FATAL("parentWidget->findChild(%s) is not null", qPrintable(objectName));
return NULL;
}
QCheckBox* checkBox = new QCheckBox(parentWidget);
checkBox->setObjectName(objectName);
checkBox->setText(text);
checkBox->setCheckState(value ? Qt::Checked : Qt::Unchecked);
layout->addWidget(checkBox);
return checkBox;
}
void LDViewExportOption::populate(void)
{
QWidget *parent;
parent = m_box;
LDExporterSettingList &settings = m_exporter->getSettings();
LDExporterSettingList::iterator it;
if (m_box != NULL)
{
// scrollArea->removeChild(m_box);
scrollArea->adjustSize();
delete m_box;
}
m_box = new QWidget(scrollArea);
m_box->setObjectName("m_box");
m_lay = new QVBoxLayout();
m_lay->setObjectName("m_lay");
m_lay->setMargin(11);
m_lay->setSpacing(4);
m_box->setLayout(m_lay);
QVBoxLayout *vbl= NULL;
std::stack<int> groupSizes;
std::stack<QWidget *> parents;
int groupSize = 0;
for (it = settings.begin(); it != settings.end(); it++)
{
bool inGroup = groupSize > 0;
if (groupSize > 0)
{
groupSize--;
if (groupSize == 0)
{
// We just got to the end of a group, so pop the previous
// groupSize value off the groupSizes stack.
groupSize = groupSizes.top();
groupSizes.pop();
parent = parents.top();
parents.pop();
// vbl = new QVBoxLayout(parent->layout());
//vbl = NULL;
}
}
if (it->getGroupSize() > 0)
{
// This item is the start of a group.
if (inGroup)
{
// At the beginning of this iteration we were in a group, so
// use a bool setting instead of a group setting.
QString qstmp;
ucstringtoqstring(qstmp,it->getName());
QCheckBox *check;
check = new QCheckBox(qstmp,parent);
check->setObjectName(qstmp);
check->setChecked(it->getBoolValue());
m_settings[&*it] = check;
if (vbl)
{
vbl->addWidget(check);
m_groups[vbl][&*it] = check;
}
}
else
{
// Top level group; use a group setting.
if (vbl)
{
QSpacerItem *sp = new QSpacerItem(20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
QHBoxLayout *hbox;
QPushButton *rg;
hbox = new QHBoxLayout();
rg = new QPushButton("Reset Group");
hbox->addItem(sp);
hbox->addWidget(rg);
rg->setObjectName("Reset Group");
vbl->addLayout(hbox);
connect( rg, SIGNAL( clicked() ), this, SLOT( doResetGroup() ) );
}
QString qstmp;
ucstringtoqstring(qstmp,it->getName());
QGroupBox *gb;
gb = new QGroupBox (qstmp, m_box);
gb->setObjectName(qstmp);
m_lay->addWidget(gb);
vbl = new QVBoxLayout(gb);
gb->setLayout(vbl);
parent=gb;
if (it->getType() == LDExporterSetting::TBool)
{
gb->setCheckable(true);
gb->setChecked(it->getBoolValue());
m_settings[&*it] = gb;
m_groups[vbl][&*it] = gb;
}
}
parents.push(parent);
// We're now in a new group, so push the current groupSize onto
// the groupSizes stack.
groupSizes.push(groupSize);
// Update groupSize based on the new group's size.
groupSize = it->getGroupSize();
}
else
{
// This setting isn't the start of a group; add the appropriate type
// of option UI to the canvas.
QString qstmp;
ucstringtoqstring(qstmp,it->getName());
QHBoxLayout *hbox;
QVBoxLayout *vbox;
QLineEdit *li;
QLabel *label;
QHBoxLayout *hbox2;
QCheckBox *check;
hbox = new QHBoxLayout();
hbox->setSpacing(4);
switch (it->getType())
{
case LDExporterSetting::TBool:
check = new QCheckBox(qstmp);
check->setChecked(it->getBoolValue());
check->setObjectName(qstmp);
hbox->addWidget(check);
m_settings[&*it] = check;
if (vbl != NULL)
{
m_groups[vbl][&*it] = check;
}
break;
case LDExporterSetting::TFloat:
case LDExporterSetting::TLong:
// Long and float are intentionally handeled the same.
label = new QLabel(qstmp);
label->setObjectName(qstmp);
hbox->addWidget(label);
li = new QLineEdit(qstmp);
li->setObjectName(qstmp);
hbox->addWidget(li);
ucstringtoqstring(qstmp,it->getStringValue());
li->setText(qstmp);
m_settings[&*it] = li;
if (vbl != NULL)
{
m_groups[vbl][&*it] = li;
}
break;
case LDExporterSetting::TString:
vbox = new QVBoxLayout();
vbox->setSpacing(4);
hbox->addLayout(vbox);
label = new QLabel(qstmp);
vbox->addWidget(label);
hbox2 = new QHBoxLayout();
hbox2->setSpacing(4);
vbox->addLayout(hbox2);
li = new QLineEdit(qstmp);
hbox2->addWidget(li);
ucstringtoqstring(qstmp,it->getStringValue());
li->setText(qstmp);
m_settings[&*it] = li;
if (vbl != NULL)
{
m_groups[vbl][&*it] = li;
}
if (it->isPath())
{
QPushButton *but = new QPushButton();
but->setText(TCObject::ls("LDXBrowse..."));
hbox2->addWidget(but);
connect( but, SIGNAL( clicked() ), this, SLOT( doBrowse()));
m_button[but]=li;
}
break;
case LDExporterSetting::TEnum:
vbox = new QVBoxLayout();
vbox->setSpacing(4);
hbox->addLayout(vbox);
label = new QLabel(qstmp);
vbox->addWidget(label);
QComboBox *combo;
combo = new QComboBox();
vbox->addWidget(combo);
for (size_t i = 0; i < it->getOptions().size(); i++)
{
ucstringtoqstring(qstmp,it->getOptions()[i]);
combo->addItem(qstmp);
}
combo->setCurrentIndex(it->getSelectedOption());
m_settings[&*it] = combo;
if (vbl != NULL)
{
m_groups[vbl][&*it] = combo;
}
break;
default:
throw "not implemented";
}
if (it->getTooltip().size() > 0)
{
ucstringtoqstring(qstmp, it->getTooltip());
//QToolTip::add(hbox, qstmp);
}
if (vbl) vbl->addLayout(hbox);
}
}
if (vbl)
{
QSpacerItem *sp = new QSpacerItem(20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
QHBoxLayout *hbox;
QPushButton *rg;
hbox = new QHBoxLayout();
rg = new QPushButton("Reset Group");
rg->setObjectName("Reset Group");
hbox->addItem(sp);
hbox->addWidget(rg);
vbl->addLayout(hbox);
connect( rg, SIGNAL( clicked() ), this, SLOT( doResetGroup() ) );
}
m_lay->addStretch();
scrollArea->setWidget(m_box);
m_box->adjustSize();
scrollArea->adjustSize();
// resize(width() + m_box->width() - scrollArea->visibleWidth(), height());
setFixedWidth(width());
}
QWidget* WidgetStyle::createWidget(const QString& name)
{
if(name == "CheckBox")
{
QCheckBox* box = new QCheckBox("CheckBox");
box->setObjectName("CheckBox");
return setLayoutWidget({ box }, { 100, 30 });
}
else if(name == "ComboBox")
{
QComboBox* box = new QComboBox;
box->addItem("Item1");
box->addItem("Item3");
box->addItem("Item3");
box->setObjectName("ComboBox");
return setLayoutWidget({ box }, { 70, 30 });
}
else if(name == "DateEdit")
{
QDateEdit* date = new QDateEdit;
date->setObjectName("DateEdit");
return setLayoutWidget({ date }, { 110, 40 });
}
else if(name == "DateTimeEdit")
{
QDateTimeEdit* date = new QDateTimeEdit;
date->setObjectName("DateTimeEdit");
return setLayoutWidget({ date }, { 160, 30 });
}
else if(name == "Dialog")
{
QDialog* dialog = new QDialog;
dialog->setObjectName("Dialog");
return setLayoutWidget({ dialog }, { 160, 110 });
}
else if(name == "DockWidget") //?
{
QDockWidget* widget = new QDockWidget;
widget->setObjectName("DockWidget");
widget->resize(61, 22);
return widget;
}
else if(name == "DoubleSpinBox")
{
QDoubleSpinBox* box = new QDoubleSpinBox;
box->setObjectName("DoubleSpinBox");
return setLayoutWidget({ box }, { 90, 40 });
}
else if(name == "Frame") //??
{
QFrame* frame = new QFrame;
frame->setObjectName("Frame");
frame->resize(150, 100);
return frame;
}
else if(name == "GroupBox")
{
QGroupBox* box = new QGroupBox("GroupBox");
box->setObjectName("GroupBox");
return setLayoutWidget({ box }, { 160, 110 });
}
else if(name == "Label")
{
QLabel* label = new QLabel("Label");
label->setObjectName("Label");
return setLayoutWidget({ label }, { 40, 20});
}
else if(name == "LineEdit")
{
QLineEdit* line = new QLineEdit;
line->setObjectName("LineEdit");
return setLayoutWidget({ line }, { 30, 30 });
}
else if(name == "ListView") //??
{
QListView* view = new QListView;
view->setObjectName("ListView");
view->resize(71, 71);
return view;
}
else if(name == "ListWidget")
{
QListWidget* list = new QListWidget;
list->setObjectName("ListWidget");
for(int i = 0; i < 20; i++)
list->addItem(QString("Item %1").arg(i));
return setLayoutWidget({ list }, { 80, 80 });
}
else if(name == "MainWindow")
{
QMainWindow* window = new QMainWindow;
window->setObjectName("MainWindow");
return setLayoutWidget({ window }, { 160, 110 });
}
else if(name == "Menu")
{
QMenu* parentMenu = new QMenu;
parentMenu->setObjectName("Menu");
parentMenu->addMenu("Menu1");
QMenu* menu1 = parentMenu->addMenu("Menu2");
menu1->addMenu("Menu1");
menu1->addMenu("Menu2");
parentMenu->addSeparator();
parentMenu->addMenu("Menu3");
return setLayoutWidget({ parentMenu }, { 160, 110 });
}
else if(name == "MenuBar")
{
QMenuBar* bar = new QMenuBar;
bar->setObjectName("QMenuBar");
QMenu* menu1 = bar->addMenu("MenuBar1");
menu1->addMenu("Menu1");
menu1->addSeparator();
menu1->addMenu("Menu2");
QMenu* menu2 = bar->addMenu("MenuBar2");
menu2->addMenu("Menu1");
menu2->addSeparator();
menu2->addMenu("Menu2");
QMenu* menu3 = bar->addMenu("MenuBar3");
menu3->addMenu("Menu1");
menu3->addSeparator();
menu3->addMenu("Menu2");
return setLayoutWidget({ bar }, { 280, 60 });
}
else if(name == "ProgressBar")
{
QProgressBar* bar = new QProgressBar;
bar->setObjectName("ProgressBar");
bar->setRange(0, 100);
bar->setValue(0);
QTimer* timer = new QTimer(bar);
this->connect(timer, &QTimer::timeout, this, [bar]()
{
if(bar->value() == 100)
bar->setValue(0);
else
bar->setValue(bar->value() + 1);
});
timer->start(100);
return setLayoutWidget({ bar }, { 110, 30 });
}
else if(name == "PushButton")
{
QPushButton* button = new QPushButton("PushButton");
button->setObjectName("PushButton");
return setLayoutWidget({ button }, { 125, 30 });
}
else if(name == "RadioButton")
{
QRadioButton* button = new QRadioButton("RadioButton");
button->setObjectName("RadioButton");
return setLayoutWidget({ button }, { 125, 30 });
}
else if(name == "ScrollBar")
{
QScrollBar* barH = new QScrollBar(Qt::Horizontal);
QScrollBar* barV = new QScrollBar(Qt::Vertical);
barH->setObjectName("ScrollBarH");
barV->setObjectName("ScrollBarV");
return setLayoutWidget({ barH, barV }, { 200, 100 });
}
else if(name == "Slider")
{
QSlider* sliderH = new QSlider(Qt::Horizontal);
QSlider* sliderV = new QSlider(Qt::Vertical);
sliderH->setObjectName("SliderH");
sliderV->setObjectName("SliderV");
return setLayoutWidget({ sliderH, sliderV }, { 200, 100 });
}
else if(name == "SpinBox")
{
QSpinBox* spinBox = new QSpinBox;
spinBox->setObjectName("SpinBox");
return setLayoutWidget({ spinBox }, { 60, 35 });
}
else if(name == "Splitter")
{
QSplitter* splitterV = new QSplitter(Qt::Vertical);
QSplitter* splitterH = new QSplitter(Qt::Horizontal);
splitterV->setObjectName("SplitterV");
splitterH->setObjectName("SplitterH");
splitterV->addWidget(new QPushButton("PushButton1"));
splitterV->addWidget(new QPushButton("PushButton2"));
splitterH->addWidget(splitterV);
splitterH->addWidget(new QPushButton("PushButton3"));
return setLayoutWidget({ splitterH }, { 250, 110 });
}
else if(name == "TabWidget")
{
QTabWidget* tab = new QTabWidget;
tab->addTab(new QWidget, "Widget1");
tab->addTab(new QWidget, "Widget2");
tab->addTab(new QWidget, "Widget3");
tab->setObjectName("TabWidget");
return setLayoutWidget({ tab }, { 210, 110 });
}
else if(name == "TableView") //?
{
QTableView* view = new QTableView;
view->setObjectName("TableView");
view->resize(200, 100);
return view;
}
else if(name == "TableWidget")
{
const int n = 100;
QStringList list = { "one", "two", "three" };
QTableWidget* table = new QTableWidget(n, n);
table->setObjectName("TableWidget");
table->setHorizontalHeaderLabels(list);
table->setVerticalHeaderLabels(list);
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
table->setItem(i, j, new QTableWidgetItem(QString("%1, %2").arg(i).arg(j)));
return setLayoutWidget({ table }, { 210, 110 });
}
else if(name == "TextEdit")
{
QTextEdit* text = new QTextEdit;
text->setObjectName("TextEdit");
return setLayoutWidget({ text }, { 80, 80 });
}
else if(name == "TimeEdit")
{
QTimeEdit* time = new QTimeEdit;
time->setObjectName("TimeEdit");
return setLayoutWidget({ time }, { 80, 80 });
}
else if(name == "ToolButton")
{
QToolButton* button = new QToolButton;
button->setText("ToolButton");
button->setObjectName("ToolButton");
return setLayoutWidget({ button }, { 95, 25 });
}
else if(name == "ToolBox")
{
QToolBox* box = new QToolBox;
box->addItem(new QWidget, "Widget1");
box->addItem(new QWidget, "Widget2");
box->addItem(new QWidget, "Widget3");
box->setObjectName("ToolBox");
return setLayoutWidget({ box }, { 110, 180 });
}
else if(name == "TreeView") //?
{
QTreeView* tree = new QTreeView;
tree->setObjectName("TreeView");
tree->resize(200, 100);
return tree;
}
else if(name == "TreeWidget")
{
QTreeWidget* tree = new QTreeWidget;
tree->setObjectName("TreeWidget");
tree->setHeaderLabels({ "Folders", "Used Space" });
QTreeWidgetItem* item = new QTreeWidgetItem(tree);
item->setText(0, "Local Disk");
for(int i = 1; i < 20; i++)
{
QTreeWidgetItem* dir = new QTreeWidgetItem(item);
dir->setText(0, "Directory" + QString::number(i));
dir->setText(1, QString::number(i) + "MB");
}
tree->setItemExpanded(item, true);
return setLayoutWidget({ tree }, { 210, 110 });
}
else if(name == "Widget")
{
QWidget* widget = new QWidget;
widget->setObjectName("Widget");
return setLayoutWidget({ widget }, { 210, 110 });
}
return nullptr;
}
void DkDisplayPreference::createLayout() {
// zoom settings
QCheckBox* invertZoom = new QCheckBox(tr("Invert mouse wheel behaviour for zooming"), this);
invertZoom->setObjectName("invertZoom");
invertZoom->setToolTip(tr("If checked, the mouse wheel behaviour is inverted while zooming."));
invertZoom->setChecked(Settings::param().display().invertZoom);
QLabel* interpolationLabel = new QLabel(tr("Show pixels if zoom level is above"), this);
QSpinBox* sbInterpolation = new QSpinBox(this);
sbInterpolation->setObjectName("interpolationBox");
sbInterpolation->setToolTip(tr("nomacs will not interpolate images if the zoom level is larger."));
sbInterpolation->setSuffix("%");
sbInterpolation->setMinimum(0);
sbInterpolation->setMaximum(10000);
sbInterpolation->setValue(Settings::param().display().interpolateZoomLevel);
DkGroupWidget* zoomGroup = new DkGroupWidget(tr("Zoom"), this);
zoomGroup->addWidget(invertZoom);
zoomGroup->addWidget(interpolationLabel);
zoomGroup->addWidget(sbInterpolation);
// keep zoom radio buttons
QVector<QRadioButton*> keepZoomButtons;
keepZoomButtons.resize(DkSettings::zoom_end);
keepZoomButtons[DkSettings::zoom_always_keep] = new QRadioButton(tr("Always keep zoom"), this);
keepZoomButtons[DkSettings::zoom_keep_same_size] = new QRadioButton(tr("Keep zoom if the size is the same"), this);
keepZoomButtons[DkSettings::zoom_keep_same_size]->setToolTip(tr("If checked, the zoom level is only kept, if the image loaded has the same level as the previous."));
keepZoomButtons[DkSettings::zoom_never_keep] = new QRadioButton(tr("Never keep zoom"), this);
QCheckBox* cbZoomToFit = new QCheckBox(tr("Always zoom to fit"), this);
cbZoomToFit->setObjectName("zoomToFit");
cbZoomToFit->setChecked(Settings::param().display().zoomToFit);
// check wrt the current settings
keepZoomButtons[Settings::param().display().keepZoom]->setChecked(true);
QButtonGroup* keepZoomButtonGroup = new QButtonGroup(this);
keepZoomButtonGroup->setObjectName("keepZoom");
keepZoomButtonGroup->addButton(keepZoomButtons[DkSettings::zoom_always_keep], DkSettings::zoom_always_keep);
keepZoomButtonGroup->addButton(keepZoomButtons[DkSettings::zoom_keep_same_size], DkSettings::zoom_keep_same_size);
keepZoomButtonGroup->addButton(keepZoomButtons[DkSettings::zoom_never_keep], DkSettings::zoom_never_keep);
DkGroupWidget* keepZoomGroup = new DkGroupWidget(tr("When Displaying New Images"), this);
keepZoomGroup->addWidget(keepZoomButtons[DkSettings::zoom_always_keep]);
keepZoomGroup->addWidget(keepZoomButtons[DkSettings::zoom_keep_same_size]);
keepZoomGroup->addWidget(keepZoomButtons[DkSettings::zoom_never_keep]);
keepZoomGroup->addWidget(cbZoomToFit);
// icon size
QSpinBox* sbIconSize = new QSpinBox(this);
sbIconSize->setObjectName("iconSizeBox");
sbIconSize->setToolTip(tr("Define the icon size in pixel."));
sbIconSize->setSuffix(" px");
sbIconSize->setMinimum(16);
sbIconSize->setMaximum(1024);
sbIconSize->setValue(Settings::param().display().iconSize);
DkGroupWidget* iconGroup = new DkGroupWidget(tr("Icon Size"), this);
iconGroup->addWidget(sbIconSize);
// slideshow
QLabel* fadeImageLabel = new QLabel(tr("Image Transition"), this);
QComboBox* cbTransition = new QComboBox(this);
cbTransition->setObjectName("transition");
cbTransition->setToolTip(tr("Choose a transition when loading a new image"));
for (int idx = 0; idx < DkSettings::trans_end; idx++) {
QString str = tr("Unknown Transition");
switch (idx) {
case DkSettings::trans_appear: str = tr("Appear"); break;
case DkSettings::trans_swipe: str = tr("Swipe"); break;
case DkSettings::trans_fade: str = tr("Fade"); break;
}
cbTransition->addItem(str);
}
cbTransition->setCurrentIndex(Settings::param().display().transition);
QDoubleSpinBox* fadeImageBox = new QDoubleSpinBox(this);
fadeImageBox->setObjectName("fadeImageBox");
fadeImageBox->setToolTip(tr("Define the image transition speed."));
fadeImageBox->setSuffix(" sec");
fadeImageBox->setMinimum(0.0);
fadeImageBox->setMaximum(3);
fadeImageBox->setSingleStep(.2);
fadeImageBox->setValue(Settings::param().display().animationDuration);
QCheckBox* cbAlwaysAnimate = new QCheckBox(tr("Always Animate Image Loading"), this);
cbAlwaysAnimate->setObjectName("alwaysAnimate");
cbAlwaysAnimate->setToolTip(tr("If unchecked, loading is only animated if nomacs is fullscreen"));
cbAlwaysAnimate->setChecked(Settings::param().display().alwaysAnimate);
QLabel* displayTimeLabel = new QLabel(tr("Display Time"), this);
QDoubleSpinBox* displayTimeBox = new QDoubleSpinBox(this);
displayTimeBox->setObjectName("displayTimeBox");
displayTimeBox->setToolTip(tr("Define the time an image is displayed."));
displayTimeBox->setSuffix(" sec");
displayTimeBox->setMinimum(0.0);
displayTimeBox->setMaximum(30);
displayTimeBox->setSingleStep(.2);
displayTimeBox->setValue(Settings::param().slideShow().time);
DkGroupWidget* slideshowGroup = new DkGroupWidget(tr("Slideshow"), this);
slideshowGroup->addWidget(fadeImageLabel);
slideshowGroup->addWidget(cbTransition);
slideshowGroup->addWidget(fadeImageBox);
slideshowGroup->addWidget(cbAlwaysAnimate);
slideshowGroup->addWidget(displayTimeLabel);
slideshowGroup->addWidget(displayTimeBox);
// left column
QWidget* leftWidget = new QWidget(this);
QVBoxLayout* leftLayout = new QVBoxLayout(leftWidget);
leftLayout->setAlignment(Qt::AlignTop);
leftLayout->addWidget(zoomGroup);
leftLayout->addWidget(keepZoomGroup);
leftLayout->addWidget(iconGroup);
leftLayout->addWidget(slideshowGroup);
// right column
QWidget* rightWidget = new QWidget(this);
QVBoxLayout* rightLayout = new QVBoxLayout(rightWidget);
rightLayout->setAlignment(Qt::AlignTop);
QHBoxLayout* layout = new QHBoxLayout(this);
layout->setAlignment(Qt::AlignLeft);
layout->addWidget(leftWidget);
layout->addWidget(rightWidget);
}
void DkGeneralPreference::createLayout() {
// color settings
DkColorChooser* highlightColorChooser = new DkColorChooser(QColor(0, 204, 255), tr("Highlight Color"), this);
highlightColorChooser->setObjectName("highlightColor");
highlightColorChooser->setColor(&Settings::param().display().highlightColor);
connect(highlightColorChooser, SIGNAL(accepted()), this, SLOT(showRestartLabel()));
DkColorChooser* iconColorChooser = new DkColorChooser(QColor(219, 89, 2, 255), tr("Icon Color"), this);
iconColorChooser->setObjectName("iconColor");
iconColorChooser->setColor(&Settings::param().display().iconColor);
connect(iconColorChooser, SIGNAL(accepted()), this, SLOT(showRestartLabel()));
DkColorChooser* bgColorChooser = new DkColorChooser(QColor(100, 100, 100, 255), tr("Background Color"), this);
bgColorChooser->setObjectName("backgroundColor");
bgColorChooser->setColor(&Settings::param().display().bgColor);
connect(bgColorChooser, SIGNAL(accepted()), this, SLOT(showRestartLabel()));
DkColorChooser* fullscreenColorChooser = new DkColorChooser(QColor(86,86,90), tr("Fullscreen Color"), this);
fullscreenColorChooser->setObjectName("fullscreenColor");
fullscreenColorChooser->setColor(&Settings::param().slideShow().backgroundColor);
connect(fullscreenColorChooser, SIGNAL(accepted()), this, SLOT(showRestartLabel()));
DkColorChooser* fgdHUDColorChooser = new DkColorChooser(QColor(255, 255, 255, 255), tr("HUD Foreground Color"), this);
fgdHUDColorChooser->setObjectName("fgdHUDColor");
fgdHUDColorChooser->setColor(&Settings::param().display().hudFgdColor);
connect(fgdHUDColorChooser, SIGNAL(accepted()), this, SLOT(showRestartLabel()));
DkColorChooser* bgHUDColorChooser = new DkColorChooser(QColor(0, 0, 0, 100), tr("HUD Background Color"), this);
bgHUDColorChooser->setObjectName("bgHUDColor");
bgHUDColorChooser->setColor((Settings::param().app().appMode == DkSettings::mode_frameless) ?
&Settings::param().display().bgColorFrameless : &Settings::param().display().hudBgColor);
connect(bgHUDColorChooser, SIGNAL(accepted()), this, SLOT(showRestartLabel()));
DkGroupWidget* colorGroup = new DkGroupWidget(tr("Color Settings"), this);
colorGroup->addWidget(highlightColorChooser);
colorGroup->addWidget(iconColorChooser);
colorGroup->addWidget(bgColorChooser);
colorGroup->addWidget(fullscreenColorChooser);
colorGroup->addWidget(fgdHUDColorChooser);
colorGroup->addWidget(bgHUDColorChooser);
// default pushbutton
QPushButton* defaultSettings = new QPushButton(tr("Reset All Settings"));
defaultSettings->setObjectName("defaultSettings");
defaultSettings->setMaximumWidth(300);
DkGroupWidget* defaultGroup = new DkGroupWidget(tr("Default Settings"), this);
defaultGroup->addWidget(defaultSettings);
// the left column (holding all color settings)
QWidget* leftColumn = new QWidget(this);
leftColumn->setMinimumWidth(400);
QVBoxLayout* leftColumnLayout = new QVBoxLayout(leftColumn);
leftColumnLayout->setAlignment(Qt::AlignTop);
leftColumnLayout->addWidget(colorGroup);
leftColumnLayout->addWidget(defaultGroup);
// checkboxes
QCheckBox* cbRecentFiles = new QCheckBox(tr("Show Recent Files on Start-Up"), this);
cbRecentFiles->setObjectName("showRecentFiles");
cbRecentFiles->setToolTip(tr("Show the History Panel on Start-Up"));
cbRecentFiles->setChecked(Settings::param().app().showRecentFiles);
QCheckBox* cbLogRecentFiles = new QCheckBox(tr("Log Recent Files"), this);
cbLogRecentFiles->setObjectName("logRecentFiles");
cbLogRecentFiles->setToolTip(tr("If checked, recent files will be saved."));
cbLogRecentFiles->setChecked(Settings::param().global().logRecentFiles);
QCheckBox* cbLoopImages = new QCheckBox(tr("Loop Images"), this);
cbLoopImages->setObjectName("loopImages");
cbLoopImages->setToolTip(tr("Start with the first image in a folder after showing the last."));
cbLoopImages->setChecked(Settings::param().global().loop);
QCheckBox* cbZoomOnWheel = new QCheckBox(tr("Mouse Wheel Zooms"), this);
cbZoomOnWheel->setObjectName("zoomOnWheel");
cbZoomOnWheel->setToolTip(tr("If checked, the mouse wheel zooms - otherwise it is used to switch between images."));
cbZoomOnWheel->setChecked(Settings::param().global().zoomOnWheel);
QCheckBox* cbDoubleClickForFullscreen = new QCheckBox(tr("Double Click Opens Fullscreen"), this);
cbDoubleClickForFullscreen->setObjectName("doubleClickForFullscreen");
cbDoubleClickForFullscreen->setToolTip(tr("If checked, a double click on the canvas opens the fullscreen mode."));
cbDoubleClickForFullscreen->setChecked(Settings::param().global().doubleClickForFullscreen);
QCheckBox* cbShowBgImage = new QCheckBox(tr("Show Background Image"), this);
cbShowBgImage->setObjectName("showBgImage");
cbShowBgImage->setToolTip(tr("If checked, the nomacs logo is shown in the bottom right corner."));
cbShowBgImage->setChecked(Settings::param().global().showBgImage);
QCheckBox* cbSwitchModifier = new QCheckBox(tr("Switch CTRL with ALT"), this);
cbSwitchModifier->setObjectName("switchModifier");
cbSwitchModifier->setToolTip(tr("If checked, CTRL + Mouse is switched with ALT + Mouse."));
cbSwitchModifier->setChecked(Settings::param().sync().switchModifier);
QCheckBox* cbEnableNetworkSync = new QCheckBox(tr("Enable LAN Sync"), this);
cbEnableNetworkSync->setObjectName("networkSync");
cbEnableNetworkSync->setToolTip(tr("If checked, syncing in your LAN is enabled."));
cbEnableNetworkSync->setChecked(Settings::param().sync().enableNetworkSync);
QCheckBox* cbCloseOnEsc = new QCheckBox(tr("Close on ESC"), this);
cbCloseOnEsc->setObjectName("closeOnEsc");
cbCloseOnEsc->setToolTip(tr("Close nomacs if ESC is pressed."));
cbCloseOnEsc->setChecked(Settings::param().app().closeOnEsc);
QCheckBox* cbCheckForUpdates = new QCheckBox(tr("Check For Updates"), this);
cbCheckForUpdates->setObjectName("checkForUpdates");
cbCheckForUpdates->setToolTip(tr("Check for updates on start-up."));
cbCheckForUpdates->setChecked(Settings::param().sync().checkForUpdates);
DkGroupWidget* generalGroup = new DkGroupWidget(tr("General"), this);
generalGroup->addWidget(cbRecentFiles);
generalGroup->addWidget(cbLogRecentFiles);
generalGroup->addWidget(cbLoopImages);
generalGroup->addWidget(cbZoomOnWheel);
generalGroup->addWidget(cbDoubleClickForFullscreen);
generalGroup->addWidget(cbSwitchModifier);
generalGroup->addWidget(cbEnableNetworkSync);
generalGroup->addWidget(cbCloseOnEsc);
generalGroup->addWidget(cbCheckForUpdates);
generalGroup->addWidget(cbShowBgImage);
// language
QComboBox* languageCombo = new QComboBox(this);
languageCombo->setObjectName("languageCombo");
languageCombo->setToolTip(tr("Choose your preferred language."));
DkUtils::addLanguages(languageCombo, mLanguages);
languageCombo->setCurrentIndex(mLanguages.indexOf(Settings::param().global().language));
QLabel* translateLabel = new QLabel("<a href=\"http://www.nomacs.org/how-to-translate-nomacs/\">How-to translate nomacs</a>", this);
translateLabel->setToolTip(tr("Info on how to translate nomacs."));
translateLabel->setOpenExternalLinks(true);
DkGroupWidget* languageGroup = new DkGroupWidget(tr("Language"), this);
languageGroup->addWidget(languageCombo);
languageGroup->addWidget(translateLabel);
// the right column (holding all checkboxes)
QWidget* cbWidget = new QWidget(this);
QVBoxLayout* cbLayout = new QVBoxLayout(cbWidget);
cbLayout->setAlignment(Qt::AlignTop);
cbLayout->addWidget(generalGroup);
// add language
cbLayout->addWidget(languageGroup);
QHBoxLayout* contentLayout = new QHBoxLayout(this);
contentLayout->setAlignment(Qt::AlignLeft);
contentLayout->addWidget(leftColumn);
contentLayout->addWidget(cbWidget);
}
void ExprParamElement::adjustForSearchType(ExprSearchType type)
{
// record which search type is active
searchType = type;
QRegExp regExp("0|[1-9][0-9]*");
numValidator = new QRegExpValidator(regExp, this);
QRegExp hexRegExp("[A-Fa-f0-9]*");
hexValidator = new QRegExpValidator(hexRegExp, this);
// remove all elements
QList<QWidget*> children = qFindChildren<QWidget*>(internalframe);
QWidget* child;
QLayout * lay_out = internalframe->layout();
while (!children.isEmpty())
{
child = children.takeLast();
child->hide();
lay_out->removeWidget(child);
delete child;
}
delete lay_out;
QHBoxLayout* hbox = createLayout();
internalframe->setLayout(hbox);
internalframe->setMinimumSize(320,26);
if (isStringSearchExpression())
{
// set up for default of a simple input field
QLineEdit* lineEdit = new QLineEdit(internalframe);
lineEdit->setMinimumSize(STR_FIELDS_MIN_WIDTH, FIELDS_MIN_HEIGHT);
lineEdit->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
lineEdit->setObjectName("param1");
hbox->addWidget(lineEdit);
hbox->addSpacing(9);
QCheckBox* icCb = new QCheckBox(tr("ignore case"), internalframe);
icCb->setObjectName("ignoreCaseCB");
icCb->setCheckState(Qt::Checked);
// hex search specifics: hidden case sensitivity and hex validator
if (searchType == HashSearch) {
icCb->hide();
lineEdit->setValidator(hexValidator);
}
hbox->addWidget(icCb);
hbox->addStretch();
} else if (searchType == DateSearch)
{
QDateEdit * dateEdit = new QDateEdit(QDate::currentDate(), internalframe);
dateEdit->setMinimumSize(DATE_FIELDS_MIN_WIDTH, FIELDS_MIN_HEIGHT);
dateEdit->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
dateEdit->setDisplayFormat(tr("dd.MM.yyyy"));
dateEdit->setObjectName("param1");
dateEdit->setMinimumDate(QDate(1970, 1, 1));
dateEdit->setMaximumDate(QDate(2099, 12,31));
hbox->addWidget(dateEdit, Qt::AlignLeft);
hbox->addStretch();
} else if (searchType == SizeSearch)
{
QLineEdit * lineEdit = new QLineEdit(internalframe);
lineEdit->setMinimumSize(SIZE_FIELDS_MIN_WIDTH, FIELDS_MIN_HEIGHT);
lineEdit->setMaximumSize(SIZE_FIELDS_MIN_WIDTH, FIELDS_MIN_HEIGHT);
lineEdit->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
lineEdit->setObjectName("param1");
lineEdit->setValidator(numValidator);
hbox->addWidget(lineEdit, Qt::AlignLeft);
QComboBox * cb = new QComboBox(internalframe);
cb->setObjectName("unitsCb1");
cb-> addItem(tr("KB"), QVariant(1024));
cb->addItem(tr("MB"), QVariant(1048576));
cb->addItem(tr("GB"), QVariant(1073741824));
hbox->addSpacing(9);
internalframe->layout()->addWidget(cb);
hbox->addStretch();
}
/* POP Search not implemented
else if (searchType == PopSearch)
{
QLineEdit * lineEdit = new QLineEdit(elem);
lineEdit->setObjectName("param1");
lineEdit->setValidator(numValidator);
elem->layout()->addWidget(lineEdit);
}*/
hbox->invalidate();
internalframe->adjustSize();
internalframe->show();
this->adjustSize();
}
QWidget *ServerDialog::createPackageTab(){
extension_group = new QButtonGroup;
extension_group->setExclusive(false);
QStringList extensions = Sanguosha->getExtensions();
QSet<QString> ban_packages = Config.BanPackages.toSet();
QGroupBox *box1 = new QGroupBox(tr("General package"));
QGroupBox *box2 = new QGroupBox(tr("Card package"));
QGridLayout *layout1 = new QGridLayout;
QGridLayout *layout2 = new QGridLayout;
box1->setLayout(layout1);
box2->setLayout(layout2);
int i = 0, j = 0;
int row = 0, column = 0;
foreach(QString extension, extensions){
const Package *package = Sanguosha->findChild<const Package *>(extension);
if(package == NULL)
continue;
bool forbid_package = Config.value("ForbidPackages").toString().contains(extension);
QCheckBox *checkbox = new QCheckBox;
checkbox->setObjectName(extension);
checkbox->setText(Sanguosha->translate(extension));
checkbox->setChecked(!ban_packages.contains(extension) && !forbid_package);
checkbox->setEnabled(!forbid_package);
extension_group->addButton(checkbox);
switch(package->getType()){
case Package::GeneralPack: {
row = i / 5;
column = i % 5;
i++;
layout1->addWidget(checkbox, row, column+1);
break;
}
case Package::CardPack: {
row = j / 5;
column = j % 5;
j++;
layout2->addWidget(checkbox, row, column+1);
break;
}
default:
break;
}
}
QWidget *widget = new QWidget;
QVBoxLayout *layout = new QVBoxLayout;
layout->addWidget(box1);
layout->addWidget(box2);
widget->setLayout(layout);
return widget;
}
static QList<QWidget*> getFormWidgets(QList<FormField> formFields, const QObject *receiver)
{
QList<QWidget*> formWidgets;
for (int i = 0; i < formFields.size(); ++i)
{
Poppler::FormField *formField = formFields.at(i).field;
if (formField->type() == Poppler::FormField::FormText)
{
Poppler::FormFieldText *formFieldText = static_cast<Poppler::FormFieldText*>(formField);
switch (formFieldText->textType())
{
case Poppler::FormFieldText::FileSelect:
{
// TODO replace this by a file selection widget
QLineEdit *lineEdit = new QLineEdit;
lineEdit->setText(formFieldText->text());
lineEdit->setObjectName(QLatin1String("PageItem::formField") + QString::number(i));
QObject::connect(lineEdit, SIGNAL(textEdited(QString)), receiver, SLOT(slotSetFormData(QString)));
formWidgets << lineEdit;
}
break;
case Poppler::FormFieldText::Multiline:
{
QTextEdit *textEdit = new QTextEdit;
textEdit->setText(formFieldText->text());
textEdit->setObjectName(QLatin1String("PageItem::formField") + QString::number(i));
QObject::connect(textEdit, SIGNAL(textChanged()), receiver, SLOT(slotSetFormData()));
formWidgets << textEdit;
}
break;
case Poppler::FormFieldText::Normal:
default:
{
QLineEdit *lineEdit = new QLineEdit;
lineEdit->setText(formFieldText->text());
lineEdit->setObjectName(QLatin1String("PageItem::formField") + QString::number(i));
QObject::connect(lineEdit, SIGNAL(textEdited(QString)), receiver, SLOT(slotSetFormData(QString)));
formWidgets << lineEdit;
}
break;
}
}
else if (formField->type() == Poppler::FormField::FormButton)
{
Poppler::FormFieldButton *formFieldButton = static_cast<Poppler::FormFieldButton*>(formField);
switch (formFieldButton->buttonType())
{
case Poppler::FormFieldButton::CheckBox:
{
QCheckBox *checkBox = new QCheckBox;
// checkBox->setText(formFieldButton->caption());
checkBox->setChecked(formFieldButton->state());
checkBox->setObjectName(QLatin1String("PageItem::formField") + QString::number(i));
QObject::connect(checkBox, SIGNAL(toggled(bool)), receiver, SLOT(slotSetFormData(bool)));
formWidgets << checkBox;
}
break;
case Poppler::FormFieldButton::Radio:
{
QRadioButton *radioButton = new QRadioButton;
radioButton->setText(formFieldButton->caption());
radioButton->setChecked(formFieldButton->state());
radioButton->setObjectName(QLatin1String("PageItem::formField") + QString::number(i));
QObject::connect(radioButton, SIGNAL(toggled(bool)), receiver, SLOT(slotSetFormData(bool)));
formWidgets << radioButton;
}
break;
case Poppler::FormFieldButton::Push:
default:
{
QPushButton *pushButton = new QPushButton;
pushButton->setText(formFieldButton->caption());
pushButton->setChecked(formFieldButton->state());
pushButton->setObjectName(QLatin1String("PageItem::formField") + QString::number(i));
QObject::connect(pushButton, SIGNAL(toggled(bool)), receiver, SLOT(slotSetFormData(bool)));
formWidgets << pushButton;
}
break;
}
}
else if (formField->type() == Poppler::FormField::FormChoice)
{
Poppler::FormFieldChoice *formFieldChoice = static_cast<Poppler::FormFieldChoice*>(formField);
switch (formFieldChoice->choiceType())
{
case Poppler::FormFieldChoice::ComboBox:
{
QComboBox *comboBox = new QComboBox;
comboBox->addItems(formFieldChoice->choices());
comboBox->setEditable(formFieldChoice->isEditable());
comboBox->setCurrentIndex(formFieldChoice->currentChoices().at(0));
comboBox->setObjectName(QLatin1String("PageItem::formField") + QString::number(i));
QObject::connect(comboBox, SIGNAL(currentIndexChanged(int)), receiver, SLOT(slotSetFormData(int)));
formWidgets << comboBox;
}
break;
case Poppler::FormFieldChoice::ListBox:
default:
{
QListWidget *listWidget = new QListWidget;
listWidget->addItems(formFieldChoice->choices());
if (formFieldChoice->isEditable())
{
for (int j = 0; j < listWidget->count(); ++j)
listWidget->item(j)->setFlags(listWidget->item(j)->flags() | Qt::ItemIsEditable);
}
else
{
for (int j = 0; j < listWidget->count(); ++j)
listWidget->item(j)->setFlags(listWidget->item(j)->flags() & ~Qt::ItemIsEditable);
}
QList<int> currentChoices = formFieldChoice->currentChoices();
for (int j = 0; j < currentChoices.size(); ++j)
listWidget->item(currentChoices.at(j))->setSelected(true);
listWidget->setObjectName(QLatin1String("PageItem::formField") + QString::number(i));
QObject::connect(listWidget, SIGNAL(itemSelectionChanged()), receiver, SLOT(slotSetFormData()));
formWidgets << listWidget;
}
break;
}
}
else if (formField->type() == Poppler::FormField::FormSignature)
{
// TODO
formWidgets << new QWidget;
}
else // make sure that m_formWidgets.at(i) corresponds to m_formFields.at(i)
formWidgets << new QWidget;
}
return formWidgets;
}
MidiFilterDialog::MidiFilterDialog(QWidget *parent,
RosegardenDocument *doc):
QDialog(parent),
m_doc(doc),
m_modified(true),
m_buttonBox(0)
{
//setHelp("studio-midi-filters");
setModal(true);
setWindowTitle(tr("Modify MIDI filters..."));
QGridLayout *metagrid = new QGridLayout;
setLayout(metagrid);
QWidget *hBox = new QWidget(this);
QHBoxLayout *hBoxLayout = new QHBoxLayout;
metagrid->addWidget(hBox, 0, 0);
m_thruBox = new QGroupBox(
tr("THRU events to ignore"), hBox );
QVBoxLayout *thruBoxLayout = new QVBoxLayout;
hBoxLayout->addWidget(m_thruBox);
QCheckBox *noteThru = new QCheckBox(tr("Note"), m_thruBox);
QCheckBox *progThru = new QCheckBox(tr("Program Change"), m_thruBox);
QCheckBox *keyThru = new QCheckBox(tr("Key Pressure"), m_thruBox);
QCheckBox *chanThru = new QCheckBox(tr("Channel Pressure"), m_thruBox);
QCheckBox *pitchThru = new QCheckBox(tr("Pitch Bend"), m_thruBox);
QCheckBox *contThru = new QCheckBox(tr("Controller"), m_thruBox);
QCheckBox *sysThru = new QCheckBox(tr("System Exclusive"), m_thruBox);
noteThru->setObjectName("Note");
progThru->setObjectName("Program Change");
keyThru->setObjectName("Key Pressure");
chanThru->setObjectName("Channel Pressure");
pitchThru->setObjectName("Pitch Bend");
contThru->setObjectName("Controller");
sysThru->setObjectName("System Exclusive");
thruBoxLayout->addWidget(noteThru);
thruBoxLayout->addWidget(progThru);
thruBoxLayout->addWidget(keyThru);
thruBoxLayout->addWidget(chanThru);
thruBoxLayout->addWidget(pitchThru);
thruBoxLayout->addWidget(contThru);
thruBoxLayout->addWidget(sysThru);
m_thruBox->setLayout(thruBoxLayout);
MidiFilter thruFilter = m_doc->getStudio().getMIDIThruFilter();
if (thruFilter & MappedEvent::MidiNote)
noteThru->setChecked(true);
if (thruFilter & MappedEvent::MidiProgramChange)
progThru->setChecked(true);
if (thruFilter & MappedEvent::MidiKeyPressure)
keyThru->setChecked(true);
if (thruFilter & MappedEvent::MidiChannelPressure)
chanThru->setChecked(true);
if (thruFilter & MappedEvent::MidiPitchBend)
pitchThru->setChecked(true);
if (thruFilter & MappedEvent::MidiController)
contThru->setChecked(true);
if (thruFilter & MappedEvent::MidiSystemMessage)
sysThru->setChecked(true);
m_recordBox = new QGroupBox(
tr("RECORD events to ignore"), hBox );
QVBoxLayout *recordBoxLayout = new QVBoxLayout;
hBoxLayout->addWidget(m_recordBox);
QCheckBox *noteRecord = new QCheckBox(tr("Note"), m_recordBox);
QCheckBox *progRecord = new QCheckBox(tr("Program Change"), m_recordBox);
QCheckBox *keyRecord = new QCheckBox(tr("Key Pressure"), m_recordBox);
QCheckBox *chanRecord = new QCheckBox(tr("Channel Pressure"), m_recordBox);
QCheckBox *pitchRecord = new QCheckBox(tr("Pitch Bend"), m_recordBox);
QCheckBox *contRecord = new QCheckBox(tr("Controller"), m_recordBox);
QCheckBox *sysRecord = new QCheckBox(tr("System Exclusive"), m_recordBox);
noteRecord->setObjectName("Note");
progRecord->setObjectName("Program Change");
keyRecord->setObjectName("Key Pressure");
chanRecord->setObjectName("Channel Pressure");
pitchRecord->setObjectName("Pitch Bend");
contRecord->setObjectName("Controller");
sysRecord->setObjectName("System Exclusive");
recordBoxLayout->addWidget(noteRecord);
recordBoxLayout->addWidget(progRecord);
recordBoxLayout->addWidget(keyRecord);
recordBoxLayout->addWidget(chanRecord);
recordBoxLayout->addWidget(pitchRecord);
recordBoxLayout->addWidget(contRecord);
recordBoxLayout->addWidget(sysRecord);
m_recordBox->setLayout(recordBoxLayout);
MidiFilter recordFilter =
m_doc->getStudio().getMIDIRecordFilter();
if (recordFilter & MappedEvent::MidiNote)
noteRecord->setChecked(true);
if (recordFilter & MappedEvent::MidiProgramChange)
progRecord->setChecked(true);
if (recordFilter & MappedEvent::MidiKeyPressure)
keyRecord->setChecked(true);
if (recordFilter & MappedEvent::MidiChannelPressure)
chanRecord->setChecked(true);
if (recordFilter & MappedEvent::MidiPitchBend)
pitchRecord->setChecked(true);
if (recordFilter & MappedEvent::MidiController)
contRecord->setChecked(true);
if (recordFilter & MappedEvent::MidiSystemMessage)
sysRecord->setChecked(true);
hBox->setLayout(hBoxLayout);
m_buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok |
QDialogButtonBox::Apply |
QDialogButtonBox::Close |
QDialogButtonBox::Help);
metagrid->addWidget(m_buttonBox, 1, 0);
metagrid->setRowStretch(0, 10);
connect(m_buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
connect(m_buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
connect(m_buttonBox, SIGNAL(helpRequested()), this, SLOT(help()));
m_applyButton = m_buttonBox->button(QDialogButtonBox::Apply);
connect(m_applyButton, SIGNAL(clicked()), this, SLOT(slotApply()));
// changing the state of any checkbox sets modified true
connect(noteThru, SIGNAL(stateChanged(int)),
SLOT(slotSetModified(int)));
connect(progThru, SIGNAL(stateChanged(int)),
SLOT(slotSetModified(int)));
connect(keyThru, SIGNAL(stateChanged(int)),
SLOT(slotSetModified(int)));
connect(chanThru, SIGNAL(stateChanged(int)),
SLOT(slotSetModified(int)));
connect(pitchThru, SIGNAL(stateChanged(int)),
SLOT(slotSetModified(int)));
connect(contThru, SIGNAL(stateChanged(int)),
SLOT(slotSetModified(int)));
connect(sysThru, SIGNAL(stateChanged(int)),
SLOT(slotSetModified(int)));
connect(noteRecord, SIGNAL(stateChanged(int)),
SLOT(slotSetModified(int)));
connect(progRecord, SIGNAL(stateChanged(int)),
SLOT(slotSetModified(int)));
connect(keyRecord, SIGNAL(stateChanged(int)),
SLOT(slotSetModified(int)));
connect(chanRecord, SIGNAL(stateChanged(int)),
SLOT(slotSetModified(int)));
connect(pitchRecord, SIGNAL(stateChanged(int)),
SLOT(slotSetModified(int)));
connect(contRecord, SIGNAL(stateChanged(int)),
SLOT(slotSetModified(int)));
connect(sysRecord, SIGNAL(stateChanged(int)),
SLOT(slotSetModified(int)));
// setting the thing up initially changes states and trips signals, so we
// have to do this to wipe the slate clean initially after all the false
// positives
setModified(false);
}
void setupUi(QDialog *MVPPlayerRemoteDialog)
{
if (MVPPlayerRemoteDialog->objectName().isEmpty())
MVPPlayerRemoteDialog->setObjectName(QStringLiteral("MVPPlayerRemoteDialog"));
MVPPlayerRemoteDialog->resize(380, 396);
MVPPlayerRemoteDialog->setAcceptDrops(true);
verticalLayout_4 = new QVBoxLayout(MVPPlayerRemoteDialog);
verticalLayout_4->setObjectName(QStringLiteral("verticalLayout_4"));
verticalLayout_2 = new QVBoxLayout();
#ifndef Q_OS_MAC
verticalLayout_2->setSpacing(-1);
#endif
verticalLayout_2->setObjectName(QStringLiteral("verticalLayout_2"));
verticalLayout_2->setContentsMargins(-1, 0, 0, -1);
verticalLayout_3 = new QVBoxLayout();
verticalLayout_3->setObjectName(QStringLiteral("verticalLayout_3"));
verticalLayout_3->setSizeConstraint(QLayout::SetMinimumSize);
horizontalLayout_4 = new QHBoxLayout();
horizontalLayout_4->setObjectName(QStringLiteral("horizontalLayout_4"));
horizontalLayout_4->setSizeConstraint(QLayout::SetMinimumSize);
sliderVolume = new QSlider(MVPPlayerRemoteDialog);
sliderVolume->setObjectName(QStringLiteral("sliderVolume"));
QSizePolicy sizePolicy(QSizePolicy::Preferred, QSizePolicy::Expanding);
sizePolicy.setHorizontalStretch(0);
sizePolicy.setVerticalStretch(0);
sizePolicy.setHeightForWidth(sliderVolume->sizePolicy().hasHeightForWidth());
sliderVolume->setSizePolicy(sizePolicy);
sliderVolume->setMinimumSize(QSize(0, 0));
sliderVolume->setMaximum(100);
sliderVolume->setValue(100);
sliderVolume->setOrientation(Qt::Horizontal);
horizontalLayout_4->addWidget(sliderVolume);
lblVol = new QLabel(MVPPlayerRemoteDialog);
lblVol->setObjectName(QStringLiteral("lblVol"));
QSizePolicy sizePolicy1(QSizePolicy::Maximum, QSizePolicy::Preferred);
sizePolicy1.setHorizontalStretch(0);
sizePolicy1.setVerticalStretch(0);
sizePolicy1.setHeightForWidth(lblVol->sizePolicy().hasHeightForWidth());
lblVol->setSizePolicy(sizePolicy1);
lblVol->setPixmap(QPixmap(QString::fromUtf8(":/mvpplayer/app/icon.png")));
lblVol->setAlignment(Qt::AlignCenter);
horizontalLayout_4->addWidget(lblVol);
verticalLayout_3->addLayout(horizontalLayout_4);
layoutButtonsBar = new QHBoxLayout();
layoutButtonsBar->setObjectName(QStringLiteral("layoutButtonsBar"));
btnServer = new QToolButton(MVPPlayerRemoteDialog);
btnServer->setObjectName(QStringLiteral("btnServer"));
QIcon icon;
icon.addFile(QStringLiteral(":/mvpplayer/toolbar/connection.png"), QSize(), QIcon::Normal, QIcon::Off);
btnServer->setIcon(icon);
btnServer->setIconSize(QSize(32, 32));
btnServer->setCheckable(true);
layoutButtonsBar->addWidget(btnServer);
verticalLayout_3->addLayout(layoutButtonsBar);
verticalLayout_2->addLayout(verticalLayout_3);
line_2 = new QFrame(MVPPlayerRemoteDialog);
line_2->setObjectName(QStringLiteral("line_2"));
line_2->setFrameShape(QFrame::HLine);
line_2->setFrameShadow(QFrame::Sunken);
verticalLayout_2->addWidget(line_2);
cbMute = new QCheckBox(MVPPlayerRemoteDialog);
cbMute->setObjectName(QStringLiteral("cbMute"));
cbMute->setChecked(true);
verticalLayout_2->addWidget(cbMute);
verticalLayout = new QVBoxLayout();
verticalLayout->setObjectName(QStringLiteral("verticalLayout"));
verticalLayout->setSizeConstraint(QLayout::SetNoConstraint);
horizontalLayout_2 = new QHBoxLayout();
horizontalLayout_2->setObjectName(QStringLiteral("horizontalLayout_2"));
label = new QLabel(MVPPlayerRemoteDialog);
label->setObjectName(QStringLiteral("label"));
horizontalLayout_2->addWidget(label);
lblCurrentTrack = new QLabel(MVPPlayerRemoteDialog);
lblCurrentTrack->setObjectName(QStringLiteral("lblCurrentTrack"));
QSizePolicy sizePolicy2(QSizePolicy::MinimumExpanding, QSizePolicy::Minimum);
sizePolicy2.setHorizontalStretch(0);
sizePolicy2.setVerticalStretch(0);
sizePolicy2.setHeightForWidth(lblCurrentTrack->sizePolicy().hasHeightForWidth());
lblCurrentTrack->setSizePolicy(sizePolicy2);
lblCurrentTrack->setWordWrap(true);
horizontalLayout_2->addWidget(lblCurrentTrack);
lblTrackLength = new QLabel(MVPPlayerRemoteDialog);
lblTrackLength->setObjectName(QStringLiteral("lblTrackLength"));
lblTrackLength->setAlignment(Qt::AlignCenter);
horizontalLayout_2->addWidget(lblTrackLength);
verticalLayout->addLayout(horizontalLayout_2);
horizontalLayout_3 = new QHBoxLayout();
horizontalLayout_3->setObjectName(QStringLiteral("horizontalLayout_3"));
sliderPosition = new QSlider(MVPPlayerRemoteDialog);
sliderPosition->setObjectName(QStringLiteral("sliderPosition"));
sliderPosition->setMaximum(100);
sliderPosition->setOrientation(Qt::Horizontal);
sliderPosition->setInvertedAppearance(false);
sliderPosition->setInvertedControls(false);
sliderPosition->setTickPosition(QSlider::TicksBelow);
sliderPosition->setTickInterval(1);
horizontalLayout_3->addWidget(sliderPosition);
verticalLayout->addLayout(horizontalLayout_3);
horizontalLayout_5 = new QHBoxLayout();
horizontalLayout_5->setObjectName(QStringLiteral("horizontalLayout_5"));
btnClearPlaylist = new QToolButton(MVPPlayerRemoteDialog);
btnClearPlaylist->setObjectName(QStringLiteral("btnClearPlaylist"));
QIcon icon1;
icon1.addFile(QStringLiteral(":/mvpplayer/action/cancel.png"), QSize(), QIcon::Normal, QIcon::Off);
btnClearPlaylist->setIcon(icon1);
horizontalLayout_5->addWidget(btnClearPlaylist);
lblPlaylist = new QLabel(MVPPlayerRemoteDialog);
lblPlaylist->setObjectName(QStringLiteral("lblPlaylist"));
horizontalLayout_5->addWidget(lblPlaylist);
verticalLayout->addLayout(horizontalLayout_5);
playlist = new QListWidget(MVPPlayerRemoteDialog);
playlist->setObjectName(QStringLiteral("playlist"));
QSizePolicy sizePolicy3(QSizePolicy::Expanding, QSizePolicy::Maximum);
sizePolicy3.setHorizontalStretch(0);
sizePolicy3.setVerticalStretch(0);
sizePolicy3.setHeightForWidth(playlist->sizePolicy().hasHeightForWidth());
playlist->setSizePolicy(sizePolicy3);
playlist->setDragDropMode(QAbstractItemView::DropOnly);
verticalLayout->addWidget(playlist);
verticalLayout_2->addLayout(verticalLayout);
verticalLayout_4->addLayout(verticalLayout_2);
QWidget::setTabOrder(cbMute, sliderPosition);
QWidget::setTabOrder(sliderPosition, playlist);
retranslateUi(MVPPlayerRemoteDialog);
QMetaObject::connectSlotsByName(MVPPlayerRemoteDialog);
} // setupUi
QWidget *ServerDialog::createPackageTab() {
disable_lua_checkbox = new QCheckBox(tr("Disable Lua"));
disable_lua_checkbox->setChecked(Config.DisableLua);
disable_lua_checkbox->setToolTip(tr("<font color=%1>The setting takes effect after reboot</font>").arg(Config.SkillDescriptionInToolTipColor.name()));
extension_group = new QButtonGroup(this);
extension_group->setExclusive(false);
QSet<QString> ban_packages = Config.BanPackages.toSet();
QGroupBox *box1 = new QGroupBox(tr("General package"));
QGroupBox *box2 = new QGroupBox(tr("Card package"));
QGridLayout *layout1 = new QGridLayout;
QGridLayout *layout2 = new QGridLayout;
box1->setLayout(layout1);
box2->setLayout(layout2);
int i = 0, j = 0;
int row = 0, column = 0;
const QList<const Package *> &packages = Sanguosha->getPackages();
foreach(const Package *package, packages) {
if (package->inherits("Scenario"))
continue;
const QString &extension = package->objectName();
bool forbid_package = Config.value("ForbidPackages").toStringList().contains(extension);
QCheckBox *checkbox = new QCheckBox;
checkbox->setObjectName(extension);
checkbox->setText(Sanguosha->translate(extension));
checkbox->setChecked(!ban_packages.contains(extension) && !forbid_package);
checkbox->setEnabled(!forbid_package);
extension_group->addButton(checkbox);
switch (package->getType()) {
case Package::GeneralPack: {
row = i / 5;
column = i % 5;
i++;
layout1->addWidget(checkbox, row, column + 1);
break;
}
case Package::CardPack: {
row = j / 5;
column = j % 5;
j++;
layout2->addWidget(checkbox, row, column + 1);
break;
}
default:
break;
}
}
QWidget *widget = new QWidget;
QVBoxLayout *layout = new QVBoxLayout;
layout->addWidget(disable_lua_checkbox);
layout->addWidget(box1);
layout->addWidget(box2);
widget->setLayout(layout);
return widget;
}
