QLabel * TASARIM_DESIGN_WIDGET::CREATE_NEW_LABEL ( const QString &text, QWidget * parent )
{
if ( parent EQ NULL ) {
parent = this;
}
QLabel * label = new QLabel(text.toUtf8(),parent);
label->setMargin(0);
label->setIndent(0);
QFont label_font = label->font();
label_font.setFixedPitch ( false );
label_font.setKerning ( false );
label_font.setLetterSpacing ( QFont::AbsoluteSpacing, 0.01 );
label_font.setWordSpacing ( 0.01 );
label->setScaledContents ( true );
label->setFont ( label_font );
label->setFocusPolicy ( Qt::StrongFocus );
int width = label->width();
label->setMinimumWidth( width + 5 );
label->installEventFilter( this );
SET_LABEL_FONTS_UNSELECTED( label );
return label;
}
void Wizard::setupPage1()
{
page1 = new QHBox( this );
page1->setSpacing(8);
QLabel *info = new QLabel( page1 );
info->setPalette( yellow );
info->setText( "Enter your personal\n"
"key here.\n\n"
"Your personal key\n"
"consists of 4 digits" );
info->setIndent( 8 );
info->setMaximumWidth( info->sizeHint().width() );
QVBox *page = new QVBox( page1 );
QHBox *row1 = new QHBox( page );
(void)new QLabel( "Key:", row1 );
key = new QLineEdit( row1 );
key->setMaxLength( 4 );
key->setValidator( new QIntValidator( 9999, 0, key ) );
connect( key, SIGNAL( textChanged( const QString & ) ), this, SLOT( keyChanged( const QString & ) ) );
addPage( page1, "Personal Key" );
setNextEnabled( page1, FALSE );
setHelpEnabled( page1, FALSE );
}
DHeaderWidget::DHeaderWidget(QWidget *parent) :
QWidget(parent)
{
QHBoxLayout *btlayout = new QHBoxLayout();
m_CloseButton = new DCloseButton();
connect(m_CloseButton, SIGNAL(clicked()), this, SIGNAL(closeClicked()));
btlayout->setMargin(0);
btlayout->addWidget(m_CloseButton);
btlayout->setAlignment(m_CloseButton, Qt::AlignRight);
QHBoxLayout *logolayout = new QHBoxLayout();
QLabel *logolabel = new QLabel();
logolabel->setPixmap(QPixmap(":/fontend/images/logo.png"));
logolayout->addStretch();
logolayout->addWidget(logolabel);
logolayout->setAlignment(logolabel, Qt::AlignBottom);
QLabel *versionlabel = new QLabel(QString("<a style='color:white; font-size:11px;'>%1</a>").arg(DeepinInstaller::Version));
versionlabel->setIndent(2);
logolayout->addSpacing(2);
logolayout->addWidget(versionlabel);
logolayout->setAlignment(versionlabel, Qt::AlignBottom);
logolayout->addStretch();
QVBoxLayout *layout = new QVBoxLayout;
layout->setMargin(0);
layout->setSpacing(0);
layout->addLayout(btlayout);
layout->addLayout(logolayout);
this->setLayout(layout);
this->setFixedHeight(80);
}
QWidget *Summary::createHeader(QWidget *parent, const QPixmap &icon, const QString &heading)
{
QHBox *hbox = new QHBox(parent);
hbox->setMargin(2);
QFont boldFont;
boldFont.setBold(true);
boldFont.setPointSize(boldFont.pointSize() + 2);
QLabel *label = new QLabel(hbox);
label->setPixmap(icon);
label->setFixedSize(label->sizeHint());
label->setPaletteBackgroundColor(colorGroup().mid());
label->setAcceptDrops(true);
label = new QLabel(heading, hbox);
label->setAlignment(AlignLeft | AlignVCenter);
label->setIndent(KDialog::spacingHint());
label->setFont(boldFont);
label->setPaletteForegroundColor(colorGroup().light());
label->setPaletteBackgroundColor(colorGroup().mid());
hbox->setPaletteBackgroundColor(colorGroup().mid());
hbox->setMaximumHeight(hbox->minimumSizeHint().height());
return hbox;
}
TagListWidget::TagListWidget(QWidget *parent) :
QWidget(parent)
{
setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
parentLayout = new FlowLayout(this, 0);
setLayout(parentLayout);
addButton = new TagWidget("+");
connect(addButton, SIGNAL(clicked()), this, SLOT(newTagRequested()));
QLabel *lbl = new QLabel(tr("<b>Tags:</b>"));
lbl->setIndent(5);
parentLayout->addWidget(lbl);
parentLayout->addWidget(addButton);
m_ignoredFlags.insert(QLatin1String("\\seen"));
m_ignoredFlags.insert(QLatin1String("\\recent"));
m_ignoredFlags.insert(QLatin1String("\\deleted"));
m_ignoredFlags.insert(QLatin1String("\\answered"));
// We do want to show \Flagged, though
m_ignoredFlags.insert(QLatin1String("\\draft"));
m_ignoredFlags.insert(QLatin1String("$mdnsent"));
m_ignoredFlags.insert(QLatin1String("$forwarded"));
m_ignoredFlags.insert(QLatin1String("$submitpending"));
m_ignoredFlags.insert(QLatin1String("$submitted"));
}
LabeledWidget::LabeledWidget(QAction *action, const QString &label, LabelPosition lb, bool warningLabelRequired)
: QWidget()
, m_action(action)
{
setMouseTracking(true);
QBoxLayout *layout;
QLabel *l = new QLabel(label);
l->setWordWrap(true);
m_lineEdit = new QLineEdit();
if (lb == LabeledWidget::INLINE) { // label followed by line edit
layout = new QHBoxLayout();
l->setIndent(l->style()->pixelMetric(QStyle::PM_SmallIconSize)
+ l->style()->pixelMetric(QStyle::PM_MenuPanelWidth) + 4);
} else { //Label goes above the text edit
layout = new QVBoxLayout();
m_lineEdit->setFixedWidth(300); //TODO : assuming a reasonable width, is there a better way?
}
layout->addWidget(l);
layout->addWidget(m_lineEdit);
if (warningLabelRequired) {
m_warningLabel[0] = new QLabel("");
m_warningLabel[1] = new QLabel("");
m_warningLabel[0]->setWordWrap(true);
m_warningLabel[1]->setWordWrap(true);
layout->addWidget(m_warningLabel[0]);
layout->addWidget(m_warningLabel[1]);
}
layout->setMargin(0);
setLayout(layout);
connect(m_lineEdit, SIGNAL(returnPressed()), this, SLOT(returnPressed()));
connect(m_lineEdit, SIGNAL(textChanged(QString)), this, SIGNAL(lineEditChanged(QString)));
}
void Wizard::setupPage3()
{
page3 = new QHBox( this );
page3->setSpacing(8);
QLabel *info = new QLabel( page3 );
info->setPalette( yellow );
info->setText( "\n"
" Look here to see of \n"
" the data you entered \n"
" is correct. To confirm, \n"
" press the [Finish] button \n"
" else go back to correct \n"
" mistakes." );
info->setIndent(8);
info->setAlignment( AlignTop|AlignLeft );
info->setMaximumWidth( info->sizeHint().width() );
QVBox *page = new QVBox( page3 );
QHBox *row1 = new QHBox( page );
QHBox *row2 = new QHBox( page );
QHBox *row3 = new QHBox( page );
QHBox *row4 = new QHBox( page );
QHBox *row5 = new QHBox( page );
QHBox *row6 = new QHBox( page );
QLabel *label1 = new QLabel( " Personal Key: ", row1 );
label1->setAlignment( Qt::AlignVCenter );
QLabel *label2 = new QLabel( " First Name: ", row2 );
label2->setAlignment( Qt::AlignVCenter );
QLabel *label3 = new QLabel( " Last Name: ", row3 );
label3->setAlignment( Qt::AlignVCenter );
QLabel *label4 = new QLabel( " Address: ", row4 );
label4->setAlignment( Qt::AlignVCenter );
QLabel *label5 = new QLabel( " Phone Number: ", row5 );
label5->setAlignment( Qt::AlignVCenter );
QLabel *label6 = new QLabel( " E-Mail: ", row6 );
label6->setAlignment( Qt::AlignVCenter );
label1->setMinimumWidth( label1->sizeHint().width() );
label2->setMinimumWidth( label1->sizeHint().width() );
label3->setMinimumWidth( label1->sizeHint().width() );
label4->setMinimumWidth( label1->sizeHint().width() );
label5->setMinimumWidth( label1->sizeHint().width() );
label6->setMinimumWidth( label1->sizeHint().width() );
lKey = new QLabel( row1 );
lFirstName = new QLabel( row2 );
lLastName = new QLabel( row3 );
lAddress = new QLabel( row4 );
lPhone = new QLabel( row5 );
lEmail = new QLabel( row6 );
addPage( page3, "Finish" );
setFinish( page3, TRUE );
setHelpEnabled( page3, FALSE );
}
void
MessageBar::show( const QString& message, const QString& id )
{
QLabel* label = findChild<QLabel*>( id );
if (label && id.size()) {
if (message.isEmpty())
{
QProgressBar* p = label->findChild<QProgressBar*>();
if (p)
p->setRange( 0, 1 ),
p->setValue( 1 );
QTimer::singleShot( 3000, label, SLOT(deleteLater()) );
}
else
label->setText( message );
return;
}
label = new QLabel( message, ui.papyrus );
label->setBackgroundRole( QPalette::Base );
label->setMargin( 8 );
label->setIndent( 4 );
label->setTextFormat( Qt::RichText );
label->setOpenExternalLinks( true );
label->setTextInteractionFlags( Qt::TextSelectableByMouse | Qt::LinksAccessibleByMouse );
ImageButton* close = new ImageButton( ":/buckets/radio_clear_all_x.png" );
QHBoxLayout* h = new QHBoxLayout( label );
h->addStretch();
if (id.size())
{
label->setObjectName( id );
QProgressBar* p;
h->addWidget( p = new QProgressBar );
p->setRange( 0, 0 );
p->setFixedWidth( 90 );
}
h->addWidget( close );
h->setMargin( 4 );
label->setFixedWidth( width() );
label->adjustSize();
label->show();
ui.papyrus->move( 0, -label->height() );
doLayout();
connect( close, SIGNAL(clicked()), label, SLOT(deleteLater()) );
connect( label, SIGNAL(destroyed()), SLOT(onLabelDestroyed()), Qt::QueuedConnection );
m_timeline->setFrameRange( height(), ui.papyrus->height() );
m_timeline->start();
}
QWidget *AbstractPropertyGroup::createEditor(QWidget *parent, const QObject *target, const char *receiver) const
{
Q_UNUSED(target);
Q_UNUSED(receiver);
QLabel *label = new QLabel(parent);
label->setIndent(2); // ### hardcode it should have the same value of textMargin in QItemDelegate
label->setBackgroundRole(QPalette::Base);
return label;
}
void Wizard::setupPage2()
{
page2 = new QHBox( this );
page2->setSpacing(8);
QLabel *info = new QLabel( page2 );
info->setPalette( yellow );
info->setText( "\n"
" Enter your personal \n"
" data here. \n\n"
" The required fields are \n"
" First Name, Last Name \n"
" and E-Mail. \n" );
info->setIndent(8);
info->setMaximumWidth( info->sizeHint().width() );
QVBox *page = new QVBox( page2 );
QHBox *row1 = new QHBox( page );
QHBox *row2 = new QHBox( page );
QHBox *row3 = new QHBox( page );
QHBox *row4 = new QHBox( page );
QHBox *row5 = new QHBox( page );
QLabel *label1 = new QLabel( " First Name: ", row1 );
label1->setAlignment( Qt::AlignVCenter );
QLabel *label2 = new QLabel( " Last Name: ", row2 );
label2->setAlignment( Qt::AlignVCenter );
QLabel *label3 = new QLabel( " Address: ", row3 );
label3->setAlignment( Qt::AlignVCenter );
QLabel *label4 = new QLabel( " Phone Number: ", row4 );
label4->setAlignment( Qt::AlignVCenter );
QLabel *label5 = new QLabel( " E-Mail: ", row5 );
label5->setAlignment( Qt::AlignVCenter );
label1->setMinimumWidth( label4->sizeHint().width() );
label2->setMinimumWidth( label4->sizeHint().width() );
label3->setMinimumWidth( label4->sizeHint().width() );
label4->setMinimumWidth( label4->sizeHint().width() );
label5->setMinimumWidth( label4->sizeHint().width() );
firstName = new QLineEdit( row1 );
lastName = new QLineEdit( row2 );
address = new QLineEdit( row3 );
phone = new QLineEdit( row4 );
email = new QLineEdit( row5 );
connect( firstName, SIGNAL( textChanged( const QString & ) ), this, SLOT( dataChanged( const QString & ) ) );
connect( lastName, SIGNAL( textChanged( const QString & ) ), this, SLOT( dataChanged( const QString & ) ) );
connect( email, SIGNAL( textChanged( const QString & ) ), this, SLOT( dataChanged( const QString & ) ) );
addPage( page2, "Personal Data" );
setHelpEnabled( page2, FALSE );
}
void Qt4TargetSetupWidget::addBuildConfigurationInfo(const BuildConfigurationInfo &info, bool importing)
{
if (importing) {
if (!m_haveImported) {
// disable everything on first import
for (int i = 0; i < m_enabled.count(); ++i) {
m_enabled[i] = false;
m_checkboxes[i]->setChecked(false);
}
m_selected = 0;
}
m_haveImported = true;
}
int pos = m_pathChoosers.count();
m_enabled.append(true);
++m_selected;
m_infoList.append(info);
QCheckBox *checkbox = new QCheckBox;
checkbox->setText(Qt4BuildConfigurationFactory::buildConfigurationDisplayName(info));
checkbox->setChecked(m_enabled.at(pos));
checkbox->setAttribute(Qt::WA_LayoutUsesWidgetRect);
m_newBuildsLayout->addWidget(checkbox, pos * 2, 0);
Utils::PathChooser *pathChooser = new Utils::PathChooser();
pathChooser->setExpectedKind(Utils::PathChooser::Directory);
pathChooser->setPath(info.directory);
QtSupport::BaseQtVersion *version = QtSupport::QtProfileInformation::qtVersion(m_profile);
if (!version)
return;
pathChooser->setReadOnly(!version->supportsShadowBuilds() || importing);
m_newBuildsLayout->addWidget(pathChooser, pos * 2, 1);
QLabel *reportIssuesLabel = new QLabel;
reportIssuesLabel->setIndent(32);
m_newBuildsLayout->addWidget(reportIssuesLabel, pos * 2 + 1, 0, 1, 2);
reportIssuesLabel->setVisible(false);
connect(checkbox, SIGNAL(toggled(bool)),
this, SLOT(checkBoxToggled(bool)));
connect(pathChooser, SIGNAL(changed(QString)),
this, SLOT(pathChanged()));
m_checkboxes.append(checkbox);
m_pathChoosers.append(pathChooser);
m_reportIssuesLabels.append(reportIssuesLabel);
m_issues.append(false);
reportIssues(pos);
emit selectedToggled();
}
MyListView() : QListView()
{
setObjectName("SuggestionPopup");
setStyleSheet("#SuggestionPopup {background-color:#FFFFFF; border:1px solid black;}");
setWindowFlags(Qt::Popup);
setMouseTracking(true);
m_tooltip = new QLabel(0, Qt::ToolTip);
//Stesso stile del popuop che lo contiene.
m_tooltip->hide();
m_tooltip->setObjectName("helpTooltip");
m_tooltip->setAlignment(Qt::AlignLeft);
m_tooltip->setIndent(1);
m_tooltip->setWordWrap(false);
}
//************************************************************************************************
//************************************** class ZFileSaveDialog ***********************************
//************************************************************************************************
ZFileSaveDialog::ZFileSaveDialog()
:MyBaseDlg()
{
QWidget *myWidget = new QWidget ( this );
QVBoxLayout *myVBoxLayout = new QVBoxLayout ( myWidget, 0 );
// label
QLabel *myLabel = new QLabel ( QString ( "Filename to save:" ), myWidget );
myVBoxLayout->addWidget ( myLabel, 0 );
myLabel->setIndent ( 5 );
myLabel->setAutoResize ( true );
// zlineedit
zmle = new ZMultiLineEdit(myWidget, true, 1, "ZMultiLineEdit");
zmle->setEdited(false);
zmle->setFixedHeight(myWidget->sizeHint().height());
zmle->setInsertionMethod ( ( ZMultiLineEdit::InsertionMethod ) 3 );
zmle->setFontPercent ( 0.7 );
zmle->setSizePolicy ( QSizePolicy ( QSizePolicy::Expanding, QSizePolicy::Expanding ) );
zmle->setCellHeight(22);
myVBoxLayout->addWidget ( zmle, 1 );
fb = new FileBrowser("*", QString ( "%I%M" ), myWidget, 0, ( ZSkinService::WidgetClsID ) 4);
fb->setDir("/");
QObject::connect(fb, SIGNAL(isFilePicked(bool)), SLOT(filePicked(bool)));
myVBoxLayout->addWidget ( fb, 1 );
setContentWidget ( myWidget );
ZSoftKey *softKey = new ZSoftKey ( NULL, this, this );
ZConfig IDini("/tmp/Z6ManagerLang", false);
QString IDval = IDini.readEntry(QString("Z6MANAGER"), QString("MENU_SELECT"), "");
softKey->setText ( ZSoftKey::LEFT, IDval, ( ZSoftKey::TEXT_PRIORITY ) 0 );
IDval = IDini.readEntry(QString("Z6MANAGER"), QString("MENU_CANCEL"), "");
softKey->setText ( ZSoftKey::RIGHT, IDval, ( ZSoftKey::TEXT_PRIORITY ) 0 );
softKey->setClickedSlot ( ZSoftKey::RIGHT, this, SLOT ( reject() ) );
softKey->setClickedSlot ( ZSoftKey::LEFT, this, SLOT ( accept() ) );
setCSTWidget ( softKey );
}
SplitRideDialog::SplitRideDialog(MainWindow *mainWindow)
: mainWindow(mainWindow)
{
setAttribute(Qt::WA_DeleteOnClose);
setWindowTitle("Split Ride");
listWidget = new QListWidget(this);
listWidget->setSelectionMode(QAbstractItemView::SingleSelection);
QLabel *splitLabel = new QLabel(tr("Split at the following positions:"), this);
QLabel *labelSpacer = new QLabel(this);
labelSpacer->setIndent(10);
okButton = new QPushButton(tr("&OK"), this);
cancelButton = new QPushButton(tr("&Cancel"), this);
connect(okButton, SIGNAL(clicked()), this, SLOT(okClicked()));
connect(cancelButton, SIGNAL(clicked()), this, SLOT(cancelClicked()));
connect(listWidget,
SIGNAL(itemSelectionChanged()), this, SLOT(selectionChanged()));
QHBoxLayout *buttonLayout = new QHBoxLayout;
buttonLayout->addWidget(okButton);
buttonLayout->addWidget(cancelButton);
QVBoxLayout *mainLayout = new QVBoxLayout(this);
mainLayout->addWidget(splitLabel);
mainLayout->addWidget(listWidget);
mainLayout->addWidget(labelSpacer);
mainLayout->addLayout(buttonLayout);
const RideFile *ride = mainWindow->currentRide();
QMap<int,QString> splitPoints;
QList<RideFileInterval> intervals = ride->intervals();
if (!intervals.empty()) {
intervals.removeFirst();
foreach (RideFileInterval interval, intervals) {
int nDataPoint = ride->intervalBegin(interval);
QString strDesc = QString("Interval %1").arg(interval.name);
splitPoints.insert(nDataPoint, strDesc);
}
DevStatus::DevStatus(QWidget *p)
: QStatusBar(p)
{
QLabel *l;
for ( int p = DevQt::General; p < DevQt::None; p++ )
{
l = new QLabel;
l->setIndent(2);
l->setMargin(2);
l->setAlignment(Qt::AlignLeft | Qt::AlignVCenter);
l->setFrameStyle(QFrame::Sunken | QFrame::StyledPanel);
l->setFixedWidth(fontMetrics().width("XXXXXXXXXXXXXXXXXXXXXXX"));
addWidget(l);
v.prepend(l);
}
connect(this, SIGNAL( messageChanged(const QString&) ),
this, SLOT ( clearMessage() ) );
}
//************************************************************************************************
//************************************** class ZFileSaveDialog ***********************************
//************************************************************************************************
ZFileSaveDialog::ZFileSaveDialog(const QString &curPath, const QString &originName)
:MyBaseDlg()
{
QWidget *myWidget = new QWidget ( this );
QVBoxLayout *myVBoxLayout = new QVBoxLayout ( myWidget, 0 );
// label
QLabel *myLabel = new QLabel ( QString ( "Nombre para guardar:" ), myWidget );
myVBoxLayout->addWidget ( myLabel, 0 );
myLabel->setIndent ( 5 );
myLabel->setAutoResize ( true );
// zlineedit
zmle = new ZMultiLineEdit(myWidget, true, 1, "ZMultiLineEdit");
zmle->setEdited(false);
zmle->setFixedHeight(myWidget->sizeHint().height());
zmle->setInsertionMethod ( ( ZMultiLineEdit::InsertionMethod ) 3 );
zmle->setFontPercent ( 0.7 );
zmle->setSizePolicy ( QSizePolicy ( QSizePolicy::Expanding, QSizePolicy::Expanding ) );
//zmle->setCellHeight(22);
zmle->setText(originName);
myVBoxLayout->addWidget ( zmle, 1 );
fb = new FileBrowser("*", QString ( "%I%M" ), myWidget, 0);
fb->setDir(curPath);
QObject::connect(fb, SIGNAL(isFilePicked(bool)), SLOT(filePicked(bool)));
myVBoxLayout->addWidget ( fb, 1 );
setContentWidget ( myWidget );
ZSoftKey *softKey = new ZSoftKey ( NULL, this, this );
softKey->setText ( ZSoftKey::LEFT, "Guardar", ( ZSoftKey::TEXT_PRIORITY ) 0 );
softKey->setText ( ZSoftKey::RIGHT, "Cancelar", ( ZSoftKey::TEXT_PRIORITY ) 0 );
softKey->setClickedSlot ( ZSoftKey::RIGHT, this, SLOT ( reject() ) );
softKey->setClickedSlot ( ZSoftKey::LEFT, this, SLOT ( accept() ) );
setCSTWidget ( softKey );
}
StartupView::StartupView(QWidget *parent) :
QWidget(parent)
{
setStyleSheet("openstudio--pat--StartupView { background: #808080; }");
QVBoxLayout * mainVLayout = new QVBoxLayout();
mainVLayout->setContentsMargins(0,0,0,0);
mainVLayout->setSpacing(10);
mainVLayout->setAlignment(Qt::AlignTop);
setLayout(mainVLayout);
QLabel * gettingStartedLabel = new QLabel("Getting Started");
gettingStartedLabel->setIndent(10);
gettingStartedLabel->setWordWrap(true);
gettingStartedLabel->setStyleSheet("QLabel { font-size: 20px; font: bold; color: #242D31; }");
mainVLayout->addWidget(gettingStartedLabel);
QLabel * newProjectLabel = new QLabel("Under File Menu Choose New Project or Open Project to Get Started");
newProjectLabel->setIndent(10);
newProjectLabel->setWordWrap(true);
newProjectLabel->setStyleSheet("QLabel { font-size: 14px; font: bold; color: black; }");
mainVLayout->addWidget(newProjectLabel);
// Organize
QString organizeDescription;
organizeDescription.append("Select the baseline model and measures you will use in this project. ");
organizeDescription.append("Measures can come from the local Building Component Library (BCL) ");
organizeDescription.append("or the Online BCL, ");
organizeDescription.append("or you can create your own, available in My Measures.");
QLabel * organizeImageLabel = new QLabel();
organizeImageLabel->setFixedSize(54,65);
organizeImageLabel->setPixmap(QPixmap(":images/measures_big.png"));
startupview::SubSection * organizeSection;
organizeSection = new startupview::SubSection("Organize and Edit Measures for Project",organizeDescription,organizeImageLabel);
mainVLayout->addWidget(organizeSection);
// Note 1
QString note1Text;
note1Text.append("Note: After completing this first tab, coming back to this tab and making changes ");
note1Text.append("may result in deletion or other changes to your design alternatives.");
startupview::Note * note1 = new startupview::Note(note1Text);
mainVLayout->addWidget(note1);
// Select
QString selectDescription;
selectDescription.append("Create a series of design alternatives that you want to run. ");
selectDescription.append("A design alternative is the baseline model with one or more measures applied. ");
selectDescription.append("Design alternatives allow you to perform \"what-if\" analyses with ");
selectDescription.append("different combinations of measures.");
QLabel * selectImageLabel = new QLabel();
selectImageLabel->setFixedSize(54,65);
selectImageLabel->setPixmap(QPixmap(":images/design_alts_big.png"));
startupview::SubSection * selectSection;
selectSection = new startupview::SubSection("Select Measures and Create Design Alternatives",selectDescription,selectImageLabel);
mainVLayout->addWidget(selectSection);
// Note 2
QString note2Text;
note2Text.append("Note: After completing the second tab, coming back to this tab and making changes ");
note2Text.append("will result in the deletion of simulation results.");
startupview::Note * note2 = new startupview::Note(note2Text);
mainVLayout->addWidget(note2);
// Run
QString runDescription;
runDescription.append("Once you've set up your design alternatives, you're ready to run the simulations. ");
runDescription.append("The run button will kick off each design alternative simulation process. ");
runDescription.append("After the simulations finish, you can dig down into the info messages, warning messages, ");
runDescription.append("and error messages from each design alternative.");
QLabel * runImageLabel = new QLabel();
runImageLabel->setFixedSize(54,65);
runImageLabel->setPixmap(QPixmap(":images/run_big.png"));
startupview::SubSection * runSection;
runSection = new startupview::SubSection("Run Simulations",runDescription,runImageLabel);
mainVLayout->addWidget(runSection);
// Create Reports
QString reportDescription;
reportDescription.append("Compare results from Design Alternatives. Currently only one report is available. ");
reportDescription.append("More reports are being developed.");
QLabel * reportImageLabel = new QLabel();
reportImageLabel->setFixedSize(54,65);
reportImageLabel->setPixmap(QPixmap(":images/results_big.png"));
startupview::SubSection * reportSection;
reportSection = new startupview::SubSection("Create and View Reports",reportDescription,reportImageLabel);
mainVLayout->addWidget(reportSection);
}
ClusterWindow::ClusterWindow(set<clusterSet*>* cs, QWidget* parent, const char* name)
: QWidget(parent, name)
{
// set up the relevant things..
clusterSets = cs; // ok that is great.. let's include
int labelIndent = 5;
QLabel* lNorm = new QLabel("Local Normalisation", this, "lNorm");
QLabel* iNorm = new QLabel("Individual Normalisation", this, "iNorm");
QLabel* mNorm = new QLabel("Mean Normalisation", this, "mNorm");
QLabel* cNum = new QLabel("Cluster Number", this, "cNum");
lNorm->setIndent(labelIndent);
iNorm->setIndent(labelIndent);
mNorm->setIndent(labelIndent);
cNum->setIndent(labelIndent);
// alignment, or let's just see how it handles it.
localNorm = new SmallToggle(1, this);
individualNorm = new SmallToggle(2, this);
meanNorm = new SmallToggle(3, this);
localNorm->setFixedSize(25, 25);
individualNorm->setFixedSize(25, 25);
meanNorm->setFixedSize(25, 25);
// and set them all to be on..
localNorm->setOn(true);
individualNorm->setOn(true);
meanNorm->setOn(true);
// and that should be fine for the buttons...
clusterNumber = new QSpinBox(this, "clusterNumber");
clusterNumber->setMinValue(1); // though this doesn't actually make much sense..
// clusterNumber->setMaxValue(30); // is there a reasonable way of doing this??
QPushButton* clusterButton = new QPushButton("Do Clustering", this, "clusterButton");
connect(clusterButton, SIGNAL(clicked()), this, SLOT(startClustering()) );
// and a QListView for storing some graphical representation of the clusters that we may receive..
clusterList = new QListView(this, "clusterList");
clusterList->addColumn("Cluster Set");
//clusterList->setSelectionMode(QListView::Extended);
connect(clusterList, SIGNAL(selectionChanged(QListViewItem*)), this, SLOT(clusterSelectionChanged(QListViewItem*)) );
// clusterList->addColumn("cluster");
// and make a plotter and hide it for now..
meanPlotter = new ClusterPlotter();
connect(meanPlotter, SIGNAL(pleaseLoadTheseGenes(vector<int>, QString)), this, SIGNAL(pleaseLoadTheseGenes(vector<int>, QString)) );
// meanPlotter = new MeanExpressionPlotter();
meanPlotter->resize(500, 300);
// and do the layout..
QGridLayout* grid = new QGridLayout(this, 6, 2, 5, 3, "grid");
grid->addWidget(lNorm, 0, 0);
grid->addWidget(localNorm, 0, 1, AlignRight);
grid->addWidget(iNorm, 1, 0);
grid->addWidget(individualNorm, 1, 1, AlignRight);
grid->addWidget(mNorm, 2, 0);
grid->addWidget(meanNorm, 2, 1, AlignRight);
grid->addWidget(cNum, 3, 0);
grid->addWidget(clusterNumber, 3, 1);
grid->addWidget(clusterButton, 4, 0);
grid->addMultiCellWidget(clusterList, 5, 5, 0, 1);
}
QWidget *MemcheckErrorDelegate::createDetailsWidget(const QModelIndex &errorIndex, QWidget *parent) const
{
QWidget *widget = new QWidget(parent);
QVBoxLayout *layout = new QVBoxLayout;
// code + white-space:pre so the padding (see below) works properly
// don't include frameName here as it should wrap if required and pre-line is not supported
// by Qt yet it seems
const QString displayTextTemplate = QString("<code style='white-space:pre'>%1:</code> %2");
QString relativeTo = relativeToPath();
const Error error = errorIndex.data(ErrorListModel::ErrorRole).value<Error>();
QLabel *errorLabel = new QLabel();
errorLabel->setWordWrap(true);
errorLabel->setContentsMargins(0, 0, 0, 0);
errorLabel->setMargin(0);
errorLabel->setIndent(0);
QPalette p = errorLabel->palette();
QColor lc = p.color(QPalette::Text);
QString linkStyle = QString("style=\"color:rgba(%1, %2, %3, %4);\"")
.arg(lc.red()).arg(lc.green()).arg(lc.blue()).arg(int(0.7 * 255));
p.setBrush(QPalette::Text, p.highlightedText());
errorLabel->setPalette(p);
errorLabel->setText(QString("%1 <span %4>%2</span>")
.arg(error.what(), errorLocation(errorIndex, error, true, linkStyle),
linkStyle));
connect(errorLabel, SIGNAL(linkActivated(QString)), SLOT(openLinkInEditor(QString)));
layout->addWidget(errorLabel);
const QVector<Stack> stacks = error.stacks();
for (int i = 0; i < stacks.count(); ++i) {
const Stack &stack = stacks.at(i);
// auxwhat for additional stacks
if (i > 0) {
QLabel *stackLabel = new QLabel(stack.auxWhat());
stackLabel->setWordWrap(true);
stackLabel->setContentsMargins(0, 0, 0, 0);
stackLabel->setMargin(0);
stackLabel->setIndent(0);
QPalette p = stackLabel->palette();
p.setBrush(QPalette::Text, p.highlightedText());
stackLabel->setPalette(p);
layout->addWidget(stackLabel);
}
int frameNr = 1;
foreach (const Frame &frame, stack.frames()) {
QString frameName = makeFrameName(frame, relativeTo);
QTC_ASSERT(!frameName.isEmpty(), qt_noop());
QLabel *frameLabel = new QLabel(widget);
frameLabel->setAutoFillBackground(true);
if (frameNr % 2 == 0) {
// alternating rows
QPalette p = frameLabel->palette();
p.setBrush(QPalette::Base, p.alternateBase());
frameLabel->setPalette(p);
}
frameLabel->setFont(QFont("monospace"));
connect(frameLabel, SIGNAL(linkActivated(QString)), SLOT(openLinkInEditor(QString)));
// pad frameNr to 2 chars since only 50 frames max are supported by valgrind
const QString displayText = displayTextTemplate
.arg(frameNr++, 2).arg(frameName);
frameLabel->setText(displayText);
frameLabel->setToolTip(Valgrind::XmlProtocol::toolTipForFrame(frame));
frameLabel->setWordWrap(true);
frameLabel->setContentsMargins(0, 0, 0, 0);
frameLabel->setMargin(0);
frameLabel->setIndent(10);
layout->addWidget(frameLabel);
}
}
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
widget->setLayout(layout);
return widget;
}
QWidget *QmlProfilerTool::createWidgets()
{
// Analyzer::AnalyzerManager *analyzerMgr = Analyzer::AnalyzerManager::instance();
// Utils::FancyMainWindow *mw = analyzerMgr->mainWindow();
QWidget *mw = this;
d->m_traceWindow = new TraceWindow(mw);
d->m_traceWindow->reset(d->m_client);
connect(d->m_traceWindow, SIGNAL(gotoSourceLocation(QString,int)),this, SLOT(gotoSourceLocation(QString,int)));
connect(d->m_traceWindow, SIGNAL(timeChanged(qreal)), this, SLOT(updateTimer(qreal)));
d->m_statistics = new QmlProfilerEventStatistics(mw);
d->m_eventsView = new QmlProfilerEventsView(mw, d->m_statistics);
d->m_eventsView->setViewType(QmlProfilerEventsView::EventsView);
connect(d->m_traceWindow, SIGNAL(range(int,int,int,qint64,qint64,QStringList,QString,int)),
d->m_statistics, SLOT(addRangedEvent(int,int,int,qint64,qint64,QStringList,QString,int)));
connect(d->m_traceWindow, SIGNAL(viewUpdated()),
d->m_statistics, SLOT(complete()));
connect(d->m_eventsView, SIGNAL(gotoSourceLocation(QString,int)),
this, SLOT(gotoSourceLocation(QString,int)));
d->m_calleeView = new QmlProfilerEventsView(mw, d->m_statistics);
d->m_calleeView->setViewType(QmlProfilerEventsView::CalleesView);
connect(d->m_calleeView, SIGNAL(gotoSourceLocation(QString,int)),
this, SLOT(gotoSourceLocation(QString,int)));
d->m_callerView = new QmlProfilerEventsView(mw, d->m_statistics);
d->m_callerView->setViewType(QmlProfilerEventsView::CallersView);
connect(d->m_callerView, SIGNAL(gotoSourceLocation(QString,int)),
this, SLOT(gotoSourceLocation(QString,int)));
#if 0
Core::ICore *core = Core::ICore::instance();
Core::ActionManager *am = core->actionManager();
Core::ActionContainer *manalyzer = am->actionContainer(Analyzer::Constants::M_DEBUG_ANALYZER);
const Core::Context globalcontext(Core::Constants::C_GLOBAL);
d->m_attachAction = new QAction(tr("Attach..."), manalyzer);
Core::Command *command = am->registerAction(d->m_attachAction,
Constants::ATTACH, globalcontext);
command->setAttribute(Core::Command::CA_UpdateText);
//manalyzer->addAction(command, Analyzer::Constants::G_ANALYZER_STARTSTOP);
connect(d->m_attachAction, SIGNAL(triggered()), this, SLOT(attach()));
updateAttachAction(false);
QDockWidget *eventsDock = AnalyzerManager::createDockWidget
(this, tr("Events"), d->m_eventsView, Qt::BottomDockWidgetArea);
QDockWidget *timelineDock = AnalyzerManager::createDockWidget
(this, tr("Timeline"), d->m_traceWindow, Qt::BottomDockWidgetArea);
QDockWidget *calleeDock = AnalyzerManager::createDockWidget
(this, tr("Callees"), d->m_calleeView, Qt::BottomDockWidgetArea);
QDockWidget *callerDock = AnalyzerManager::createDockWidget
(this, tr("Callers"), d->m_callerView, Qt::BottomDockWidgetArea);
mw->splitDockWidget(mw->toolBarDockWidget(), eventsDock, Qt::Vertical);
mw->tabifyDockWidget(eventsDock, timelineDock);
mw->tabifyDockWidget(timelineDock, calleeDock);
mw->tabifyDockWidget(calleeDock, callerDock);
#endif
QTabWidget *tabWidget = new QTabWidget;
tabWidget->addTab(d->m_eventsView, tr("Events"));
tabWidget->addTab(d->m_traceWindow, tr("Timeline"));
tabWidget->addTab(d->m_calleeView, tr("Callees"));
tabWidget->addTab(d->m_callerView, tr("Callers"));
//
// Toolbar
//
QWidget *toolbarWidget = new QWidget;
toolbarWidget->setObjectName(QLatin1String("QmlProfilerToolBarWidget"));
QHBoxLayout *layout = new QHBoxLayout;
layout->setMargin(0);
layout->setSpacing(0);
d->m_recordButton = new QToolButton(toolbarWidget);
// icon and tooltip set in setRecording(), called later
d->m_recordButton->setCheckable(true);
connect(d->m_recordButton,SIGNAL(toggled(bool)), this, SLOT(setRecording(bool)));
d->m_recordButton->setChecked(true);
layout->addWidget(d->m_recordButton);
d->m_clearButton = new QToolButton(toolbarWidget);
d->m_clearButton->setIcon(QIcon(QLatin1String(":/qmlprofiler/clean_pane_small.png")));
d->m_clearButton->setToolTip(tr("Discard data"));
connect(d->m_clearButton,SIGNAL(clicked()), this, SLOT(clearDisplay()));
layout->addWidget(d->m_clearButton);
QLabel *timeLabel = new QLabel(tr("Elapsed: 0 s"));
QPalette palette = timeLabel->palette();
palette.setColor(QPalette::WindowText, Qt::white);
timeLabel->setPalette(palette);
timeLabel->setIndent(10);
connect(this, SIGNAL(setTimeLabel(QString)), timeLabel, SLOT(setText(QString)));
layout->addWidget(timeLabel);
toolbarWidget->setLayout(layout);
QVBoxLayout *mainLayout = new QVBoxLayout(this);
mainLayout->addWidget(toolbarWidget);
mainLayout->addWidget(tabWidget);
return toolbarWidget;
}
void TimeLine::initUI()
{
Q_ASSERT( editor() != nullptr );
setWindowTitle( "Timeline" );
QWidget* timeLineContent = new QWidget( this );
connect( editor(), &Editor::currentFrameChanged, this, &TimeLine::updateFrame );
mLayerList = new TimeLineCells( this, editor(), TIMELINE_CELL_TYPE::Layers );
mTracks = new TimeLineCells( this, editor(), TIMELINE_CELL_TYPE::Tracks );
connect( mLayerList, &TimeLineCells::mouseMovedY, mLayerList, &TimeLineCells::setMouseMoveY );
connect( mLayerList, &TimeLineCells::mouseMovedY, mTracks, &TimeLineCells::setMouseMoveY );
mHScrollbar = new QScrollBar( Qt::Horizontal );
mVScrollbar = new QScrollBar( Qt::Vertical );
mVScrollbar->setMinimum( 0 );
mVScrollbar->setMaximum( 1 );
mVScrollbar->setPageStep( 1 );
updateLength( getFrameLength() );
QWidget* leftWidget = new QWidget();
leftWidget->setMinimumWidth( 120 );
QWidget* rightWidget = new QWidget();
QWidget* leftToolBar = new QWidget();
leftToolBar->setFixedHeight( 31 );
QWidget* rightToolBar = new QWidget();
rightToolBar->setFixedHeight( 31 );
// --- left widget ---
// --------- layer buttons ---------
QToolBar* layerButtons = new QToolBar( this );
QLabel* layerLabel = new QLabel( tr( "Layers:" ) );
layerLabel->setIndent( 5 );
layerLabel->setFont( QFont( "Helvetica", 10 ) );
QToolButton* addLayerButton = new QToolButton( this );
addLayerButton->setIcon( QIcon( ":icons/add.png" ) );
addLayerButton->setToolTip( "Add Layer" );
addLayerButton->setFixedSize( 24, 24 );
QToolButton* removeLayerButton = new QToolButton( this );
removeLayerButton->setIcon( QIcon( ":icons/remove.png" ) );
removeLayerButton->setToolTip( "Remove Layer" );
removeLayerButton->setFixedSize( 24, 24 );
layerButtons->addWidget( layerLabel );
layerButtons->addWidget( addLayerButton );
layerButtons->addWidget( removeLayerButton );
QHBoxLayout* leftToolBarLayout = new QHBoxLayout();
leftToolBarLayout->setAlignment( Qt::AlignLeft );
leftToolBarLayout->setMargin( 0 );
leftToolBarLayout->addWidget( layerButtons );
leftToolBar->setLayout( leftToolBarLayout );
QAction* newBitmapLayerAct = new QAction( QIcon( ":icons/layer-bitmap.png" ), tr( "New Bitmap Layer" ), this );
QAction* newVectorLayerAct = new QAction( QIcon( ":icons/layer-vector.png" ), tr( "New Vector Layer" ), this );
QAction* newSoundLayerAct = new QAction( QIcon( ":icons/layer-sound.png" ), tr( "New Sound Layer" ), this );
QAction* newCameraLayerAct = new QAction( QIcon( ":icons/layer-camera.png" ), tr( "New Camera Layer" ), this );
QMenu* layerMenu = new QMenu( tr( "&Layer" ), this );
layerMenu->addAction( newBitmapLayerAct );
layerMenu->addAction( newVectorLayerAct );
layerMenu->addAction( newSoundLayerAct );
layerMenu->addAction( newCameraLayerAct );
addLayerButton->setMenu( layerMenu );
addLayerButton->setPopupMode( QToolButton::InstantPopup );
QGridLayout* leftLayout = new QGridLayout();
leftLayout->addWidget( leftToolBar, 0, 0 );
leftLayout->addWidget( mLayerList, 1, 0 );
leftLayout->setMargin( 0 );
leftLayout->setSpacing( 0 );
leftWidget->setLayout( leftLayout );
// --- right widget ---
// --------- key buttons ---------
QToolBar* keyButtons = new QToolBar( this );
QLabel* keyLabel = new QLabel( tr( "Keys:" ) );
keyLabel->setFont( QFont( "Helvetica", 10 ) );
keyLabel->setIndent( 5 );
QToolButton* addKeyButton = new QToolButton( this );
addKeyButton->setIcon( QIcon( ":icons/add.png" ) );
addKeyButton->setToolTip( "Add Frame" );
addKeyButton->setFixedSize( 24, 24 );
QToolButton* removeKeyButton = new QToolButton( this );
removeKeyButton->setIcon( QIcon( ":icons/remove.png" ) );
removeKeyButton->setToolTip( "Remove Frame" );
removeKeyButton->setFixedSize( 24, 24 );
QToolButton* duplicateKeyButton = new QToolButton( this );
duplicateKeyButton->setIcon( QIcon( ":icons/controls/duplicate.png" ) );
duplicateKeyButton->setToolTip( "Duplicate Frame" );
duplicateKeyButton->setFixedSize( 24, 24 );
keyButtons->addWidget( keyLabel );
keyButtons->addWidget( addKeyButton );
keyButtons->addWidget( removeKeyButton );
keyButtons->addWidget( duplicateKeyButton );
QToolBar* onionButtons = new QToolBar( this );
QLabel* onionLabel = new QLabel( tr( "Onion skin:" ) );
onionLabel->setFont( QFont( "Helvetica", 10 ) );
onionLabel->setIndent( 5 );
QToolButton* onionTypeButton = new QToolButton( this );
onionTypeButton->setIcon( QIcon( ":icons/onion_type.png" ) );
onionTypeButton->setToolTip( "Toggle match keyframes" );
onionTypeButton->setFixedSize( 24, 24 );
onionButtons->addWidget( onionLabel );
onionButtons->addWidget( onionTypeButton );
// --------- Time controls ---------
mTimeControls = new TimeControls( this );
mTimeControls->setCore( editor() );
mTimeControls->initUI();
QHBoxLayout* rightToolBarLayout = new QHBoxLayout();
rightToolBarLayout->addWidget( keyButtons );
rightToolBarLayout->addStretch( 1 );
rightToolBarLayout->addWidget( onionButtons );
rightToolBarLayout->addStretch( 1 );
rightToolBarLayout->addWidget( mTimeControls );
rightToolBarLayout->setMargin( 0 );
rightToolBarLayout->setSpacing( 0 );
rightToolBar->setLayout( rightToolBarLayout );
QGridLayout* rightLayout = new QGridLayout();
rightLayout->addWidget( rightToolBar, 0, 0 );
rightLayout->addWidget( mTracks, 1, 0 );
rightLayout->setMargin( 0 );
rightLayout->setSpacing( 0 );
rightWidget->setLayout( rightLayout );
// --- Splitter ---
QSplitter* splitter = new QSplitter( this );
splitter->addWidget( leftWidget );
splitter->addWidget( rightWidget );
splitter->setSizes( QList<int>() << 100 << 600 );
QGridLayout* lay = new QGridLayout();
lay->addWidget( splitter, 0, 0 );
lay->addWidget( mVScrollbar, 0, 1 );
lay->addWidget( mHScrollbar, 1, 0 );
lay->setMargin( 0 );
lay->setSpacing( 0 );
timeLineContent->setLayout( lay );
setWidget( timeLineContent );
setWindowFlags( Qt::WindowStaysOnTopHint );
connect( mHScrollbar, &QScrollBar::valueChanged, mTracks, &TimeLineCells::hScrollChange );
connect( mVScrollbar, &QScrollBar::valueChanged, mTracks, &TimeLineCells::vScrollChange );
connect( mVScrollbar, &QScrollBar::valueChanged, mLayerList, &TimeLineCells::vScrollChange );
connect( addKeyButton, &QToolButton::clicked, this, &TimeLine::addKeyClick );
connect( removeKeyButton, &QToolButton::clicked, this, &TimeLine::removeKeyClick );
connect( duplicateKeyButton, &QToolButton::clicked, this, &TimeLine::duplicateKeyClick );
connect( onionTypeButton, &QToolButton::clicked, this, &TimeLine::toogleAbsoluteOnionClick );
connect( mTimeControls, &TimeControls::loopStartClick, this, &TimeLine::loopStartClick );
connect( mTimeControls, &TimeControls::loopEndClick, this, &TimeLine::loopEndClick );
connect( mTimeControls, &TimeControls::soundClick, this, &TimeLine::soundClick );
connect( mTimeControls, &TimeControls::fpsClick, this, &TimeLine::fpsClick );
connect( newBitmapLayerAct, &QAction::triggered, this, &TimeLine::newBitmapLayer );
connect( newVectorLayerAct, &QAction::triggered, this, &TimeLine::newVectorLayer );
connect( newSoundLayerAct, &QAction::triggered, this, &TimeLine::newSoundLayer );
connect( newCameraLayerAct, &QAction::triggered, this, &TimeLine::newCameraLayer );
connect( removeLayerButton, &QPushButton::clicked, this, &TimeLine::deleteCurrentLayer );
LayerManager* layer = editor()->layers();
connect( layer, &LayerManager::layerCountChanged, this, &TimeLine::updateLayerNumber );
scrubbing = false;
}
WaveEdit::WaveEdit(MusECore::PartList* pl, QWidget* parent, const char* name)
: MidiEditor(TopWin::WAVE, 1, pl, parent, name)
{
setFocusPolicy(Qt::NoFocus);
colorMode = colorModeInit;
QSignalMapper* mapper = new QSignalMapper(this);
QSignalMapper* colorMapper = new QSignalMapper(this);
QAction* act;
//---------Pulldown Menu----------------------------
// We probably don't need an empty menu - Orcan
//QMenu* menuFile = menuBar()->addMenu(tr("&File"));
QMenu* menuEdit = menuBar()->addMenu(tr("&Edit"));
menuFunctions = menuBar()->addMenu(tr("Func&tions"));
menuGain = menuFunctions->addMenu(tr("&Gain"));
act = menuGain->addAction("200%");
mapper->setMapping(act, WaveCanvas::CMD_GAIN_200);
connect(act, SIGNAL(triggered()), mapper, SLOT(map()));
act = menuGain->addAction("150%");
mapper->setMapping(act, WaveCanvas::CMD_GAIN_150);
connect(act, SIGNAL(triggered()), mapper, SLOT(map()));
act = menuGain->addAction("75%");
mapper->setMapping(act, WaveCanvas::CMD_GAIN_75);
connect(act, SIGNAL(triggered()), mapper, SLOT(map()));
act = menuGain->addAction("50%");
mapper->setMapping(act, WaveCanvas::CMD_GAIN_50);
connect(act, SIGNAL(triggered()), mapper, SLOT(map()));
act = menuGain->addAction("25%");
mapper->setMapping(act, WaveCanvas::CMD_GAIN_25);
connect(act, SIGNAL(triggered()), mapper, SLOT(map()));
act = menuGain->addAction(tr("Other"));
mapper->setMapping(act, WaveCanvas::CMD_GAIN_FREE);
connect(act, SIGNAL(triggered()), mapper, SLOT(map()));
connect(mapper, SIGNAL(mapped(int)), this, SLOT(cmd(int)));
menuFunctions->addSeparator();
copyAction = menuEdit->addAction(tr("&Copy"));
mapper->setMapping(copyAction, WaveCanvas::CMD_EDIT_COPY);
connect(copyAction, SIGNAL(triggered()), mapper, SLOT(map()));
copyPartRegionAction = menuEdit->addAction(tr("&Create Part from Region"));
mapper->setMapping(copyPartRegionAction, WaveCanvas::CMD_CREATE_PART_REGION);
connect(copyPartRegionAction, SIGNAL(triggered()), mapper, SLOT(map()));
cutAction = menuEdit->addAction(tr("C&ut"));
mapper->setMapping(cutAction, WaveCanvas::CMD_EDIT_CUT);
connect(cutAction, SIGNAL(triggered()), mapper, SLOT(map()));
pasteAction = menuEdit->addAction(tr("&Paste"));
mapper->setMapping(pasteAction, WaveCanvas::CMD_EDIT_PASTE);
connect(pasteAction, SIGNAL(triggered()), mapper, SLOT(map()));
act = menuEdit->addAction(tr("Edit in E&xternal Editor"));
mapper->setMapping(act, WaveCanvas::CMD_EDIT_EXTERNAL);
connect(act, SIGNAL(triggered()), mapper, SLOT(map()));
menuEdit->addSeparator();
// REMOVE Tim. Also remove CMD_ADJUST_WAVE_OFFSET and so on...
// adjustWaveOffsetAction = menuEdit->addAction(tr("Adjust wave offset..."));
// mapper->setMapping(adjustWaveOffsetAction, WaveCanvas::CMD_ADJUST_WAVE_OFFSET);
// connect(adjustWaveOffsetAction, SIGNAL(triggered()), mapper, SLOT(map()));
act = menuFunctions->addAction(tr("Mute Selection"));
mapper->setMapping(act, WaveCanvas::CMD_MUTE);
connect(act, SIGNAL(triggered()), mapper, SLOT(map()));
act = menuFunctions->addAction(tr("Normalize Selection"));
mapper->setMapping(act, WaveCanvas::CMD_NORMALIZE);
connect(act, SIGNAL(triggered()), mapper, SLOT(map()));
act = menuFunctions->addAction(tr("Fade In Selection"));
mapper->setMapping(act, WaveCanvas::CMD_FADE_IN);
connect(act, SIGNAL(triggered()), mapper, SLOT(map()));
act = menuFunctions->addAction(tr("Fade Out Selection"));
mapper->setMapping(act, WaveCanvas::CMD_FADE_OUT);
connect(act, SIGNAL(triggered()), mapper, SLOT(map()));
act = menuFunctions->addAction(tr("Reverse Selection"));
mapper->setMapping(act, WaveCanvas::CMD_REVERSE);
connect(act, SIGNAL(triggered()), mapper, SLOT(map()));
select = menuEdit->addMenu(QIcon(*selectIcon), tr("Select"));
selectAllAction = select->addAction(QIcon(*select_allIcon), tr("Select &All"));
mapper->setMapping(selectAllAction, WaveCanvas::CMD_SELECT_ALL);
connect(selectAllAction, SIGNAL(triggered()), mapper, SLOT(map()));
selectNoneAction = select->addAction(QIcon(*select_allIcon), tr("&Deselect All"));
mapper->setMapping(selectNoneAction, WaveCanvas::CMD_SELECT_NONE);
connect(selectNoneAction, SIGNAL(triggered()), mapper, SLOT(map()));
select->addSeparator();
selectPrevPartAction = select->addAction(QIcon(*select_all_parts_on_trackIcon), tr("&Previous Part"));
mapper->setMapping(selectPrevPartAction, WaveCanvas::CMD_SELECT_PREV_PART);
connect(selectPrevPartAction, SIGNAL(triggered()), mapper, SLOT(map()));
selectNextPartAction = select->addAction(QIcon(*select_all_parts_on_trackIcon), tr("&Next Part"));
mapper->setMapping(selectNextPartAction, WaveCanvas::CMD_SELECT_NEXT_PART);
connect(selectNextPartAction, SIGNAL(triggered()), mapper, SLOT(map()));
QMenu* settingsMenu = menuBar()->addMenu(tr("Window &Config"));
eventColor = settingsMenu->addMenu(tr("&Event Color"));
QActionGroup* actgrp = new QActionGroup(this);
actgrp->setExclusive(true);
evColorNormalAction = actgrp->addAction(tr("&Part colors"));
evColorNormalAction->setCheckable(true);
colorMapper->setMapping(evColorNormalAction, 0);
evColorPartsAction = actgrp->addAction(tr("&Gray"));
evColorPartsAction->setCheckable(true);
colorMapper->setMapping(evColorPartsAction, 1);
connect(evColorNormalAction, SIGNAL(triggered()), colorMapper, SLOT(map()));
connect(evColorPartsAction, SIGNAL(triggered()), colorMapper, SLOT(map()));
eventColor->addActions(actgrp->actions());
connect(colorMapper, SIGNAL(mapped(int)), this, SLOT(eventColorModeChanged(int)));
settingsMenu->addSeparator();
settingsMenu->addAction(subwinAction);
settingsMenu->addAction(shareAction);
settingsMenu->addAction(fullscreenAction);
connect(MusEGlobal::muse, SIGNAL(configChanged()), SLOT(configChanged()));
//--------------------------------------------------
// ToolBar: Solo Cursor1 Cursor2
tools2 = new MusEGui::EditToolBar(this, waveEditTools);
addToolBar(tools2);
addToolBarBreak();
tb1 = addToolBar(tr("WaveEdit tools"));
tb1->setObjectName("WaveEdit tools");
//tb1->setLabel(tr("weTools"));
solo = new QToolButton();
solo->setText(tr("Solo"));
solo->setCheckable(true);
solo->setFocusPolicy(Qt::NoFocus);
tb1->addWidget(solo);
connect(solo, SIGNAL(toggled(bool)), SLOT(soloChanged(bool)));
QLabel* label = new QLabel(tr("Cursor"));
tb1->addWidget(label);
label->setAlignment(Qt::AlignRight|Qt::AlignVCenter);
label->setIndent(3);
pos1 = new PosLabel(0);
pos1->setFixedHeight(22);
tb1->addWidget(pos1);
pos2 = new PosLabel(0);
pos2->setFixedHeight(22);
pos2->setSmpte(true);
tb1->addWidget(pos2);
//---------------------------------------------------
// Rest
//---------------------------------------------------
int yscale = 256;
int xscale;
if (!parts()->empty()) { // Roughly match total size of part
MusECore::Part* firstPart = parts()->begin()->second;
xscale = 0 - firstPart->lenFrame()/_widthInit[_type];
}
else {
xscale = -8000;
}
hscroll = new ScrollScale(-32768, 1, xscale, 10000, Qt::Horizontal, mainw, 0, false, 10000.0);
//view = new WaveView(this, mainw, xscale, yscale);
canvas = new WaveCanvas(this, mainw, xscale, yscale);
//wview = canvas; // HACK!
QSizeGrip* corner = new QSizeGrip(mainw);
ymag = new QSlider(Qt::Vertical, mainw);
ymag->setMinimum(1);
ymag->setMaximum(256);
ymag->setPageStep(256);
ymag->setValue(yscale);
ymag->setFocusPolicy(Qt::NoFocus);
time = new MTScale(&_raster, mainw, xscale, true);
ymag->setFixedWidth(16);
connect(canvas, SIGNAL(mouseWheelMoved(int)), this, SLOT(moveVerticalSlider(int)));
connect(ymag, SIGNAL(valueChanged(int)), canvas, SLOT(setYScale(int)));
connect(canvas, SIGNAL(horizontalZoom(bool, const QPoint&)), SLOT(horizontalZoom(bool, const QPoint&)));
connect(canvas, SIGNAL(horizontalZoom(int, const QPoint&)), SLOT(horizontalZoom(int, const QPoint&)));
time->setOrigin(0, 0);
mainGrid->setRowStretch(0, 100);
mainGrid->setColumnStretch(0, 100);
mainGrid->addWidget(time, 0, 0, 1, 2);
mainGrid->addWidget(MusECore::hLine(mainw), 1, 0, 1, 2);
mainGrid->addWidget(canvas, 2, 0);
mainGrid->addWidget(ymag, 2, 1);
mainGrid->addWidget(hscroll, 3, 0);
mainGrid->addWidget(corner, 3, 1, Qt::AlignBottom | Qt::AlignRight);
canvas->setFocus();
connect(canvas, SIGNAL(toolChanged(int)), tools2, SLOT(set(int)));
connect(tools2, SIGNAL(toolChanged(int)), canvas, SLOT(setTool(int)));
connect(hscroll, SIGNAL(scrollChanged(int)), canvas, SLOT(setXPos(int)));
connect(hscroll, SIGNAL(scaleChanged(int)), canvas, SLOT(setXMag(int)));
setWindowTitle(canvas->getCaption());
connect(canvas, SIGNAL(followEvent(int)), hscroll, SLOT(setOffset(int)));
connect(hscroll, SIGNAL(scrollChanged(int)), time, SLOT(setXPos(int)));
connect(hscroll, SIGNAL(scaleChanged(int)), time, SLOT(setXMag(int)));
connect(time, SIGNAL(timeChanged(unsigned)), SLOT(timeChanged(unsigned)));
connect(canvas, SIGNAL(timeChanged(unsigned)), SLOT(setTime(unsigned)));
connect(canvas, SIGNAL(horizontalScroll(unsigned)),hscroll, SLOT(setPos(unsigned)));
connect(canvas, SIGNAL(horizontalScrollNoLimit(unsigned)),hscroll, SLOT(setPosNoLimit(unsigned)));
connect(hscroll, SIGNAL(scaleChanged(int)), SLOT(updateHScrollRange()));
connect(MusEGlobal::song, SIGNAL(songChanged(MusECore::SongChangedFlags_t)), SLOT(songChanged1(MusECore::SongChangedFlags_t)));
// For the wave editor, let's start with the operation range selection tool.
canvas->setTool(MusEGui::RangeTool);
tools2->set(MusEGui::RangeTool);
setEventColorMode(colorMode);
initShortcuts();
updateHScrollRange();
configChanged();
if(!parts()->empty())
{
MusECore::WavePart* part = (MusECore::WavePart*)(parts()->begin()->second);
solo->setChecked(part->track()->solo());
}
initTopwinState();
finalizeInit();
}
MiniTargetWidget::MiniTargetWidget(Target *target, QWidget *parent) :
QWidget(parent), m_target(target)
{
Q_ASSERT(m_target);
if (hasBuildConfiguration()) {
m_buildComboBox = new QComboBox;
m_buildComboBox->setProperty("alignarrow", true);
m_buildComboBox->setProperty("hideborder", true);
m_buildComboBox->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Preferred);
m_buildComboBox->setToolTip(tr("Select active build configuration"));
} else {
m_buildComboBox = 0;
}
m_runComboBox = new QComboBox;
m_runComboBox ->setProperty("alignarrow", true);
m_runComboBox ->setProperty("hideborder", true);
m_runComboBox->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Preferred);
m_runComboBox->setToolTip(tr("Select active run configuration"));
int fontSize = font().pointSize();
setStyleSheet(QString::fromLatin1("QLabel { font-size: %2pt; color: white; } "
"#target { font: bold %1pt;} "
"#buildLabel{ font: bold; color: rgba(255, 255, 255, 160)} "
"#runLabel { font: bold ; color: rgba(255, 255, 255, 160)} "
).arg(fontSize).arg(fontSize - 2));
QGridLayout *gridLayout = new QGridLayout(this);
m_targetName = new QLabel(m_target->displayName());
m_targetName->setObjectName(QString::fromUtf8("target"));
m_targetIcon = new QLabel();
updateIcon();
if (hasBuildConfiguration()) {
Q_FOREACH(BuildConfiguration* bc, m_target->buildConfigurations())
addBuildConfiguration(bc);
connect(m_target, SIGNAL(addedBuildConfiguration(ProjectExplorer::BuildConfiguration*)),
SLOT(addBuildConfiguration(ProjectExplorer::BuildConfiguration*)));
connect(m_target, SIGNAL(removedBuildConfiguration(ProjectExplorer::BuildConfiguration*)),
SLOT(removeBuildConfiguration(ProjectExplorer::BuildConfiguration*)));
connect(m_target, SIGNAL(activeBuildConfigurationChanged(ProjectExplorer::BuildConfiguration*)),
SLOT(setActiveBuildConfiguration()));
connect(m_buildComboBox, SIGNAL(currentIndexChanged(int)), SLOT(setActiveBuildConfiguration(int)));
}
Q_FOREACH(RunConfiguration* rc, m_target->runConfigurations())
addRunConfiguration(rc);
connect(m_target, SIGNAL(addedRunConfiguration(ProjectExplorer::RunConfiguration*)),
SLOT(addRunConfiguration(ProjectExplorer::RunConfiguration*)));
connect(m_target, SIGNAL(removedRunConfiguration(ProjectExplorer::RunConfiguration*)),
SLOT(removeRunConfiguration(ProjectExplorer::RunConfiguration*)));
connect(m_runComboBox, SIGNAL(currentIndexChanged(int)), SLOT(setActiveRunConfiguration(int)));
connect(m_target, SIGNAL(activeRunConfigurationChanged(ProjectExplorer::RunConfiguration*)),
SLOT(setActiveRunConfiguration()));
connect(m_target, SIGNAL(iconChanged()), this, SLOT(updateIcon()));
QHBoxLayout *buildHelperLayout = 0;
if (hasBuildConfiguration()) {
buildHelperLayout= new QHBoxLayout;
buildHelperLayout->setMargin(0);
buildHelperLayout->setSpacing(0);
buildHelperLayout->addWidget(m_buildComboBox);
}
QHBoxLayout *runHelperLayout = new QHBoxLayout;
runHelperLayout->setMargin(0);
runHelperLayout->setSpacing(0);
runHelperLayout->addWidget(m_runComboBox);
QFormLayout *formLayout = new QFormLayout;
formLayout->setLabelAlignment(Qt::AlignRight);
QLabel *lbl;
int indent = 10;
if (hasBuildConfiguration()) {
lbl = new QLabel(tr("Build:"));
lbl->setObjectName(QString::fromUtf8("buildLabel"));
lbl->setMinimumWidth(lbl->fontMetrics().width(lbl->text()) + indent + 4);
lbl->setIndent(indent);
formLayout->addRow(lbl, buildHelperLayout);
}
lbl = new QLabel(tr("Run:"));
lbl->setObjectName(QString::fromUtf8("runLabel"));
lbl->setMinimumWidth(lbl->fontMetrics().width(lbl->text()) + indent + 4);
lbl->setIndent(indent);
formLayout->addRow(lbl, runHelperLayout);
gridLayout->addWidget(m_targetName, 0, 0);
gridLayout->addWidget(m_targetIcon, 0, 1, 2, 1, Qt::AlignTop|Qt::AlignHCenter);
gridLayout->addLayout(formLayout, 1, 0);
}
CoverFoundDialog::CoverFoundDialog( const CoverFetchUnit::Ptr unit,
const CoverFetch::Metadata &data,
QWidget *parent )
: KDialog( parent )
, m_album( unit->album() )
, m_isSorted( false )
, m_sortEnabled( false )
, m_unit( unit )
, m_queryPage( 0 )
{
DEBUG_BLOCK
setButtons( KDialog::Ok | KDialog::Cancel |
KDialog::User1 ); // User1: clear icon view
setButtonGuiItem( KDialog::User1, KStandardGuiItem::clear() );
connect( button( KDialog::User1 ), SIGNAL(clicked()), SLOT(clearView()) );
m_save = button( KDialog::Ok );
QSplitter *splitter = new QSplitter( this );
m_sideBar = new CoverFoundSideBar( m_album, splitter );
KVBox *vbox = new KVBox( splitter );
vbox->setSpacing( 4 );
KHBox *breadcrumbBox = new KHBox( vbox );
QLabel *breadcrumbLabel = new QLabel( i18n( "Finding cover for" ), breadcrumbBox );
AlbumBreadcrumbWidget *breadcrumb = new AlbumBreadcrumbWidget( m_album, breadcrumbBox );
QFont breadcrumbLabelFont;
breadcrumbLabelFont.setBold( true );
breadcrumbLabel->setFont( breadcrumbLabelFont );
breadcrumbLabel->setIndent( 4 );
connect( breadcrumb, SIGNAL(artistClicked(const QString&)), SLOT(addToCustomSearch(const QString&)) );
connect( breadcrumb, SIGNAL(albumClicked(const QString&)), SLOT(addToCustomSearch(const QString&)) );
KHBox *searchBox = new KHBox( vbox );
vbox->setSpacing( 4 );
QStringList completionNames;
QString firstRunQuery( m_album->name() );
completionNames << firstRunQuery;
if( m_album->hasAlbumArtist() )
{
const QString &name = m_album->albumArtist()->name();
completionNames << name;
firstRunQuery += ' ' + name;
}
m_query = firstRunQuery;
m_album->setSuppressImageAutoFetch( true );
m_search = new KComboBox( searchBox );
m_search->setEditable( true ); // creates a KLineEdit for the combobox
m_search->setTrapReturnKey( true );
m_search->setInsertPolicy( QComboBox::NoInsert ); // insertion is handled by us
m_search->setCompletionMode( KGlobalSettings::CompletionPopup );
m_search->setSizePolicy( QSizePolicy::MinimumExpanding, QSizePolicy::Fixed );
qobject_cast<KLineEdit*>( m_search->lineEdit() )->setClickMessage( i18n( "Enter Custom Search" ) );
m_search->completionObject()->setOrder( KCompletion::Insertion );
m_search->completionObject()->setIgnoreCase( true );
m_search->completionObject()->setItems( completionNames );
m_search->insertItem( 0, KStandardGuiItem::find().icon(), QString() );
m_search->insertSeparator( 1 );
m_search->insertItem( 2, KIcon("filename-album-amarok"), m_album->name() );
if( m_album->hasAlbumArtist() )
m_search->insertItem( 3, KIcon("filename-artist-amarok"), m_album->albumArtist()->name() );
m_searchButton = new KPushButton( KStandardGuiItem::find(), searchBox );
KPushButton *sourceButton = new KPushButton( KStandardGuiItem::configure(), searchBox );
updateSearchButton( firstRunQuery );
QMenu *sourceMenu = new QMenu( sourceButton );
QAction *lastFmAct = new QAction( i18n( "Last.fm" ), sourceMenu );
QAction *googleAct = new QAction( i18n( "Google" ), sourceMenu );
QAction *yahooAct = new QAction( i18n( "Yahoo!" ), sourceMenu );
QAction *discogsAct = new QAction( i18n( "Discogs" ), sourceMenu );
lastFmAct->setCheckable( true );
googleAct->setCheckable( true );
yahooAct->setCheckable( true );
discogsAct->setCheckable( true );
connect( lastFmAct, SIGNAL(triggered()), this, SLOT(selectLastFm()) );
connect( googleAct, SIGNAL(triggered()), this, SLOT(selectGoogle()) );
connect( yahooAct, SIGNAL(triggered()), this, SLOT(selectYahoo()) );
connect( discogsAct, SIGNAL(triggered()), this, SLOT(selectDiscogs()) );
m_sortAction = new QAction( i18n( "Sort by size" ), sourceMenu );
m_sortAction->setCheckable( true );
connect( m_sortAction, SIGNAL(triggered(bool)), this, SLOT(sortingTriggered(bool)) );
QActionGroup *ag = new QActionGroup( sourceButton );
ag->addAction( lastFmAct );
ag->addAction( googleAct );
ag->addAction( yahooAct );
ag->addAction( discogsAct );
sourceMenu->addActions( ag->actions() );
sourceMenu->addSeparator();
sourceMenu->addAction( m_sortAction );
sourceButton->setMenu( sourceMenu );
connect( m_search, SIGNAL(returnPressed(const QString&)), SLOT(insertComboText(const QString&)) );
connect( m_search, SIGNAL(returnPressed(const QString&)), SLOT(processQuery(const QString&)) );
connect( m_search, SIGNAL(returnPressed(const QString&)), SLOT(updateSearchButton(const QString&)) );
connect( m_search, SIGNAL(editTextChanged(const QString&)), SLOT(updateSearchButton(const QString&)) );
connect( m_search->lineEdit(), SIGNAL(clearButtonClicked()), SLOT(clearQueryButtonClicked()));
connect( m_searchButton, SIGNAL(clicked()), SLOT(processQuery()) );
m_view = new KListWidget( vbox );
m_view->setAcceptDrops( false );
m_view->setContextMenuPolicy( Qt::CustomContextMenu );
m_view->setDragDropMode( QAbstractItemView::NoDragDrop );
m_view->setDragEnabled( false );
m_view->setDropIndicatorShown( false );
m_view->setMovement( QListView::Static );
m_view->setGridSize( QSize( 140, 150 ) );
m_view->setIconSize( QSize( 120, 120 ) );
m_view->setSpacing( 4 );
m_view->setViewMode( QListView::IconMode );
m_view->setResizeMode( QListView::Adjust );
connect( m_view, SIGNAL(currentItemChanged(QListWidgetItem*, QListWidgetItem*)),
this, SLOT(currentItemChanged(QListWidgetItem*, QListWidgetItem*)) );
connect( m_view, SIGNAL(itemDoubleClicked(QListWidgetItem*)),
this, SLOT(itemDoubleClicked(QListWidgetItem*)) );
connect( m_view, SIGNAL(customContextMenuRequested(const QPoint&)),
this, SLOT(itemMenuRequested(const QPoint&)) );
splitter->addWidget( m_sideBar );
splitter->addWidget( vbox );
setMainWidget( splitter );
const KConfigGroup config = Amarok::config( "Cover Fetcher" );
const QString source = config.readEntry( "Interactive Image Source", "LastFm" );
m_sortEnabled = config.readEntry( "Sort by Size", false );
m_sortAction->setChecked( m_sortEnabled );
m_isSorted = m_sortEnabled;
restoreDialogSize( config ); // call this after setMainWidget()
if( source == "LastFm" )
lastFmAct->setChecked( true );
else if( source == "Yahoo" )
yahooAct->setChecked( true );
else if( source == "Discogs" )
discogsAct->setChecked( true );
else
googleAct->setChecked( true );
typedef CoverFetchArtPayload CFAP;
const CFAP *payload = dynamic_cast< const CFAP* >( unit->payload() );
if( !m_album->hasImage() )
m_sideBar->setPixmap( QPixmap::fromImage( m_album->image(190 ) ) );
else if( payload )
add( m_album->image(), data, payload->imageSize() );
else
add( m_album->image(), data );
m_view->setCurrentItem( m_view->item( 0 ) );
updateGui();
connect( The::networkAccessManager(), SIGNAL( requestRedirected( QNetworkReply*, QNetworkReply* ) ),
this, SLOT( fetchRequestRedirected( QNetworkReply*, QNetworkReply* ) ) );
}
Window::Window()
{
this->timerDelay = 250;
setWalls();
this->helper.b->initialize();
//setWalls();
setWindowTitle(QString("Mosquito Buzz Buzz: " + this->helper.b->player->playerName));
this->openGL = new GLWidget(&this->helper, this);
QGridLayout *layout = new QGridLayout;
layout->addWidget(openGL, 0, 1);
//layout->addWidget(openGLLabel, 1, 1);
setLayout(layout);
this->mosquitoLabel = new QLabel(this);
layout->addWidget(this->mosquitoLabel, 1, 1);
mosquitoLabel->setText("Mosquitoes Eaten: 0");
mosquitoLabel->setAlignment(Qt::AlignLeft);
this->roundLabel = new QLabel(this);
layout->addWidget(this->roundLabel, 1, 1);
roundLabel->setText("Round: 0");
roundLabel->setAlignment(Qt::AlignHCenter);
this->timer = new QTimer(this);
connect(this->timer, SIGNAL(timeout()), openGL, SLOT(animate()));
connect(this->timer, SIGNAL (timeout()), this, SLOT(updateText()));
this->timer->start(this->timerDelay);
this->stepButton = new QPushButton("Step", this);
layout->addWidget(stepButton, 3, 1);
layout->setAlignment(stepButton, Qt::AlignTop);
connect(stepButton, SIGNAL (released()), openGL, SLOT (step()));
connect(stepButton, SIGNAL (released()), this, SLOT(updateText()));
this->playButton = new QPushButton("Play", this);
this->playButton->setMinimumWidth(250);
layout->addWidget(playButton, 4, 1);
layout->setAlignment(playButton, Qt::AlignLeft);
connect(playButton, SIGNAL (released()), openGL, SLOT (play()));
connect(playButton, SIGNAL (released()), this, SLOT(play()));
this->pauseButton = new QPushButton("Pause", this);
this->pauseButton->setMinimumWidth(250);
layout->addWidget(pauseButton, 4, 1);
layout->setAlignment(pauseButton, Qt::AlignRight);
connect(pauseButton, SIGNAL (released()), this, SLOT (stop()));
connect(pauseButton, SIGNAL (released()), openGL, SLOT (stop()));
this->newGameButton = new QPushButton("Begin New Game", this);
layout->addWidget(newGameButton, 1, 1);
layout->setAlignment(newGameButton, Qt::AlignRight);
connect(newGameButton, SIGNAL (released()), this, SLOT(startNewGame()));
this->timeDelaySlider = new QSlider(Qt::Horizontal, this);
this->timeDelaySlider->setFixedWidth(400);
this->timeDelaySlider->setMinimum(0);
this->timeDelaySlider->setSingleStep(10);
this->timeDelaySlider->setValue(250);
this->timeDelaySlider->setMaximum(800);
this->timeDelaySlider->setSingleStep(10);
connect(this->timeDelaySlider, SIGNAL (sliderReleased()), this, SLOT(changeTimerDelay()));
layout->addWidget(this->timeDelaySlider, 5, 1);
layout->setAlignment(this->timeDelaySlider, Qt::AlignRight);
QLabel* timerLabel = new QLabel(this);
layout->addWidget(timerLabel, 5, 1);
layout->setAlignment(timerLabel, Qt::AlignLeft);
timerLabel->setText("Timer Delay");
timerLabel->setIndent(10);
timerLabel->setBuddy(this->timeDelaySlider);
QLabel* captureTargetLabel = new QLabel(this);
layout->addWidget(captureTargetLabel, 2, 1);
captureTargetLabel->setIndent(65);
captureTargetLabel->setText("Capture Target (%)");
this->captureTargetSpinBox = new QSpinBox; // set percentage for capture rate needed to win
captureTargetSpinBox->setRange(1, 100);
captureTargetSpinBox->setValue(100);
layout->addWidget(captureTargetSpinBox, 2, 1);
layout->setAlignment(captureTargetSpinBox, Qt::AlignLeft);
connect(captureTargetSpinBox, SIGNAL(valueChanged(int)), this, SLOT(updateCaptureTarget()));
QLabel* roundsLabel = new QLabel(this);
layout->addWidget(roundsLabel, 2, 1);
layout->setAlignment(roundsLabel, Qt::AlignCenter);
roundsLabel->setIndent(170);
roundsLabel->setText("Rounds (max)");
this->maxRoundsSpinBox = new QSpinBox; // set max num of rounds before game over
maxRoundsSpinBox->setRange(100, 10000);
maxRoundsSpinBox->setValue(5000);
layout->addWidget(maxRoundsSpinBox, 2, 1);
layout->setAlignment(maxRoundsSpinBox, Qt::AlignCenter);
connect(maxRoundsSpinBox, SIGNAL(valueChanged(int)), this, SLOT(updateMaxRounds()));
}
Toolbar1::Toolbar1(QWidget* parent, int r, bool sp)
: QToolBar(QString("Pos/Snap/Solo-tools"), parent)
{
setObjectName("Pos/Snap/Solo-tools");
pitch = 0;
showPitch = sp;
solo = new QToolButton();
solo->setText(tr("Solo"));
solo->setCheckable(true);
solo->setFocusPolicy(Qt::NoFocus);
//solo->setContentsMargins(0,0,0,0);
addWidget(solo);
//---------------------------------------------------
// Cursor Position
//---------------------------------------------------
QLabel* label = new QLabel(tr("Cursor"));
label->setAlignment(Qt::AlignRight|Qt::AlignVCenter);
label->setIndent(3);
//label->setContentsMargins(0,0,0,0);
addWidget(label);
pos = new PosLabel(0, "pos");
addWidget(pos);
if (showPitch) {
pitch = new PitchLabel(0);
pitch->setEnabled(false);
addWidget(pitch);
}
//---------------------------------------------------
// Raster
//---------------------------------------------------
raster = new LabelCombo(tr("Snap"), 0);
raster->setFocusPolicy(Qt::TabFocus);
//raster->setContentsMargins(0,0,0,0);
rlist = new QTableWidget(10, 3);
rlist->verticalHeader()->setDefaultSectionSize(22);
rlist->horizontalHeader()->setDefaultSectionSize(32);
rlist->setSelectionMode(QAbstractItemView::SingleSelection);
rlist->verticalHeader()->hide();
rlist->horizontalHeader()->hide();
//rlist->setContentsMargins(0,0,0,0);
rlist->setMinimumWidth(96);
raster->setView(rlist);
for (int j = 0; j < 3; j++)
for (int i = 0; i < 10; i++)
rlist->setItem(i, j, new QTableWidgetItem(tr(rasterStrings[i + j * 10])));
setRaster(r);
//setContentsMargins(0,0,0,0);
addWidget(raster);
connect(raster, SIGNAL(activated(int)), SLOT(_rasterChanged(int)));
connect(solo, SIGNAL(toggled(bool)), SIGNAL(soloChanged(bool)));
pos->setEnabled(false);
}
KexiRelationsView::KexiRelationsView(QWidget *parent)
: KexiView(parent)
, d(new Private)
{
QWidget *mainWidget = new QWidget(this);
QGridLayout *g = new QGridLayout(mainWidget);
g->setContentsMargins(0, 0, 0, 0);
g->setSpacing(KexiUtils::spacingHint());
QWidget *horWidget = new QWidget(mainWidget);
QHBoxLayout *hlyr = new QHBoxLayout(horWidget);
hlyr->setContentsMargins(0, 0, 0, 0);
g->addWidget(horWidget, 0, 0);
d->tableCombo = new KComboBox(horWidget);
d->tableCombo->setObjectName("tables_combo");
d->tableCombo->setMinimumWidth(QFontMetrics(font()).width("w")*20);
d->tableCombo->setInsertPolicy(QComboBox::NoInsert);
d->tableCombo->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Preferred));
QLabel *lbl = new QLabel(xi18n("Table:"), horWidget);
lbl->setBuddy(d->tableCombo);
lbl->setIndent(3);
hlyr->addWidget(lbl);
hlyr->addWidget(d->tableCombo);
d->btnAdd = new QPushButton(xi18nc("Insert table/query into relations view", "&Insert"), horWidget);
hlyr->addWidget(d->btnAdd);
hlyr->addStretch(1);
connect(d->btnAdd, SIGNAL(clicked()), this, SLOT(slotAddTable()));
d->scrollArea = new KexiRelationsScrollArea(mainWidget);
d->scrollArea->setObjectName("scroll_area");
setViewWidget(mainWidget, false/* no focus proxy */);
setFocusProxy(d->scrollArea);
g->addWidget(d->scrollArea, 1, 0);
//actions
d->tableQueryPopup = new QMenu(this);
d->tableQueryPopup->setObjectName("tableQueryPopup");
connect(d->tableQueryPopup, SIGNAL(aboutToShow()), this, SLOT(aboutToShowPopupMenu()));
d->hideTableAction = plugSharedAction("edit_delete", xi18n("&Hide Table"), d->tableQueryPopup);
if (d->hideTableAction)
d->hideTableAction->setIcon(QIcon());
d->connectionPopup = new QMenu(this);
d->connectionPopup->setObjectName("connectionPopup");
connect(d->connectionPopup, SIGNAL(aboutToShow()), this, SLOT(aboutToShowPopupMenu()));
//! @todo areaPopup
d->areaPopup = new QMenu(this);
d->areaPopup->setObjectName("areaPopup");
d->appendSelectedFieldAction = new QAction(koIcon("add_field"), xi18n("&Append Field"), this);
d->appendSelectedFieldAction->setObjectName("relationsview_appendField");
connect(d->appendSelectedFieldAction, SIGNAL(triggered()),
this, SLOT(appendSelectedFields()));
d->appendSelectedFieldsAction = new QAction(koIcon("add_field"), xi18n("&Append Fields"), this);
d->appendSelectedFieldsAction->setObjectName("relationsview_appendFields");
connect(d->appendSelectedFieldsAction, SIGNAL(triggered()),
this, SLOT(appendSelectedFields()));
d->openSelectedTableAction = new QAction(koIcon("document-open"), xi18n("&Open Table"), this);
d->openSelectedTableAction->setObjectName("relationsview_openTable");
connect(d->openSelectedTableAction, SIGNAL(triggered()),
this, SLOT(openSelectedTable()));
d->designSelectedTableAction = new QAction(koIcon("document-properties"), xi18n("&Design Table"), this);
connect(d->designSelectedTableAction, SIGNAL(triggered()),
this, SLOT(designSelectedTable()));
d->designSelectedTableAction->setObjectName("relationsview_designTable");
plugSharedAction("edit_delete", this, SLOT(removeSelectedObject()));
connect(d->scrollArea, SIGNAL(tableViewGotFocus()),
this, SLOT(tableViewGotFocus()));
connect(d->scrollArea, SIGNAL(connectionViewGotFocus()),
this, SLOT(connectionViewGotFocus()));
connect(d->scrollArea, SIGNAL(emptyAreaGotFocus()),
this, SLOT(emptyAreaGotFocus()));
connect(d->scrollArea, SIGNAL(tableContextMenuRequest(QPoint)),
this, SLOT(tableContextMenuRequest(QPoint)));
connect(d->scrollArea, SIGNAL(connectionContextMenuRequest(QPoint)),
this, SLOT(connectionContextMenuRequest(QPoint)));
connect(d->scrollArea, SIGNAL(tableHidden(KDbTableSchema*)),
this, SLOT(slotTableHidden(KDbTableSchema*)));
connect(d->scrollArea, SIGNAL(tablePositionChanged(KexiRelationsTableContainer*)),
this, SIGNAL(tablePositionChanged(KexiRelationsTableContainer*)));
connect(d->scrollArea, SIGNAL(aboutConnectionRemove(KexiRelationsConnection*)),
this, SIGNAL(aboutConnectionRemove(KexiRelationsConnection*)));
//! @todo
#if 0
if (!embedd) {
/*todo setContextHelp(xi18n("Relations"), xi18n("To create a relationship simply drag the source field onto the target field. "
"An arrowhead is used to show which table is the parent (master) and which table is the child (slave) in the relationship."));*/
}
#endif
#ifdef TESTING_KexiRelationWidget
for (int i = 0;i < (int)d->db->tableNames().count();i++)
QTimer::singleShot(100, this, SLOT(slotAddTable()));
#endif
invalidateActions();
}
NoteInfo::NoteInfo(QWidget* parent)
: QToolBar(tr("Note Info"), parent)
{
deltaMode = false;
//QLabel* label = new QLabel(tr("Start"), this, "Start");
QLabel* label = new QLabel(tr("Start"));
label->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
label->setIndent(3);
addWidget(label);
//selTime = new PosEdit(this, "Start");
///selTime = new PosEdit(0, "Start");
selTime = new Awl::PosEdit;
selTime->setObjectName("Start");
addWidget(selTime);
//label = new QLabel(tr("Len"), this, "Len");
label = new QLabel(tr("Len"));
label->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
label->setIndent(3);
addWidget(label);
//selLen = new QSpinBox(0, 100000, 1, this);
selLen = new QSpinBox();
selLen->setRange(0, 100000);
selLen->setSingleStep(1);
addWidget(selLen);
//label = new QLabel(tr("Pitch"), this, "Pitch");
label = new QLabel(tr("Pitch"));
label->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
label->setIndent(3);
addWidget(label);
//selPitch = new PitchEdit(this, "selPitch");
selPitch = new PitchEdit;
addWidget(selPitch);
//label = new QLabel(tr("Velo On"), this, "Velocity On");
label = new QLabel(tr("Velo On"));
label->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
label->setIndent(3);
addWidget(label);
//selVelOn = new QSpinBox(0, 127, 1, this);
selVelOn = new QSpinBox();
selVelOn->setRange(0, 127);
selVelOn->setSingleStep(1);
addWidget(selVelOn);
//label = new QLabel(tr("Velo Off"), this, "Velocity Off");
label = new QLabel(tr("Velo Off"));
label->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
label->setIndent(3);
addWidget(label);
//selVelOff = new QSpinBox(0, 127, 1, this);
selVelOff = new QSpinBox();
selVelOff->setRange(0, 127);
selVelOff->setSingleStep(1);
addWidget(selVelOff);
connect(selLen, SIGNAL(valueChanged(int)), SLOT(lenChanged(int)));
connect(selPitch, SIGNAL(valueChanged(int)), SLOT(pitchChanged(int)));
connect(selVelOn, SIGNAL(valueChanged(int)), SLOT(velOnChanged(int)));
connect(selVelOff, SIGNAL(valueChanged(int)), SLOT(velOffChanged(int)));
connect(selTime, SIGNAL(valueChanged(const Pos&)), SLOT(timeChanged(const Pos&)));
}
TimeControls::TimeControls( QWidget* parent ) : QToolBar( parent )
{
QSettings settings( PENCIL2D, PENCIL2D );
mFpsBox = new QSpinBox();
mFpsBox->setFont( QFont("Helvetica", 10) );
mFpsBox->setFixedHeight(22);
mFpsBox->setValue(settings.value("fps").toInt());
mFpsBox->setMinimum(1);
mFpsBox->setMaximum(50);
mFpsBox->setToolTip("Frames per second");
mFpsBox->setFocusPolicy(Qt::NoFocus);
mLoopStartSpinBox = new QSpinBox();
mLoopStartSpinBox->setFont( QFont("Helvetica", 10) );
mLoopStartSpinBox->setFixedHeight(22);
mLoopStartSpinBox->setValue(settings.value("loopStart").toInt());
mLoopStartSpinBox->setMinimum(1);
mLoopStartSpinBox->setToolTip(tr("Start of loop"));
mLoopStartSpinBox->setFocusPolicy(Qt::NoFocus);
mLoopEndSpinBox= new QSpinBox();
mLoopEndSpinBox->setFont( QFont("Helvetica", 10) );
mLoopEndSpinBox->setFixedHeight(22);
mLoopEndSpinBox->setMinimum(2);
mLoopEndSpinBox->setToolTip(tr("End of loop"));
mLoopEndSpinBox->setFocusPolicy(Qt::NoFocus);
mLoopEndSpinBox->setValue( settings.value( "loopEnd" ).toInt() );
mPlaybackRangeCheckBox = new QCheckBox( tr("Range") );
mPlaybackRangeCheckBox->setFont( QFont("Helvetica", 10) );
mPlaybackRangeCheckBox->setFixedHeight(26);
mPlaybackRangeCheckBox->setToolTip(tr("Loop control"));
mPlayButton = new QPushButton( this );
mLoopButton = new QPushButton();
mSoundButton = new QPushButton();
mJumpToEndButton= new QPushButton();
mJumpToStartButton= new QPushButton();
QLabel* separator = new QLabel();
separator->setPixmap(QPixmap(":icons/controls/separator.png"));
separator->setFixedSize(QSize(37,31));
QLabel* spacingLabel = new QLabel("");
spacingLabel->setIndent(6);
QLabel* fpsLabel = new QLabel(tr("Fps: "));
fpsLabel->setIndent(6);
QIcon playIcon(":icons/controls/play.png");
QIcon loopIcon(":icons/controls/loop.png");
QIcon soundIcon(":icons/controls/sound.png");
QIcon endplayIcon(":icons/controls/endplay.png");
QIcon startplayIcon(":icons/controls/startplay.png");
mPlayButton->setIcon(playIcon);
mLoopButton->setIcon(loopIcon);
mSoundButton->setIcon(soundIcon);
mJumpToEndButton->setIcon(endplayIcon);
mJumpToStartButton->setIcon(startplayIcon);
mPlayButton->setToolTip(tr("Play"));
mLoopButton->setToolTip(tr("Loop"));
mSoundButton->setToolTip(tr("Sound on/off"));
mJumpToEndButton->setToolTip(tr("End"));
mJumpToStartButton->setToolTip(tr("Start"));
mLoopButton->setCheckable(true);
mSoundButton->setCheckable(true);
mSoundButton->setChecked(true);
addWidget(separator);
addWidget(mJumpToStartButton);
addWidget(mPlayButton);
addWidget(mJumpToEndButton);
addWidget(mLoopButton);
addWidget(mPlaybackRangeCheckBox);
addWidget(mLoopStartSpinBox);
addWidget(mLoopEndSpinBox);
addWidget(mSoundButton);
addWidget(fpsLabel);
addWidget(mFpsBox);
makeConnections();
auto spinBoxValueChanged = static_cast< void ( QSpinBox::* )( int ) >( &QSpinBox::valueChanged );
connect( mLoopStartSpinBox, spinBoxValueChanged, this, &TimeControls::loopStartClick );
connect( mLoopEndSpinBox, spinBoxValueChanged, this, &TimeControls::loopEndClick );
connect( mPlaybackRangeCheckBox, &QCheckBox::toggled, mLoopStartSpinBox, &QSpinBox::setEnabled );
connect( mPlaybackRangeCheckBox, &QCheckBox::toggled, mLoopEndSpinBox, &QSpinBox::setEnabled );
connect( mSoundButton, &QPushButton::clicked, this, &TimeControls::soundClick );
connect( mFpsBox, spinBoxValueChanged, this, &TimeControls::fpsClick );
}
void SettingWidget::createValueWidget()
{
rsArgument* argument = task->getArgument(option->name);
switch(option->type) {
case G_OPTION_ARG_FILENAME:
case G_OPTION_ARG_STRING:
case G_OPTION_ARG_STRING_ARRAY:
case G_OPTION_ARG_CALLBACK:
case G_OPTION_ARG_INT:
case G_OPTION_ARG_INT64:
case G_OPTION_ARG_DOUBLE:
{
// Display text box if number of values is not restricted
if ( option->allowedValues == NULL ) {
if ( option->nLines < 2 ) {
QLineEdit *w = new QLineEdit();
valueWidget = w;
w->setPlaceholderText(option->cli_arg_description);
connect(w, SIGNAL(textChanged(QString)), this, SLOT(textChanged(QString)));
if ( argument != NULL ) {
w->setText(argument->value);
} else if ( option->defaultValue != NULL ) {
w->setText(option->defaultValue);
}
} else { // create a QTextEdit field instead
QPlainTextEdit *w = new QPlainTextEdit();
valueWidget = w;
connect(w, SIGNAL(textChanged()), this, SLOT(textChanged()));
if ( argument != NULL ) {
w->setPlainText(argument->value);
} else if ( option->defaultValue != NULL ) {
w->setPlainText(option->defaultValue);
}
QFontMetrics m(w->font()) ;
int rowHeight = m.lineSpacing() ;
w->setFixedHeight(option->nLines * rowHeight) ;
w->setLineWrapMode(QPlainTextEdit::NoWrap);
}
} else { // if the allowed values are restricted display radio buttons instead
QWidget *w = new QWidget();
QBoxLayout *wLayout = new QBoxLayout(QBoxLayout::TopToBottom);
QButtonGroup *buttonGroup = new QButtonGroup();
buttonGroup->setExclusive(true);
valueWidget = w;
connect(buttonGroup, SIGNAL(buttonClicked(int)), this, SLOT(buttonClicked(int)));
// go through all options and add a radio button for them
rsUIOptionValue** values = option->allowedValues;
for (size_t i=0; values[i] != NULL; i++ ) {
// add radio button
QRadioButton *b = new QRadioButton(QString("'")+QString(values[i]->name)+QString("'"));
QFont f("Arial", 12, QFont::Bold);
b->setFont(f);
buttonGroup->addButton(b, (int)i);
wLayout->addWidget(b);
// set it to checked if it is the default or set value
b->setChecked(false);
if ( argument != NULL ) {
if ( ! strcmp(argument->value,values[i]->name) ) {
b->setChecked(true);
}
} else if ( ! strcmp(option->defaultValue,values[i]->name) ) {
b->setChecked(true);
}
// add its description
QLabel *label = new QLabel(values[i]->description);
label->setIndent(22);
label->setWordWrap(true);
label->setContentsMargins(0, 0, 0, 4);
QFont f2("Arial", 11, QFont::Normal);
label->setFont(f2);
wLayout->addWidget(label);
}
w->setLayout(wLayout);
}
}
break;
/*
case G_OPTION_ARG_INT:
case G_OPTION_ARG_INT64:
valueWidget = new QSpinBox();
break;
case G_OPTION_ARG_DOUBLE:
valueWidget = new QDoubleSpinBox();
break;
*/
case G_OPTION_ARG_NONE:
{
QCheckBox *w = new QCheckBox("Enabled"); // new SwitchWidget();
valueWidget = w;
connect(w, SIGNAL(stateChanged(int)), this, SLOT(stateChanged(int)));
if ( argument != NULL ) {
w->setCheckState(Qt::Checked);
} else {
w->setCheckState(Qt::Unchecked);
}
}
break;
default:
throw std::invalid_argument("UI argument type unknown");
}
}
