inline void MainWindow::createCheckBoxLegend()
{
QWidget* iLegend = new QWidget;
iLegend->setStyleSheet("background-color: red;");
iLegend->setFixedSize(16, 16);
iLegend->setAutoFillBackground(true);
QWidget* bLegend = new QWidget;
bLegend->setStyleSheet("background-color: blue;");
bLegend->setFixedSize(16, 16);
bLegend->setAutoFillBackground(true);
QWidget* pLegend = new QWidget;
pLegend->setStyleSheet("background-color: yellow;");
pLegend->setFixedSize(16, 16);
pLegend->setAutoFillBackground(true);
QWidget* sLegend = new QWidget;
sLegend->setStyleSheet("background-color: green;");
sLegend->setFixedSize(16, 16);
sLegend->setAutoFillBackground(true);
checkBoxLayout->addWidget(iLegend, 0, 1);
checkBoxLayout->addWidget(bLegend, 1, 1);
checkBoxLayout->addWidget(pLegend, 2, 1);
checkBoxLayout->addWidget(sLegend, 3, 1);
}
HeadbandWidget::HeadbandWidget(QWidget *parent):QWidget(parent)
{
setPalette(QPalette(Qt::cyan));
setAutoFillBackground(true);
bL = new QHBoxLayout();
QWidget* w = new QWidget(this);
w->setAttribute(Qt::WA_TransparentForMouseEvents);
w->setPalette(QPalette(Qt::red));
w->setAutoFillBackground(true);
w->setFixedWidth(500);
QWidget* w1 = new QWidget(this);
w1->setAttribute(Qt::WA_TransparentForMouseEvents);
w1->setPalette(QPalette(Qt::green));
w1->setAutoFillBackground(true);
w1->setFixedWidth(300);
//Ajout des widget au layout
bL->addWidget(w);
bL->addWidget(w1);
this->setLayout(bL);
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
QWidget w;
w.setWindowTitle ( "Quelle est cette note?" );
w.setFixedSize(800, 720);
// set color background
QPalette Pal(w.palette());
Pal.setColor(QPalette::Background, QColor::fromRgb(250, 250, 250));
w.setAutoFillBackground(true);
w.setPalette(Pal);
po = new Portee(&w);
Piano *pi = new Piano(&w);
po->setPiano(pi);
addMenus(&w);
QVBoxLayout qvbox;
qvbox.addWidget(po);
qvbox.addWidget(pi);
w.setLayout(&qvbox);
w.show();
return a.exec();
}
QWidget* CWizDocumentView::createClient()
{
QWidget* client = new QWidget(this);
QVBoxLayout* layout = new QVBoxLayout(client);
client->setLayout(layout);
client->setAutoFillBackground(true);
QPalette pal = palette();
pal.setColor(QPalette::Window, QColor(0xff, 0xff, 0xff));
client->setPalette(pal);
QWidget* line = new QWidget(this);
line->setMaximumHeight(1);
line->setMinimumHeight(1);
line->setStyleSheet("border-bottom-width:1;border-bottom-style:solid;border-bottom-color:#bbbbbb");
layout->setSpacing(0);
layout->setContentsMargins(0, 0, 0, 0);
layout->addWidget(m_title);
layout->addWidget(line);
layout->addWidget(m_web);
layout->setStretchFactor(m_title, 0);
layout->setStretchFactor(m_web, 1);
return client;
}
void Overlay::showEntry(MetaEntry* entry){
QWidget *box = new QWidget(this);
// background color
QPalette Pal(palette());
Pal.setColor(QPalette::Background, QColor(255, 255, 255, 30));
box->setAutoFillBackground(true);
box->setPalette(Pal);
// calculate size
int w = this->size().width(), h = this->size().height();
int boxW = entry->width * w, boxH = entry->height * h, boxX = entry->left * w, boxY = entry->top * h;
if(mouseX >= boxX && mouseX <= boxX+boxW)
if(mouseY >= boxY && mouseY <= boxY+boxH){
box->setGeometry(boxX, boxY, boxW, boxH);
box->show();
}
boxes[entry] = box;
//printf("Show %d\n", entry->itemId);
//printf("box %d %d %d %d\n", boxX, boxY, boxW, boxH);
}
void GLViewer::setup()
{
QSurfaceFormat format;
format.setVersion(3, 2);
format.setProfile(QSurfaceFormat::CoreProfile);
format.setDepthBufferSize(16);
m_canvas = new Canvas(format);
m_canvas->setContinuousRepaint(true, 0);
m_canvas->setSwapInterval(Canvas::VerticalSyncronization);
m_canvas->setPainter(m_painter);
QWidget *widget = QWidget::createWindowContainer(m_canvas);
widget->setMinimumSize(1, 1);
widget->setAutoFillBackground(false); // Important for overdraw, not occluding the scene.
widget->setFocusPolicy(Qt::TabFocus);
widget->setParent(this);
QHBoxLayout *layout = new QHBoxLayout;
layout->setContentsMargins(0, 0, 0, 0);
layout->addWidget(widget);
setLayout(layout);
show();
}
void SettingsWidget::chModule(QListWidgetItem *w)
{
if (w)
{
page3->module = (Module *)w->data(Qt::UserRole).value<void *>();
QWidget *w = page3->module->getSettingsWidget();
if (w)
{
QLayout *layout = w->layout();
layout->setMargin(2);
if (QFormLayout *fLayout = qobject_cast<QFormLayout *>(layout))
fLayout->setFieldGrowthPolicy(QFormLayout::ExpandingFieldsGrow);
else if (QGridLayout *gLayout = qobject_cast<QGridLayout *>(layout))
{
if (!gLayout->property("NoVHSpacer").toBool())
{
gLayout->addItem(new QSpacerItem(0, 0, QSizePolicy::Minimum, QSizePolicy::Expanding), gLayout->rowCount(), 0); //vSpacer
gLayout->addItem(new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Minimum), 0, gLayout->columnCount()); //hSpacer
}
}
page3->scrollA->setWidget(w);
w->setAutoFillBackground(false);
}
else if (page3->scrollA->widget())
page3->scrollA->widget()->close(); //ustawi się na nullptr po usunięciu (WA_DeleteOnClose)
}
}
QWidget *QgsAttributeTableDelegate::createEditor( QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index ) const
{
Q_UNUSED( option );
QgsVectorLayer *vl = layer( index.model() );
if ( !vl )
return nullptr;
int fieldIdx = index.model()->data( index, QgsAttributeTableModel::FieldIndexRole ).toInt();
QgsAttributeEditorContext context( masterModel( index.model() )->editorContext(), QgsAttributeEditorContext::Popup );
QgsEditorWidgetWrapper *eww = QgsGui::editorWidgetRegistry()->create( vl, fieldIdx, nullptr, parent, context );
QWidget *w = eww->widget();
w->setAutoFillBackground( true );
w->setFocusPolicy( Qt::StrongFocus ); // to make sure QMouseEvents are propagated to the editor widget
const int fieldOrigin = vl->fields().fieldOrigin( fieldIdx );
bool readOnly = true;
if ( fieldOrigin == QgsFields::OriginJoin )
{
int srcFieldIndex;
const QgsVectorLayerJoinInfo *info = vl->joinBuffer()->joinForFieldIndex( fieldIdx, vl->fields(), srcFieldIndex );
if ( info && info->isEditable() )
readOnly = info->joinLayer()->editFormConfig().readOnly( srcFieldIndex );
}
else
readOnly = vl->editFormConfig().readOnly( fieldIdx );
eww->setEnabled( !readOnly );
return w;
}
void MainWindow::initCells()
{
if (centralWidget() != 0) {
delete centralWidget();
}
QWidget *grid = new QWidget();
QPalette pal;
pal.setBrush(QPalette::Active, QPalette::Window,QBrush(QColor("#b2b5c7")));
grid->setPalette(pal);
grid->setAutoFillBackground(true);
grid->setBackgroundRole(QPalette::Window);
QGridLayout* layout = new QGridLayout;
layout->setHorizontalSpacing(0);
layout->setVerticalSpacing(0);
layout->setSizeConstraint(QLayout::SetNoConstraint);
//layout->setContentsMargins(1,1,1,1);
layout->setContentsMargins(0,0,0,0);
for(int i = 0; i < BoardSize; i++)
{
for(int j = 0; j < BoardSize; j++)
{
int ii = i * BoardSize + j;
board[ii] = new Cell(grid, ii);
connect(board[ii], SIGNAL(cellClicked(int)), SLOT(cellClicked(int)));
layout->addWidget(board[ii], i, j);
}
}
grid->setLayout(layout);
setCentralWidget(grid);
QApplication::processEvents();
doResize();
}
SetupPlugins::SetupPlugins(QWidget* parent)
: QScrollArea(parent), d(new SetupPluginsPriv)
{
QWidget* panel = new QWidget(viewport());
setWidget(panel);
setWidgetResizable(true);
QVBoxLayout* layout = new QVBoxLayout(panel);
d->pluginsNumber = new QLabel(panel);
if (KIPI::PluginLoader::instance())
{
d->kipiConfig = KIPI::PluginLoader::instance()->configWidget(panel);
d->kipiConfig->setWhatsThis(i18n("A list of available Kipi plugins appears below."));
}
layout->addWidget(d->pluginsNumber);
layout->addWidget(d->kipiConfig);
layout->setMargin(KDialog::spacingHint());
layout->setSpacing(KDialog::spacingHint());
if (KIPI::PluginLoader::instance())
{
KIPI::PluginLoader::PluginList list = KIPI::PluginLoader::instance()->pluginList();
initPlugins((int)list.count());
}
// --------------------------------------------------------
setAutoFillBackground(false);
viewport()->setAutoFillBackground(false);
panel->setAutoFillBackground(false);
}
void
GcSplitter::prepare(QString cyclist, QString name)
{
this->name = name;
this->cyclist = cyclist;
QWidget *spacer = new QWidget(this);
spacer->setAutoFillBackground(false);
spacer->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
control->addWidget(spacer);
// get saved state
QString statesetting = GC_QSETTINGS_ATHLETE_LAYOUT+QString("splitter/%1/sizes").arg(name);
QVariant sizes = appsettings->cvalue(cyclist, statesetting);
if (sizes != QVariant()) {
splitter->restoreState(sizes.toByteArray());
splitter->setOpaqueResize(true); // redraw when released, snappier UI
}
// should we hide / show each widget?
for(int i=0; i<splitter->count(); i++) {
QString hidesetting = GC_QSETTINGS_ATHLETE_LAYOUT+QString("splitter/%1/hide/%2").arg(name).arg(i);
QVariant hidden = appsettings->cvalue(cyclist, hidesetting);
if (i && hidden != QVariant()) {
if (hidden.toBool() == true) {
splitter->widget(i)->hide();
}
}
}
}
void MainWindow::attachAllWidget()
{
QString displayname;
for(int i = 0; i < displayDocklist.size();i++)
{
displayname = QString("/usr/local/opi/ui/")+displayDocklist.at(i)+".ui";
pattach = new AttachChannelAccess(displayname.toStdString().c_str(), i);
vecACHAcc.push_back(pattach);
if (!pattach->GetWidget())
{
QWidget *page = new QWidget();
QPushButton *pbut = new QPushButton(page);
pbut -> setGeometry(0,0,180,40);
char display[30];
sprintf(display,"%s: %d",displayname.toStdString().c_str(), i);
pbut -> setText(display);
stackedWidget->addWidget(page);
}
else
{
QWidget *w = pattach->GetWidget();
w->setAutoFillBackground (true);
stackedWidget->addWidget(pattach->GetWidget());
};
};
}
void
MainWindow::attachWidget()
{
QStringList uilist;
QString displayname;
uilist<<"ExperimentsStatus"<<"SD_Machine_Status";
hbox = new QHBoxLayout();
stackedWidget = new QStackedWidget(centralwidget);
hbox->addWidget(stackedWidget);
centralwidget->setLayout(hbox);
for(int i = 0; i < uilist.size();i++)
{
displayname = QString("/usr/local/opi/ui/")+uilist.at(i)+".ui";
pattach = new AttachChannelAccess(displayname.toStdString().c_str(), i);
vecACHAcc.push_back(pattach);
if (!pattach->GetWidget())
{
qDebug("%s isn't exist.", displayname.toStdString().c_str());
}
else
{
QWidget *w = pattach->GetWidget();
w->setAutoFillBackground (true);
stackedWidget->addWidget(pattach->GetWidget());
};
};
stackedWidget->setCurrentIndex(0);
}
QWidget *QgsAttributeTableDelegate::createEditor(
QWidget *parent,
const QStyleOptionViewItem &option,
const QModelIndex &index ) const
{
Q_UNUSED( option );
QgsVectorLayer *vl = layer( index.model() );
if ( !vl )
return NULL;
int fieldIdx = index.model()->data( index, QgsAttributeTableModel::FieldIndexRole ).toInt();
QWidget *w = QgsAttributeEditor::createAttributeEditor( parent, 0, vl, fieldIdx, index.model()->data( index, Qt::EditRole ) );
w->setAutoFillBackground( true );
if ( parent )
{
QgsAttributeTableView *tv = dynamic_cast<QgsAttributeTableView *>( parent->parentWidget() );
w->setMinimumWidth( tv->columnWidth( index.column() ) );
if ( vl->editType( fieldIdx ) == QgsVectorLayer::FileName ||
vl->editType( fieldIdx ) == QgsVectorLayer::Calendar )
{
QLineEdit *le = w->findChild<QLineEdit*>();
le->adjustSize();
w->setMinimumHeight( le->height()*2 ); // FIXME: there must be a better way to do this
}
}
return w;
}
WebView *TabWidget::newTab(bool makeCurrent)
{
// line edit
UrlLineEdit *urlLineEdit = new UrlLineEdit;
QLineEdit *lineEdit = urlLineEdit->lineEdit();
if (!m_lineEditCompleter && count() > 0) {
HistoryCompletionModel *completionModel = new HistoryCompletionModel(this);
completionModel->setSourceModel(BrowserApplication::historyManager()->historyFilterModel());
m_lineEditCompleter = new QCompleter(completionModel, this);
// Should this be in Qt by default?
QAbstractItemView *popup = m_lineEditCompleter->popup();
QListView *listView = qobject_cast<QListView*>(popup);
if (listView)
listView->setUniformItemSizes(true);
}
lineEdit->setCompleter(m_lineEditCompleter);
connect(lineEdit, SIGNAL(returnPressed()), this, SLOT(lineEditReturnPressed()));
m_lineEdits->addWidget(urlLineEdit);
m_lineEdits->setSizePolicy(lineEdit->sizePolicy());
// optimization to delay creating the more expensive WebView, history, etc
if (count() == 0) {
QWidget *emptyWidget = new QWidget;
QPalette p = emptyWidget->palette();
p.setColor(QPalette::Window, palette().color(QPalette::Base));
emptyWidget->setPalette(p);
emptyWidget->setAutoFillBackground(true);
disconnect(this, SIGNAL(currentChanged(int)),
this, SLOT(currentChanged(int)));
addTab(emptyWidget, tr("(Untitled)"));
connect(this, SIGNAL(currentChanged(int)),
this, SLOT(currentChanged(int)));
return 0;
}
void
InsertPageCommand::execute()
{
KFormDesigner::Container *container = m_form->objectTree()->lookup(m_containername)->container();
QWidget *parent = m_form->objectTree()->lookup(m_parentname)->widget();
if (m_name.isEmpty()) {
m_name = container->form()->objectTree()->generateUniqueName(
container->form()->library()->displayName("QWidget").toLatin1(),
/*!numberSuffixRequired*/false);
}
QWidget *page = container->form()->library()->createWidget(
"QWidget", parent, m_name.toLatin1(), container);
page->setAutoFillBackground(true);
// page->setPaletteBackgroundColor(Qt::red);
KFormDesigner::ObjectTreeItem *item = container->form()->objectTree()->lookup(m_name);
QByteArray classname = parent->metaObject()->className();
if (classname == "KFDTabWidget") {
TabWidgetBase *tab = dynamic_cast<TabWidgetBase*>(parent);
QString n = i18n("Page %1", tab->count() + 1);
tab->addTab(page, n);
tab->setCurrentWidget(page);
item->addModifiedProperty("title", n);
} else if (classname == "QStackedWidget" || /* compat */ classname == "QWidgetStack") {
QStackedWidget *stack = dynamic_cast<QStackedWidget*>(parent);
stack->addWidget(page);
stack->setCurrentWidget(page);
item->addModifiedProperty("stackIndex", stack->indexOf(page));
}
}
void Fix8Log::aboutSlot()
{
QDialog *aboutDialog = new QDialog();
QVBoxLayout *aboutLayout = new QVBoxLayout(0);
QDialogButtonBox *dialogButtonBox = new QDialogButtonBox();
dialogButtonBox->addButton(QDialogButtonBox::Ok);
connect(dialogButtonBox,SIGNAL(clicked(QAbstractButton*)),
aboutDialog,SLOT(close()));
QQuickView *aboutView = new QQuickView(QUrl("qrc:qml/helpAbout.qml"));
QQuickItem *qmlObject = aboutView->rootObject();
qmlObject->setProperty("color",aboutDialog->palette().color(QPalette::Window));
qmlObject->setProperty("bgColor",aboutDialog->palette().color(QPalette::Window));
qmlObject->setProperty("version",QString::number(Globals::version));
aboutView->setResizeMode(QQuickView::SizeRootObjectToView);
QWidget *aboutWidget = QWidget::createWindowContainer(aboutView,0);
aboutWidget->setPalette(aboutDialog->palette());
aboutWidget->setAutoFillBackground(false);
aboutDialog->setLayout(aboutLayout);
aboutLayout->addWidget(aboutWidget,1);
aboutLayout->addWidget(dialogButtonBox,0);
aboutDialog->resize(500,400);
aboutDialog->setWindowTitle(GUI::Globals::appName);
aboutDialog->exec();
aboutDialog->deleteLater();
}
ContextView::ContextView( QWidget* parent, const QString& caption )
: QWidget( parent )
, m_trackView( new TrackView() )
, m_temporary( false )
{
TrackItemDelegate* del = new TrackItemDelegate( TrackItemDelegate::LovedTracks, m_trackView, m_trackView->proxyModel() );
m_trackView->setPlaylistItemDelegate( del );
m_trackView->proxyModel()->setStyle( PlayableProxyModel::SingleColumn );
m_trackView->setStyleSheet( QString( "QTreeView { background-color: %1; }" ).arg( TomahawkStyle::PAGE_BACKGROUND.name() ) );
#ifndef Q_OS_MAC
TomahawkStyle::styleScrollBar( m_trackView->verticalScrollBar() );
#endif
setLayout( new QVBoxLayout() );
TomahawkUtils::unmarginLayout( layout() );
m_captionLabel = new CaptionLabel( this );
setCaption( caption );
QWidget* vbox = new QWidget;
QPalette pal = vbox->palette();
pal.setBrush( vbox->backgroundRole(), TomahawkStyle::PAGE_BACKGROUND );
vbox->setPalette( pal );
vbox->setAutoFillBackground( true );
QVBoxLayout* vboxl = new QVBoxLayout();
TomahawkUtils::unmarginLayout( vboxl );
vboxl->setContentsMargins( 32, 32, 32, 32 );
vboxl->setSpacing( 32 );
vbox->setLayout( vboxl );
QWidget* hbox = new QWidget;
QHBoxLayout* hboxl = new QHBoxLayout();
TomahawkUtils::unmarginLayout( hboxl );
hboxl->setSpacing( 32 );
m_innerLayout = new QVBoxLayout();
TomahawkUtils::unmarginLayout( m_innerLayout );
m_innerLayout->addWidget( m_trackView, 1 );
m_innerLayout->addStretch();
m_detailView = new TrackDetailView;
m_detailView->setPlaylistInterface( playlistInterface() );
hboxl->addWidget( m_detailView );
hboxl->addLayout( m_innerLayout );
hbox->setLayout( hboxl );
vboxl->addWidget( m_captionLabel );
vboxl->addWidget( hbox );
layout()->addWidget( vbox );
connect( m_captionLabel, SIGNAL( clicked() ), SIGNAL( closeClicked() ) );
connect( m_trackView, SIGNAL( querySelected( Tomahawk::query_ptr ) ), SLOT( onQuerySelected( Tomahawk::query_ptr ) ) );
connect( m_trackView, SIGNAL( querySelected( Tomahawk::query_ptr ) ), m_detailView, SLOT( setQuery( Tomahawk::query_ptr ) ) );
connect( m_trackView, SIGNAL( modelChanged() ), SLOT( onModelChanged() ) );
TomahawkUtils::fixMargins( this );
}
int LuaMyWidget2::setAutoBackground(lua_State *L)
{
QWidget* obj = ObjectHelper<QWidget>::check( L, 1 );
bool b = true;
if( lua_gettop(L) > 1 && lua_isboolean( L, 2 ) )
b = lua_toboolean( L, 2 );
obj->setAutoFillBackground( b );
return 0;
}
MultiLayer::MultiLayer(ApplicationWindow* parent, int layers, int rows, int cols,
const QString& label, const char* name, Qt::WFlags f)
: MdiSubWindow(label, parent, name, f),
active_graph(NULL),
d_cols(cols),
d_rows(rows),
graph_width(500),
graph_height(400),
colsSpace(5),
rowsSpace(5),
left_margin(5),
right_margin(5),
top_margin(5),
bottom_margin(5),
l_canvas_width(400),
l_canvas_height(300),
hor_align(HCenter),
vert_align(VCenter),
d_scale_on_print(true),
d_print_cropmarks(false),
d_scale_layers(parent->autoResizeLayers)
{
layerButtonsBox = new QHBoxLayout();
QHBoxLayout *hbox = new QHBoxLayout();
hbox->addLayout(layerButtonsBox);
hbox->addStretch();
canvas = new QWidget();
QWidget *mainWidget = new QWidget();
mainWidget->setAutoFillBackground(true);
mainWidget->setBackgroundRole(QPalette::Window);
QVBoxLayout* layout = new QVBoxLayout(mainWidget);
layout->addLayout(hbox);
layout->addWidget(canvas, 1);
layout->setMargin(0);
layout->setSpacing(0);
setWidget(mainWidget);
int canvas_width = graph_width + left_margin + right_margin;
int canvas_height = graph_height + top_margin + bottom_margin;
setGeometry(QRect(0, 0, canvas_width, canvas_height + LayerButton::btnSize()));
canvas->resize(canvas_width, canvas_height);
canvas->installEventFilter(this);
QPalette pal = palette();
pal.setColor(QPalette::Window, QColor(Qt::white));
setPalette(pal);
for (int i = 0; i < layers; i++)
addLayer();
setFocusPolicy(Qt::StrongFocus);
setFocus();
}
void MainWindow::resizeEvent(QResizeEvent* event)
{
//call methode of parent class
QMainWindow::resizeEvent(event);
//calcluate position and size for given event.size()
int newHeight = event->size().height();
int newWidth = event->size().width();
double ratioSpeedWidget = this->speedWidget->heightForWidth(1); //just to get ratio
int newWidthSpeedWidget = (newHeight-20) / ratioSpeedWidget;
int newWidthTabWidgets = newWidth - newWidthSpeedWidget - 70;
//update ScaleInformation signleton
ScaleInformation::getInstance()->setMainWindowSize( event->size() );
//determine minimum width of ClickGenerator Widgets
int minimumWidthClickGeneratorWidgets = 0;
if(this->clickGeneratorDivisionWidget->getMinimumWidthForMainWindowHeight( newHeight ) > minimumWidthClickGeneratorWidgets )
minimumWidthClickGeneratorWidgets = this->clickGeneratorDivisionWidget->getMinimumWidthForMainWindowHeight( event->size().height() );
if(this->clickGeneratorXoYWidget->getMinimumWidthForMainWindowHeight( newHeight ) > minimumWidthClickGeneratorWidgets )
minimumWidthClickGeneratorWidgets = this->clickGeneratorXoYWidget->getMinimumWidthForMainWindowHeight( event->size().height() );
if(this->clickGeneratorPASWidget->getMinimumWidthForMainWindowHeight( newHeight ) > minimumWidthClickGeneratorWidgets )
minimumWidthClickGeneratorWidgets = this->clickGeneratorPASWidget->getMinimumWidthForMainWindowHeight( event->size().height() );
//determine minimumWidthForMainWindow
if(minimumWidthClickGeneratorWidgets > newWidthTabWidgets)
{
newWidth += minimumWidthClickGeneratorWidgets - newWidthTabWidgets;
newWidthTabWidgets = minimumWidthClickGeneratorWidgets;
this->resize(newWidth, newHeight);
}
//resize speedWidget
this->speedWidget->setGeometry(10, 20, newWidthSpeedWidget, newHeight-20);
this->theClickForm->speedGroupBox->setGeometry(newWidth-newWidthSpeedWidget-30, 0, newWidthSpeedWidget+20, newHeight-10);
//debug
QWidget* debugWidget = this->m_XToXAssociationWidget->leftScrollList;
QPalette pal = debugWidget->palette();
pal.setColor(QPalette::Background, Qt::blue);
debugWidget->setPalette(pal);
debugWidget->setBackgroundRole( QPalette::Background );
debugWidget->setAutoFillBackground(true);
debugWidget->repaint();
//resize ClickGenerators
this->clickGeneratorScrollListOfWidgets->setGeometry( QRect(10, 20, newWidthTabWidgets, newHeight-40) );
this->m_XToXAssociationWidget->setGeometry( QRect(10, 20, newWidthTabWidgets, newHeight-40) );
this->theClickForm->tabWidget->setGeometry(10, 0, newWidthTabWidgets+20, newHeight-10);
}
QWidget *PropertyEditorFactory::createEditor(QVariant::Type type, QWidget *parent) const
{
QWidget *w = QItemEditorFactory::createEditor(type, parent);
if (!w) {
return 0;
}
// the read-only view is still in the background usually, so transpareny is not a good choice here
w->setAutoFillBackground(true);
return w;
}
RubberBand::RubberBand(QWidget *parent)
: QMainWindow(parent)
{
QWidget *mainWidget = new QWidget;
mainWidget->setBackgroundRole(QPalette::Light);
mainWidget->setAutoFillBackground(true);
setCentralWidget(mainWidget);
resize(600,400);
setWindowTitle(tr("Rubberband"));
rubberBand = NULL;
}
void XyzWindow::CreateXYZView()
{
QFrame *XyFrame;
QFrame *XzFrame;
QFrame *ZyFrame;
QWidget *centralWidget;
centralWidget = new QWidget(this);
QPalette palette;
palette.setColor(QPalette::Background , QColor(/*200,200,200*/167, 210, 200));
centralWidget->setAutoFillBackground(true);
centralWidget->setPalette(palette);
XzFrame = new QFrame(centralWidget);
XzFrame->setGeometry(QRect(mXorigin1,mYorigin1 , mx+2*FRAM_BORDER , mz+2*FRAM_BORDER));
XzFrame->setFrameShape(QFrame::StyledPanel);
XzFrame->setFrameShadow(QFrame::Raised);
ZyFrame = new QFrame(centralWidget);
ZyFrame->setGeometry(QRect(mXorigin2 , mYorigin2 , mz+2*FRAM_BORDER ,my+2*FRAM_BORDER));
ZyFrame->setFrameShape(QFrame::StyledPanel);
ZyFrame->setFrameShadow(QFrame::Raised);
XyFrame = new QFrame(centralWidget);
XyFrame->setGeometry(QRect(mXorigin1 , mYorigin2 , mx+2*FRAM_BORDER ,my+2*FRAM_BORDER));
XyFrame->setFrameShape(QFrame::StyledPanel);
XyFrame->setFrameShadow(QFrame::Raised);
palette.setColor(QPalette::Background , QColor(255,0,0));
XzFrame->setAutoFillBackground(true);
XzFrame->setPalette(palette);
ZyFrame->setAutoFillBackground(true);
ZyFrame->setPalette(palette);
XyFrame->setAutoFillBackground(true);
XyFrame->setPalette(palette);
setCentralWidget(centralWidget);
QGLFormat glFormat;
glFormat.setRgba(true);
glFormat.setDoubleBuffer(true);
glFormat.setDepth(true);
mXY_GLw = new XyzGL(glFormat , XY_VIEW , XyFrame , this);
mXY_GLw->setGeometry(FRAM_BORDER , FRAM_BORDER,mx,my);
mXY_GLw->setAttribute(Qt::WA_DeleteOnClose);
mXZ_GLw = new XyzGL(glFormat , XZ_VIEW , XzFrame , this);
mXZ_GLw->setGeometry(FRAM_BORDER , FRAM_BORDER , mx ,mz);
mXZ_GLw->setAttribute(Qt::WA_DeleteOnClose);
mYZ_GLw = new XyzGL(glFormat , ZY_VIEW , ZyFrame , this);
mYZ_GLw->setGeometry(FRAM_BORDER , FRAM_BORDER ,mz ,my);
mYZ_GLw->setAttribute(Qt::WA_DeleteOnClose);
}
CalamaresWindow::CalamaresWindow( QWidget* parent )
: QWidget( parent )
{
// Hide close button
setWindowFlags( Qt::Window | Qt::WindowTitleHint | Qt::CustomizeWindowHint );
setMinimumSize( 1010, 560 );
QSize availableSize = qApp->desktop()->screenGeometry( this ).size();
int w = qBound( 1010, CalamaresUtils::defaultFontHeight() * 60, availableSize.width() );
int h = qBound( 560, CalamaresUtils::defaultFontHeight() * 36, availableSize.height() );
cDebug() << "Proposed window size:" << w << h;
resize( w, h );
QBoxLayout* mainLayout = new QHBoxLayout;
setLayout( mainLayout );
QWidget* sideBox = new QWidget( this );
mainLayout->addWidget( sideBox );
QBoxLayout* sideLayout = new QVBoxLayout;
sideBox->setLayout( sideLayout );
sideBox->setFixedWidth( qMax( 190, CalamaresUtils::defaultFontHeight() * 12 ) );
sideBox->setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
QHBoxLayout* logoLayout = new QHBoxLayout;
sideLayout->addLayout( logoLayout );
logoLayout->addStretch();
QLabel* logoLabel = new QLabel( "branding\ngoes\nhere", sideBox );
{
QPalette plt = sideBox->palette();
sideBox->setAutoFillBackground( true );
plt.setColor( sideBox->backgroundRole(), CalamaresStyle::SIDEBAR_BACKGROUND );
plt.setColor( sideBox->foregroundRole(), CalamaresStyle::SIDEBAR_TEXT );
sideBox->setPalette( plt );
logoLabel->setPalette( plt );
}
logoLabel->setAlignment( Qt::AlignCenter );
logoLabel->setFixedSize( 80, 80 );
logoLayout->addWidget( logoLabel );
logoLayout->addStretch();
ProgressTreeView* tv = new ProgressTreeView( sideBox );
sideLayout->addWidget( tv );
CalamaresUtils::unmarginLayout( sideLayout );
CalamaresUtils::unmarginLayout( mainLayout );
Calamares::ViewManager* vm = new Calamares::ViewManager( this );
mainLayout->addWidget( vm->centralWidget() );
}
QWidget* CTimelineWidget::NewColumn(bool a_bIsGame)
{
QWidget* pNewColumn = new QWidget(this);
QVBoxLayout* pVBLayout = new QVBoxLayout(pNewColumn);
pVBLayout->setSpacing(6);
pVBLayout->setContentsMargins(3, 3, 3, 3);
pNewColumn->setLayout(pVBLayout);
if (a_bIsGame)
{
QPalette Pal(palette());
Pal.setColor(QPalette::Background, QColor(255, 170, 0));
pNewColumn->setAutoFillBackground(true);
pNewColumn->setPalette(Pal);
}
else
{
QPalette Pal(palette());
Pal.setColor(QPalette::Background, QColor(240, 240, 240));
pNewColumn->setAutoFillBackground(true);
pNewColumn->setPalette(Pal);
}
return pNewColumn;
}
void MainWindow::buildLayout() {
this->topWidget = new AlwaysTopWidget();
this->layout = new QVBoxLayout();
this->layout->setMargin(0);
this->layout->setSpacing(0);
this->layout->insertWidget(0, this->topWidget);
QWidget *window = new QWidget(this);
window->setLayout(this->layout);
window->setFixedSize(size());
window->setAutoFillBackground(true);
window->show();
}
void MainWindow::initClient()
{
QWidget* client = new QWidget(this);
setCentralWidget(client);
client->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
QPalette pal = client->palette();
pal.setBrush(QPalette::Window, QBrush("#FFFFFF"));
client->setPalette(pal);
client->setAutoFillBackground(true);
QHBoxLayout* layout = new QHBoxLayout();
layout->setContentsMargins(0, 0, 0, 0);
client->setLayout(layout);
m_splitter = new CWizSplitter();
layout->addWidget(m_splitter);
QWidget* documentPanel = new QWidget();
QHBoxLayout* layoutDocument = new QHBoxLayout();
layoutDocument->setContentsMargins(0, 0, 0, 0);
layoutDocument->setSpacing(0);
documentPanel->setLayout(layoutDocument);
layoutDocument->addWidget(m_doc);
layoutDocument->addWidget(m_documentSelection);
m_documentSelection->hide();
// append after client
m_doc->layout()->addWidget(m_transitionView);
m_transitionView->hide();
m_splitter->addWidget(m_category);
QWidget* wlist = new QWidget(this);
QHBoxLayout* layoutList = new QHBoxLayout();
layoutList->setContentsMargins(0, 0, 0, 0);
layoutList->setSpacing(0);
layoutList->addWidget(createListView());
layoutList->addWidget(m_msgList);
wlist->setLayout(layoutList);
m_splitter->addWidget(wlist);
m_splitter->addWidget(documentPanel);
m_splitter->setStretchFactor(0, 0);
m_splitter->setStretchFactor(1, 0);
m_splitter->setStretchFactor(2, 1);
m_msgList->hide();
}
QWidget *PropTreeItemDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &/* option */, const QModelIndex &index) const
{
QWidget *edito = NULL;
PropTreeItem* item = (PropTreeItem*) m_parent->indexToItem(index);
if (!item)
return 0;
if (item->m_type == PropTreeItem::IntSpinBox)
{
ScrSpinBox *editor = new ScrSpinBox(parent, item->m_unit);
int val = index.model()->data(index, Qt::UserRole).toInt();
editor->setValues(item->m_min, item->m_max, 0, val);
edito = editor;
edito->setAutoFillBackground(true);
connect(editor, SIGNAL(valueChanged(double)), this, SLOT(valueHasChanged()));
connect(editor, SIGNAL(valueChanged(double)), item, SIGNAL(valueChanged(double)));
}
void Viewer::setupCanvas(const QSurfaceFormat & format)
{
m_canvas = new Canvas(format);
m_canvas->setContinuousRepaint(true, 0);
m_canvas->setSwapInterval(Canvas::VerticalSyncronization);
connect(m_canvas, &Canvas::fpsUpdate, this, &Viewer::fpsChanged);
connect(m_canvas, &Canvas::numCubesUpdate, this, &Viewer::numCubesChanged);
QWidget * widget = QWidget::createWindowContainer(m_canvas);
widget->setMinimumSize(1, 1);
widget->setAutoFillBackground(false); // Important for overdraw, not occluding the scene.
widget->setFocusPolicy(Qt::TabFocus);
setCentralWidget(widget);
show();
}
