void WWidgetGroup::setup(QDomNode node) {
setContentsMargins(0, 0, 0, 0);
// Set background pixmap if available
if (!WWidget::selectNode(node, "BackPath").isNull()) {
setPixmapBackground(WWidget::getPath(WWidget::selectNodeQString(node, "BackPath")));
}
QLayout* pLayout = NULL;
if (!XmlParse::selectNode(node, "Layout").isNull()) {
QString layout = XmlParse::selectNodeQString(node, "Layout");
if (layout == "vertical") {
pLayout = new QVBoxLayout();
pLayout->setSpacing(0);
pLayout->setContentsMargins(0, 0, 0, 0);
pLayout->setAlignment(Qt::AlignCenter);
} else if (layout == "horizontal") {
pLayout = new QHBoxLayout();
pLayout->setSpacing(0);
pLayout->setContentsMargins(0, 0, 0, 0);
pLayout->setAlignment(Qt::AlignCenter);
}
}
if (pLayout) {
setLayout(pLayout);
}
}
void SmoothToolTip::previewLayoutChanged(Applet::PreviewLayoutType previewLayout) {
QLayout *layout = m_widget->layout();
switch (previewLayout) {
case Applet::NewPreviewLayout:
layout->setSpacing(0);
break;
case Applet::ClassicPreviewLayout:
default:
layout->setSpacing(3);
}
layout->activate();
}
void SearchWidget::showEvent(QShowEvent *event)
{
if (!event->spontaneous() && !searchEngine) {
QVBoxLayout *vLayout = new QVBoxLayout(this);
vLayout->setMargin(0);
vLayout->setSpacing(0);
searchEngine = new QHelpSearchEngine(&LocalHelpManager::helpEngine(), this);
Utils::StyledBar *toolbar = new Utils::StyledBar(this);
toolbar->setSingleRow(false);
QHelpSearchQueryWidget *queryWidget = searchEngine->queryWidget();
QLayout *tbLayout = new QVBoxLayout();
tbLayout->setSpacing(6);
tbLayout->setMargin(4);
tbLayout->addWidget(queryWidget);
toolbar->setLayout(tbLayout);
Utils::StyledBar *toolbar2 = new Utils::StyledBar(this);
toolbar2->setSingleRow(false);
tbLayout = new QVBoxLayout();
tbLayout->setSpacing(0);
tbLayout->setMargin(0);
tbLayout->addWidget(resultWidget = searchEngine->resultWidget());
toolbar2->setLayout(tbLayout);
vLayout->addWidget(toolbar);
vLayout->addWidget(toolbar2);
setFocusProxy(queryWidget);
connect(queryWidget, SIGNAL(search()), this, SLOT(search()));
connect(resultWidget, &QHelpSearchResultWidget::requestShowLink, this,
[this](const QUrl &url) {
emit linkActivated(url, currentSearchTerms(), false/*newPage*/);
});
connect(searchEngine, SIGNAL(searchingStarted()), this,
SLOT(searchingStarted()));
connect(searchEngine, SIGNAL(searchingFinished(int)), this,
SLOT(searchingFinished(int)));
QTextBrowser* browser = resultWidget->findChild<QTextBrowser*>();
browser->viewport()->installEventFilter(this);
connect(searchEngine, SIGNAL(indexingStarted()), this,
SLOT(indexingStarted()));
connect(searchEngine, SIGNAL(indexingFinished()), this,
SLOT(indexingFinished()));
QMetaObject::invokeMethod(&LocalHelpManager::helpEngine(), "setupFinished",
Qt::QueuedConnection);
}
//---------------------------------------------------------------------------
PlotLegend::PlotLegend( QWidget *parent ):
QwtLegend( parent )
{
setMinimumHeight( 1 );
setMaxColumns( 1 );
setContentsMargins( 0, 0, 0, 0 );
QLayout* layout = contentsWidget()->layout();
layout->setAlignment( Qt::AlignLeft | Qt::AlignTop );
layout->setSpacing( 0 );
QScrollArea *scrollArea = findChild<QScrollArea *>();
if ( scrollArea )
{
scrollArea->setVerticalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
scrollArea->setHorizontalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
}
#if 1
QFont fnt = font();
if ( fnt.pointSize() > 8 )
{
fnt.setPointSize( 8 );
setFont( fnt );
}
#endif
}
ItemSelectorWidget::ItemSelectorWidget( QWidget* parent )
:StylableWidget(parent), m_clearText( false )
{
QLayout* layout = new FlowLayout( this, 0, 0, 0 );
layout->setContentsMargins( 0, 0, 0, 0 );
layout->setSpacing( 0 );
}
TilesetDock::TilesetDock(QWidget *parent):
QDockWidget(parent),
mMapDocument(0),
mDropDown(new QComboBox),
mViewStack(new QStackedWidget),
mCurrentTile(0),
mCurrentTiles(0)
{
setObjectName(QLatin1String("TilesetDock"));
QWidget *w = new QWidget(this);
QLayout *l = new QVBoxLayout(w);
l->setSpacing(0);
l->setMargin(0);
l->addWidget(mDropDown);
l->addWidget(mViewStack);
mDropDown->setEditable(false);
connect(mDropDown, SIGNAL(currentIndexChanged(int)),
mViewStack, SLOT(setCurrentIndex(int)));
connect(mViewStack, SIGNAL(currentChanged(int)),
this, SLOT(updateCurrentTiles()));
connect(TilesetManager::instance(), SIGNAL(tilesetChanged(Tileset*)),
this, SLOT(tilesetChanged(Tileset*)));
setWidget(w);
retranslateUi();
setAcceptDrops(true);
}
QtResourceView::QtResourceView(QDesignerFormEditorInterface *core, QWidget *parent) :
QWidget(parent),
d_ptr(new QtResourceViewPrivate(core))
{
d_ptr->q_ptr = this;
QIcon editIcon = QIcon::fromTheme("document-properties", qdesigner_internal::createIconSet(QLatin1String("edit.png")));
d_ptr->m_editResourcesAction = new QAction(editIcon, tr("Edit Resources..."), this);
d_ptr->m_toolBar->addAction(d_ptr->m_editResourcesAction);
connect(d_ptr->m_editResourcesAction, SIGNAL(triggered()), this, SLOT(slotEditResources()));
d_ptr->m_editResourcesAction->setEnabled(false);
QIcon refreshIcon = QIcon::fromTheme("view-refresh", qdesigner_internal::createIconSet(QLatin1String("reload.png")));
d_ptr->m_reloadResourcesAction = new QAction(refreshIcon, tr("Reload"), this);
d_ptr->m_toolBar->addAction(d_ptr->m_reloadResourcesAction);
connect(d_ptr->m_reloadResourcesAction, SIGNAL(triggered()), this, SLOT(slotReloadResources()));
d_ptr->m_reloadResourcesAction->setEnabled(false);
QIcon copyIcon = QIcon::fromTheme("edit-copy", qdesigner_internal::createIconSet(QLatin1String("editcopy.png")));
d_ptr->m_copyResourcePathAction = new QAction(copyIcon, tr("Copy Path"), this);
connect(d_ptr->m_copyResourcePathAction, SIGNAL(triggered()), this, SLOT(slotCopyResourcePath()));
d_ptr->m_copyResourcePathAction->setEnabled(false);
//d_ptr->m_filterWidget = new qdesigner_internal::FilterWidget(0, qdesigner_internal::FilterWidget::LayoutAlignNone);
d_ptr->m_filterWidget = new qdesigner_internal::FilterWidget(d_ptr->m_toolBar);
d_ptr->m_toolBar->addWidget(d_ptr->m_filterWidget);
connect(d_ptr->m_filterWidget, SIGNAL(filterChanged(QString)), this, SLOT(slotFilterChanged(QString)));
d_ptr->m_splitter = new QSplitter;
d_ptr->m_splitter->setChildrenCollapsible(false);
d_ptr->m_splitter->addWidget(d_ptr->m_treeWidget);
d_ptr->m_splitter->addWidget(d_ptr->m_listWidget);
QLayout *layout = new QVBoxLayout(this);
layout->setMargin(0);
layout->setSpacing(0);
layout->addWidget(d_ptr->m_toolBar);
layout->addWidget(d_ptr->m_splitter);
d_ptr->m_treeWidget->setColumnCount(1);
d_ptr->m_treeWidget->header()->hide();
d_ptr->m_treeWidget->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Expanding));
d_ptr->m_listWidget->setViewMode(QListView::IconMode);
d_ptr->m_listWidget->setResizeMode(QListView::Adjust);
d_ptr->m_listWidget->setIconSize(QSize(48, 48));
d_ptr->m_listWidget->setGridSize(QSize(64, 64));
connect(d_ptr->m_treeWidget, SIGNAL(currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)),
this, SLOT(slotCurrentPathChanged(QTreeWidgetItem*)));
connect(d_ptr->m_listWidget, SIGNAL(currentItemChanged(QListWidgetItem*,QListWidgetItem*)),
this, SLOT(slotCurrentResourceChanged(QListWidgetItem*)));
connect(d_ptr->m_listWidget, SIGNAL(itemActivated(QListWidgetItem*)),
this, SLOT(slotResourceActivated(QListWidgetItem*)));
d_ptr->m_listWidget->setContextMenuPolicy(Qt::CustomContextMenu);
connect(d_ptr->m_listWidget, SIGNAL(customContextMenuRequested(QPoint)),
this, SLOT(slotListWidgetContextMenuRequested(QPoint)));
}
IdentityFormWidget::IdentityFormWidget(Form::FormItem *formItem, QWidget *parent) :
Form::IFormWidget(formItem,parent),
m_ContainerLayout(0)
{
setObjectName("IdentityFormWidget");
// Create the central widget / layout
QGridLayout *mainLayout = new QGridLayout(this);
mainLayout->setSpacing(0);
mainLayout->setMargin(0);
// get options
const QStringList &options = formItem->getOptions();
m_Identity = new Identity::IdentityEditorWidget(this);
m_Identity->initialize();
Identity::IdentityEditorWidget::AvailableWidgets widgets = Identity::IdentityEditorWidget::FullIdentity;
if (options.contains("with-photo", Qt::CaseInsensitive))
widgets |= Identity::IdentityEditorWidget::Photo;
if (options.contains("with-address", Qt::CaseInsensitive))
widgets |= Identity::IdentityEditorWidget::FullAddress;
if (options.contains("with-login", Qt::CaseInsensitive))
widgets |= Identity::IdentityEditorWidget::FullLogin;
m_Identity->setAvailableWidgets(widgets);
if (options.contains("xml", Qt::CaseInsensitive))
m_Identity->setXmlInOut(true);
if (options.contains("readonly", Qt::CaseInsensitive))
m_Identity->setReadOnly(true);
// QtUi Loaded ?
const QString &layout = formItem->spec()->value(Form::FormItemSpec::Spec_UiInsertIntoLayout).toString();
if (!layout.isEmpty()) {
// Find layout
QLayout *lay = formItem->parentFormMain()->formWidget()->findChild<QLayout*>(layout);
if (lay) {
lay->addWidget(m_Identity);
lay->setMargin(0);
lay->setSpacing(0);
} else {
LOG_ERROR("Using the QtUiLinkage, layout not found in the ui: " + formItem->uuid());
}
} else {
mainLayout->addWidget(m_Identity, 1, 0);
}
if (options.contains("compact", Qt::CaseInsensitive)) {
m_Identity->layout()->setSpacing(0);
m_Identity->layout()->setMargin(0);
}
setFocusedWidget(m_Identity);
// create itemdata
IdentityWidgetData *data = new IdentityWidgetData(m_FormItem);
data->setIdentityFormWiget(this);
m_FormItem->setItemData(data);
}
Tab::Tab(QWidget *parent) : QWidget (parent) {
// Will contain chat window and list of online peers
outputSplitter = new QSplitter;
// Will split the outputSplitter from the input line
inputSplitter = new QSplitter;
inputSplitter->setOrientation(Qt::Vertical);
// Contains the top portion (output) and bottom (input)
QLayout *groupLayout = new QVBoxLayout;
// Chat input
chatInput = new QTextEdit;
chatInput->setMinimumHeight(20);
chatInput->setMaximumHeight(100);
chatInput->installEventFilter(this);
// Add chat viewer and chat input to main splitter
inputSplitter->addWidget(outputSplitter);
inputSplitter->addWidget(chatInput);
// Configure sizing for main vertical splitter
inputSplitter->setStretchFactor(0,99);
inputSplitter->setStretchFactor(1,1);
inputSplitter->setCollapsible(1,false);
// Populate chat container
QWidget *chatContainer = new QWidget;
QLayout *chatContainerLayout = new QVBoxLayout;
chat = new QTextBrowser;
chatContainerLayout->addWidget(new QLabel("Chat:"));
chatContainerLayout->addWidget(chat);
chatContainerLayout->setMargin(0);
chatContainerLayout->setSpacing(2);
chatContainer->setLayout(chatContainerLayout);
// Add chat viewer and online list to splitter
outputSplitter->addWidget(chatContainer);
groupLayout->addWidget(inputSplitter);
groupLayout->setMargin(10);
groupLayout->setSpacing(5);
setLayout(groupLayout);
this->setParent(parent);
}
void WWidgetGroup::setup(QDomNode node, const SkinContext& context) {
setContentsMargins(0, 0, 0, 0);
// Set background pixmap if available
if (context.hasNode(node, "BackPath")) {
setPixmapBackground(context.getSkinPath(context.selectString(node, "BackPath")));
}
QLayout* pLayout = NULL;
if (context.hasNode(node, "Layout")) {
QString layout = context.selectString(node, "Layout");
if (layout == "vertical") {
pLayout = new QVBoxLayout();
pLayout->setSpacing(0);
pLayout->setContentsMargins(0, 0, 0, 0);
pLayout->setAlignment(Qt::AlignCenter);
} else if (layout == "horizontal") {
pLayout = new QHBoxLayout();
pLayout->setSpacing(0);
pLayout->setContentsMargins(0, 0, 0, 0);
pLayout->setAlignment(Qt::AlignCenter);
}
}
if (pLayout && context.hasNode(node, "SizeConstraint")) {
QMap<QString, QLayout::SizeConstraint> constraints;
constraints["SetDefaultConstraint"] = QLayout::SetDefaultConstraint;
constraints["SetFixedSize"] = QLayout::SetFixedSize;
constraints["SetMinimumSize"] = QLayout::SetMinimumSize;
constraints["SetMaximumSize"] = QLayout::SetMaximumSize;
constraints["SetMinAndMaxSize"] = QLayout::SetMinAndMaxSize;
constraints["SetNoConstraint"] = QLayout::SetNoConstraint;
QString sizeConstraintStr = context.selectString(node, "SizeConstraint");
if (constraints.contains(sizeConstraintStr)) {
pLayout->setSizeConstraint(constraints[sizeConstraintStr]);
} else {
qDebug() << "Could not parse SizeConstraint:" << sizeConstraintStr;
}
}
if (pLayout) {
setLayout(pLayout);
}
}
// 设置 widget 的 padding 和 spacing
void UiUtil::setWidgetPaddingAndSpacing(QWidget *widget, int padding, int spacing) {
// 设置 Widget 的 padding 和 spacing
QLayout *layout = widget->layout();
if (nullptr != layout) {
layout->setContentsMargins(padding, padding, padding, padding);
layout->setSpacing(spacing);
}
}
void WWidgetGroup::setLayoutSpacing(int spacing) {
//qDebug() << "WWidgetGroup::setSpacing" << spacing;
if (spacing < 0) {
qDebug() << "WWidgetGroup: Invalid spacing:" << spacing;
return;
}
QLayout* pLayout = layout();
if (pLayout) {
pLayout->setSpacing(spacing);
}
}
DotPlotSplitter::DotPlotSplitter(AnnotatedDNAView* a)
: ADVSplitWidget(a),
locked(false)
{
syncLockAction = createAction(":core/images/sync_lock.png", tr("Multiple view synchronization lock"), SLOT(sl_toggleSyncLock(bool)));
filterAction = createAction(":dotplot/images/filter.png", tr("Filter results"), SLOT(sl_toggleFilter()), false);
zoomInAction = createAction(":core/images/zoom_in.png", tr("Zoom in (<b> + </b>)"), SLOT(sl_toggleZoomIn()), false);
zoomOutAction = createAction(":core/images/zoom_out.png", tr("Zoom out (<b> - </b>)"), SLOT(sl_toggleZoomOut()), false);
resetZoomingAction = createAction(":core/images/zoom_whole.png", tr("Reset zooming (<b>0</b>)"), SLOT(sl_toggleZoomReset()), false);
selAction = createAction(":dotplot/images/cursor.png", tr("Select tool (<b>S</b>)"), SLOT(sl_toggleSel()));
handAction = createAction(":dotplot/images/hand_icon.png", tr("Hand tool (<b>H</b>)"), SLOT(sl_toggleHand()));
splitter = new QSplitter(Qt::Horizontal);
WidgetWithLocalToolbar* wgt = new WidgetWithLocalToolbar(this);
QLayout* l = new QVBoxLayout();
l->setMargin(0);
l->setSpacing(0);
l->addWidget(splitter);
wgt->setContentLayout(l);
wgt->addActionToLocalToolbar(filterAction);
wgt->addActionToLocalToolbar(syncLockAction);
wgt->addActionToLocalToolbar(zoomInAction);
wgt->addActionToLocalToolbar(zoomOutAction);
wgt->addActionToLocalToolbar(resetZoomingAction);
wgt->addActionToLocalToolbar(selAction);
wgt->addActionToLocalToolbar(handAction);
QLayout* mainLayout = new QVBoxLayout();
mainLayout->setSpacing(0);
mainLayout->setMargin(0);
mainLayout->addWidget(wgt);
setLayout(mainLayout);
setAcceptDrops(false);
setFocus();
}
GraphEditorWidget::GraphEditorWidget(QWidget *parent)
: QWidget(parent)
, m_viewWidgets(new QTabWidget(this))
, m_project(0)
, m_editor(0)
{
QLayout *layout = new QVBoxLayout();
m_viewWidgets->setTabsClosable(false);
m_viewWidgets->setMovable(true);
layout->addWidget(m_viewWidgets);
layout->setSpacing(0);
setLayout(layout);
}
void BookmarkWidget::setup()
{
regExp.setPatternSyntax(QRegExp::FixedString);
regExp.setCaseSensitivity(Qt::CaseInsensitive);
QLayout *vlayout = new QVBoxLayout(this);
vlayout->setMargin(0);
vlayout->setSpacing(0);
searchField = new Utils::FancyLineEdit(this);
searchField->setFiltering(true);
setFocusProxy(searchField);
Utils::StyledBar *toolbar = new Utils::StyledBar(this);
toolbar->setSingleRow(false);
QLayout *tbLayout = new QHBoxLayout();
tbLayout->setMargin(4);
tbLayout->addWidget(searchField);
toolbar->setLayout(tbLayout);
vlayout->addWidget(toolbar);
searchField->installEventFilter(this);
connect(searchField, &Utils::FancyLineEdit::textChanged,
this, &BookmarkWidget::filterChanged);
treeView = new TreeView(this);
vlayout->addWidget(treeView);
filterBookmarkModel = new QSortFilterProxyModel(this);
treeView->setModel(filterBookmarkModel);
treeView->setDragEnabled(true);
treeView->setAcceptDrops(true);
treeView->setAutoExpandDelay(1000);
treeView->setDropIndicatorShown(true);
treeView->viewport()->installEventFilter(this);
treeView->setContextMenuPolicy(Qt::CustomContextMenu);
connect(treeView, &TreeView::expanded, this, &BookmarkWidget::expand);
connect(treeView, &TreeView::collapsed, this, &BookmarkWidget::expand);
connect(treeView, &TreeView::activated, this, &BookmarkWidget::activated);
connect(treeView, &TreeView::customContextMenuRequested,
this, &BookmarkWidget::customContextMenuRequested);
filterBookmarkModel->setFilterKeyColumn(0);
filterBookmarkModel->setDynamicSortFilter(true);
filterBookmarkModel->setSourceModel(bookmarkManager->treeBookmarkModel());
expandItems();
}
/*!
\internal
*/
QLayout *QFormBuilder::createLayout(const QString &layoutName, QObject *parent, const QString &name)
{
QLayout *l = 0;
QWidget *parentWidget = qobject_cast<QWidget*>(parent);
QLayout *parentLayout = qobject_cast<QLayout*>(parent);
Q_ASSERT(parentWidget || parentLayout);
#define DECLARE_WIDGET(W, C)
#define DECLARE_COMPAT_WIDGET(W, C)
#define DECLARE_LAYOUT(L, C) \
if (layoutName == QLatin1String(#L)) { \
Q_ASSERT(l == 0); \
l = parentLayout \
? new L() \
: new L(parentWidget); \
}
#include "widgets.table"
#undef DECLARE_LAYOUT
#undef DECLARE_COMPAT_WIDGET
#undef DECLARE_WIDGET
if (l) {
l->setObjectName(name);
if (parentLayout) {
QWidget *w = qobject_cast<QWidget *>(parentLayout->parent());
if (w && w->inherits("Q3GroupBox")) {
l->setContentsMargins(w->style()->pixelMetric(QStyle::PM_LayoutLeftMargin),
w->style()->pixelMetric(QStyle::PM_LayoutTopMargin),
w->style()->pixelMetric(QStyle::PM_LayoutRightMargin),
w->style()->pixelMetric(QStyle::PM_LayoutBottomMargin));
QGridLayout *grid = qobject_cast<QGridLayout *>(l);
if (grid) {
grid->setHorizontalSpacing(-1);
grid->setVerticalSpacing(-1);
} else {
l->setSpacing(-1);
}
l->setAlignment(Qt::AlignTop);
}
}
} else {
qWarning() << QCoreApplication::translate("QFormBuilder", "The layout type `%1' is not supported.").arg(layoutName);
}
return l;
}
void StorageInfoView::init()
{
sinfo = QStorageMetaInfo::instance();
QLayout *layout = new QVBoxLayout( this );
layout->setSpacing( 0 );
layout->setMargin( 0 );
area = new QScrollArea;
layout->addWidget( area );
area->setFocusPolicy( Qt::TabFocus );
area->setFrameShape( QFrame::NoFrame );
updateMounts();
connect(sinfo, SIGNAL(disksChanged()), this, SLOT(updateMounts()));
startTimer(60000);
}
IndexWindow::IndexWindow()
: m_searchLineEdit(0)
, m_indexWidget(0)
{
QVBoxLayout *layout = new QVBoxLayout(this);
m_searchLineEdit = new Utils::FilterLineEdit();
m_searchLineEdit->setPlaceholderText(QString());
setFocusProxy(m_searchLineEdit);
connect(m_searchLineEdit, SIGNAL(textChanged(QString)), this,
SLOT(filterIndices(QString)));
m_searchLineEdit->installEventFilter(this);
QLabel *l = new QLabel(tr("&Look for:"));
l->setBuddy(m_searchLineEdit);
layout->addWidget(l);
layout->setMargin(0);
layout->setSpacing(0);
Utils::StyledBar *toolbar = new Utils::StyledBar(this);
toolbar->setSingleRow(false);
QLayout *tbLayout = new QHBoxLayout();
tbLayout->setSpacing(6);
tbLayout->setMargin(4);
tbLayout->addWidget(l);
tbLayout->addWidget(m_searchLineEdit);
toolbar->setLayout(tbLayout);
layout->addWidget(toolbar);
QHelpEngine *engine = &LocalHelpManager::helpEngine();
m_indexWidget = engine->indexWidget();
m_indexWidget->installEventFilter(this);
connect(engine->indexModel(), SIGNAL(indexCreationStarted()), this,
SLOT(disableSearchLineEdit()));
connect(engine->indexModel(), SIGNAL(indexCreated()), this,
SLOT(enableSearchLineEdit()));
connect(m_indexWidget, SIGNAL(linkActivated(QUrl,QString)), this,
SIGNAL(linkActivated(QUrl)));
connect(m_indexWidget, SIGNAL(linksActivated(QMap<QString,QUrl>,QString)),
this, SIGNAL(linksActivated(QMap<QString,QUrl>,QString)));
connect(m_searchLineEdit, SIGNAL(returnPressed()), m_indexWidget,
SLOT(activateCurrentItem()));
m_indexWidget->setFrameStyle(QFrame::NoFrame);
layout->addWidget(m_indexWidget);
m_indexWidget->viewport()->installEventFilter(this);
}
void FieldGUIController::makeCellHoverSensitiveAndClicable(unsigned row, unsigned coll, const QString &hover_color)
{
QWidget *cell = getCell(row,coll);
QLayout* layout = new QBoxLayout(QBoxLayout::LeftToRight,cell);
layout->setSpacing(0);
layout->setMargin(0);
QWidgetWithPosClicked*hover_and_click = new QWidgetWithPosClicked(cell);
//game cells numeration from 0 but in greedlayout from 1
hover_and_click->setPosOnField(row-1,coll-1);
QObject::connect(hover_and_click,SIGNAL(clicked(uint,uint,Qt::MouseButton)),this,SLOT(clickCell(uint,uint,Qt::MouseButton)));
QString style = "*{border-image: none; border: none; margin: 4px;} *:hover {border: 3px solid "+hover_color+";}";
hover_and_click->setStyleSheet(style);
layout->addWidget(hover_and_click);
cell->setLayout(layout);
}
SubTableWidget::SubTableWidget(QWidget *parent) :
QWidget(parent),
ui(new Ui::SubTableWidget)
{
ui->setupUi(this);
statusbar = new QStatusBar(this);
movable = true;
ui->label-> setVisible (true);
ui->toolsframe->setVisible (true);
ui->tableView-> setFocusPolicy(Qt::NoFocus);
QLayout* layoutWidget = ui->gridLayout_2;
layoutWidget->setContentsMargins(0,0,0,0);
layoutWidget->setSpacing(0);
layoutWidget->addWidget(statusbar);
}
ConsoleOutput::ConsoleOutput(QWidget* parent)
: QWidget(0/* cannot have parent because it will becode topmost*/, Qt::Dialog)
, m_parent(parent)
{
setWindowTitle(tr("Console Output"));
m_tabs = new QTabWidget(this);
QLayout* layout = new QVBoxLayout();
layout->addWidget(m_tabs);
layout->setContentsMargins(DEFAULT_MARGINS);
layout->setSpacing(DEFAULT_SPACING);
setLayout(layout);
if (m_parent)
{
move(m_parent->x(), m_parent->frameGeometry().top());
}
}
void MetaDataBase::setSpacing( QObject *o, int spacing )
{
if ( !o )
return;
setupDataBase();
MetaDataBaseRecord *r = db->find( (void*)o );
if ( !r || !o->isWidgetType() ) {
qWarning( "No entry for %p (%s, %s) found in MetaDataBase",
o, o->name(), o->className() );
return;
}
r->spacing = spacing;
QLayout * layout = 0;
WidgetFactory::layoutType( (QWidget*)o, layout );
if ( layout )
layout->setSpacing( spacing );
}
TCollapsibleWidget* KSettingsContainer::insertWidget(QWidget *w, const QString& name)
{
if (w && w->layout()) {
QLayout *lay = w->layout();
lay->setMargin(2);
lay->setSpacing(0);
}
TCollapsibleWidget *cw = new TCollapsibleWidget(name);
k->layout->addWidget(cw);
cw->setInnerWidget(w);
k->collapsibles << cw;
cw->show();
return cw;
}
int drv_layout(int drvid, void *a0, void* a1, void* a2, void* a3, void* a4, void* a5, void* a6, void* a7, void* a8, void* a9)
{
handle_head* head = (handle_head*)a0;
QLayout *self = (QLayout*)head->native;
switch (drvid) {
case LAYOUT_ADDLAYOUT: {
self->addItem(drvGetLayout(a1));
break;
}
case LAYOUT_ADDWIDGET: {
self->addWidget(drvGetWidget(a1));
break;
}
case LAYOUT_SETSPACING: {
self->setSpacing(drvGetInt(a1));
break;
}
case LAYOUT_SPACING: {
drvSetInt(a1,self->spacing());
break;
}
case LAYOUT_SETMARGINS: {
self->setContentsMargins(drvGetMargins(a1));
break;
}
case LAYOUT_MARGINS: {
drvSetMargins(a1,self->contentsMargins());
break;
}
case LAYOUT_SETMENUBAR: {
self->setMenuBar(drvGetWidget(a1));
break;
}
case LAYOUT_MENUBAR: {
drvSetHandle(a1,self->menuBar());
break;
}
default:
return 0;
}
return 1;
}
FormPage::FormPage(FPage* fPage, QWidget* parent, ViewPage::ViewMode viewMode) :
QWidget(parent)
{
Q_ASSERT(fPage);
m_fPage = fPage;
m_viewPage = new ViewPage(this, fPage, viewMode);
QLayout* layout = NULL;
if (viewMode == ViewPage::Design)
{
QGridLayout* gridLayout = new QGridLayout(this);
gridLayout->setSizeConstraint(QLayout::SetMinimumSize);
layout = gridLayout;
QLabel* label = new QLabel(this);
label->setText("*");
gridLayout->addWidget(label, 0, 0);
Rule* hRule = new Rule(Qt::Horizontal, this);
gridLayout->addWidget(hRule, 0, 1);
Rule* vRule = new Rule(Qt::Vertical, this);
gridLayout->addWidget(vRule, 1, 0);
m_viewPage->setRules(hRule, vRule);
gridLayout->addWidget(m_viewPage, 1, 1);
}
else
{
layout = new QVBoxLayout(this);
layout->addWidget(m_viewPage);
}
layout->setSpacing(0);
layout->setMargin(0);
setLayout(layout);
}
/**
* @brief
* Updates the transfer function
*/
void DockWidgetVolumeTransferFunction::UpdateObject(PLCore::Object *pObject)
{
// Destroy previous transfer function Qt widget
if (m_pTransferFunctionWidget) {
delete m_pTransferFunctionWidget;
m_pTransferFunctionWidget = nullptr;
}
if (m_pTransferFunctionResultWidget) {
delete m_pTransferFunctionResultWidget;
m_pTransferFunctionResultWidget = nullptr;
}
// Is there an selected object?
if (pObject) {
// Get encapsulated Qt dock widget
QDockWidget *pQDockWidget = GetQDockWidget();
if (pQDockWidget) {
// Get the used volume resource
PLVolume::Volume *pVolume = static_cast<PLVolume::SNVolume&>(*pObject).GetVolume(); // If we're in here, we know the cast is valid
if (pVolume) {
// Transfer function result widget
m_pTransferFunctionResultWidget = new QLabel();
m_pTransferFunctionResultWidget->setAlignment(Qt::AlignTop | Qt::AlignLeft);
m_pTransferFunctionResultWidget->setToolTip(pQDockWidget->tr("Resulting 1D transfer function"));
// Create transfer function Qt widget
m_pTransferFunctionWidget = new TransferFunctionWidget(*this, *pVolume);
QLayout *pQLayout = new QVBoxLayout();
pQLayout->setSpacing(0);
pQLayout->setMargin(0);
pQLayout->setContentsMargins(0, 0, 0, 0);
pQLayout->addWidget(m_pTransferFunctionWidget);
pQLayout->addWidget(m_pTransferFunctionResultWidget);
QWidget *pQWidget = new QWidget();
pQWidget->setLayout(pQLayout);
pQDockWidget->setWidget(pQWidget);
}
}
}
}
TilesetDock::TilesetDock(QWidget *parent):
QDockWidget(parent),
mMapDocument(0),
mTabBar(new QTabBar),
mViewStack(new QStackedWidget),
mCurrentTile(0),
mCurrentTiles(0)
{
setObjectName(QLatin1String("TilesetDock"));
QWidget *w = new QWidget(this);
QLayout *l = new QVBoxLayout(w);
l->setSpacing(0);
l->setMargin(0);
l->addWidget(mTabBar);
l->addWidget(mViewStack);
mTabBar->setTabsClosable(true);
mTabBar->setMovable(true);
mTabBar->setUsesScrollButtons(true);
connect(mTabBar, SIGNAL(currentChanged(int)),
mViewStack, SLOT(setCurrentIndex(int)));
connect(mTabBar, SIGNAL(tabCloseRequested(int)),
this, SLOT(removeTileset(int)));
connect(mTabBar, SIGNAL(tabMoved(int,int)),
this, SLOT(moveTileset(int,int)));
connect(mViewStack, SIGNAL(currentChanged(int)),
this, SLOT(updateCurrentTiles()));
connect(TilesetManager::instance(), SIGNAL(tilesetChanged(Tileset*)),
this, SLOT(tilesetChanged(Tileset*)));
setWidget(w);
retranslateUi();
setAcceptDrops(true);
}
GroupTab::GroupTab(QWidget *parent) : Tab(parent){
// Populate online list container
QWidget *onlineContainer = new QWidget;
QLayout *onlineContainerLayout = new QVBoxLayout();
online = new QListWidget;
online->setSortingEnabled(true);
onlineContainer->setMinimumWidth(50);
onlineContainer->setMaximumWidth(175);
onlineContainerLayout->addWidget(new QLabel("Online:"));
onlineContainerLayout->addWidget(online);
onlineContainerLayout->setMargin(0);
onlineContainerLayout->setSpacing(2);
onlineContainer->setLayout(onlineContainerLayout);
// Enable double clicking on list items to message peer
connect(online,SIGNAL(itemDoubleClicked(QListWidgetItem*)),parent,SLOT(startPeerChat(QListWidgetItem*)));
outputSplitter->addWidget(onlineContainer);
outputSplitter->setStretchFactor(0,7);
outputSplitter->setStretchFactor(1,3);
// Set base hue
hueSeed = 0;
}
void PieceAppearanceWidget::setupUI()
{
QLayout * lay = new QGridLayout( this );
lay->setSpacing(0);
lay->setContentsMargins(0,0,0,0);
QGraphicsView * v = this->impl->gv =
//new QGraphicsView( impl->gs.scene() )
new QBoardView( impl->gs )
;
v->setTransformationAnchor(QGraphicsView::NoAnchor);
#if 0
v->setAlignment(Qt::AlignLeft | Qt::AlignTop);
v->setInteractive(true); // required to get mouse events to the children
v->setHorizontalScrollBarPolicy( Qt::ScrollBarAsNeeded );
v->setVerticalScrollBarPolicy( Qt::ScrollBarAsNeeded );
v->setDragMode(QGraphicsView::RubberBandDrag);
v->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
#endif
v->setBackgroundBrush(QColor("#abb8fb"));
v->viewport()->setObjectName( "PieceAppearanceWidget");
lay->addWidget( v );
QStringList tip;
tip << "<html><body>These widgets are appearance templates for game pieces.\n"
<< "Edit them by right-clicking them.\n"
<< "Select a template by left-clicking it. "
<< "QBoard will use the selected template as the default look\n"
<< "for newly-added pieces which are loaded from image files.\n"
<< "This list will be saved automatically when QBoard exits,\n"
<< "and loaded when QBoard starts up.</body></html>"
;
impl->gv->setToolTip( tip.join("") );
}
MainWindowImpl::MainWindowImpl( QWidget * parent, Qt::WFlags f)
: QMainWindow(parent, f),
Ui::MainWindow(),
impl(new Impl)
{
setupUi(this);
this->setWindowTitle( QString("QBoard v. %1").arg(qboard::versionString()) );
connect( this->actionSave, SIGNAL(triggered(bool)), this, SLOT(saveGame()) );
connect( this->actionLoad, SIGNAL(triggered(bool)), this, SLOT(loadGame()) );
connect( this->actionNewBoardView, SIGNAL(triggered(bool)), this, SLOT(launchNewBoardView()) );
connect( this->actionAboutQt, SIGNAL(triggered(bool)), qApp, SLOT(aboutQt()) );
connect( this->actionAboutQBoard, SIGNAL(triggered(bool)), this, SLOT(aboutQBoard()) );
connect( this->actionPrint, SIGNAL(triggered(bool)), this, SLOT(printGame()) );
connect( this->actionHelp, SIGNAL(triggered(bool)), this, SLOT(launchHelp()) );
connect( this->actionClearBoard, SIGNAL(triggered(bool)), this, SLOT(clearBoard()) );
connect( this->actionQuickSave, SIGNAL(triggered(bool)), this, SLOT(quickSave()) );
connect( this->actionQuickLoad, SIGNAL(triggered(bool)), this, SLOT(quickLoad()) );
impl->gstate.enablePlacemarker(true);
#if ! QBOARD_VERSION
// For "end user builds" we won't show this action.
connect( this->actionExperiment, SIGNAL(triggered(bool)), this, SLOT(doSomethingExperimental()) );
this->actionExperiment->setEnabled(true);
#else
this->actionExperiment->setEnabled(false);
#endif
connect( &S11nClipboard::instance(), SIGNAL(signalUpdated()), this, SLOT(clipboardUpdated()) );
this->actionClearClipboard->setEnabled( 0 != S11nClipboard::instance().contents() );
connect( this->actionClearClipboard, SIGNAL(triggered(bool)), this, SLOT( clearClipboard() ) );
QWidget * cli = this->clientArea;
QLayout * lay = new QGridLayout( cli );
lay->setSpacing(0);
lay->setContentsMargins(2,2,2,2);
QSplitter * splitter = new QSplitter( Qt::Horizontal, cli );
lay->addWidget( splitter );
splitter->setHandleWidth(4);
QSplitter * vsplit = new QSplitter( Qt::Vertical, cli );
impl->sidebar = vsplit;
splitter->addWidget( vsplit );
vsplit->setHandleWidth(4);
impl->tree = new QBoardHomeView();
vsplit->addWidget(impl->tree);
connect( this->actionRefreshFileList, SIGNAL(triggered(bool)), impl->tree, SLOT(refresh()) );
connect( impl->tree, SIGNAL(itemActivated(QFileInfo const &)), this, SLOT(loadFile(QFileInfo const &)) );
connect( this->actionToggleBrowserView, SIGNAL(toggled(bool)), this, SLOT(toggleSidebarVisible(bool)) );
impl->gv = new QBoardView( impl->gstate );
//impl->gv->enablePlacemarker(true);
connect( this->actionToggleBoardDragMode, SIGNAL(toggled(bool)),
impl->gv, SLOT(setHandDragMode(bool)) );
this->actionToggleBoardDragMode->setChecked(false);
connect( this->actionCopy, SIGNAL(triggered(bool)), impl->gv, SLOT(clipCopySelected()) );
connect( this->actionCut, SIGNAL(triggered(bool)), impl->gv, SLOT(clipCutSelected()) );
connect( this->actionPaste, SIGNAL(triggered(bool)), impl->gv, SLOT(clipPaste()) );
connect( this->actionSelectAll, SIGNAL(triggered(bool)), impl->gv, SLOT(selectAll()) );
connect( this->actionZoomIn, SIGNAL(triggered(bool)), impl->gv, SLOT(zoomIn()) );
connect( this->actionZoomOut, SIGNAL(triggered(bool)), impl->gv, SLOT(zoomOut()) );
connect( this->actionZoomReset, SIGNAL(triggered(bool)), impl->gv, SLOT(zoomReset()) );
#define BOGO(A)
// this->action ## A->setParent(impl->gv);
BOGO(Copy);
BOGO(Cut);
BOGO(Paste);
BOGO(ZoomIn);
BOGO(ZoomOut);
BOGO(ZoomReset);
#undef BOGO
splitter->addWidget( impl->gv );
splitter->setStretchFactor(0,2);
splitter->setStretchFactor(1,3);
vsplit->addWidget( impl->paw );
vsplit->setStretchFactor(0,3);
vsplit->setStretchFactor(1,1);
if(1)
{
impl->gv->setObjectName("view");
QScriptEngine & js( impl->gstate.jsEngine() );
QScriptValue jo = js.newQObject( impl->gv, QScriptEngine::QtOwnership );
QScriptValue qb = js.globalObject().property("qboard");
qb.setProperty("view",jo);
qb.setProperty("window",js.newQObject(this, QScriptEngine::QtOwnership ) );
}
this->resize(760,600);
}
