void DialogEditSIMDRegister::set_value(const Register& newReg)
{
resetLayout();
assert(newReg.bitSize()<=8*sizeof value_);
reg=newReg;
util::markMemory(&value_,value_.size());
if(QRegExp("mm[0-7]").exactMatch(reg.name()))
{
const auto value=reg.value<edb::value64>();
std::memcpy(&value_,&value,sizeof value);
hideColumns(MMX_FIRST_COL);
// MMX registers are never used in float computations, so hide useless rows
hideRows(FLOATS32_ROW);
hideRows(FLOATS64_ROW);
}
else if(QRegExp("xmm[0-9]+").exactMatch(reg.name()))
{
const auto value=reg.value<edb::value128>();
std::memcpy(&value_,&value,sizeof value);
hideColumns(XMM_FIRST_COL);
}
else if(QRegExp("ymm[0-9]+").exactMatch(reg.name()))
{
const auto value=reg.value<edb::value256>();
std::memcpy(&value_,&value,sizeof value);
hideColumns(YMM_FIRST_COL);
}
else qCritical() << "DialogEditSIMDRegister::set_value(" << reg.name() << "): register type unsupported";
setWindowTitle(tr("Modify %1").arg(reg.name().toUpper()));
updateAllEntriesExcept(nullptr);
}
AppletHandle::AppletHandle(AppletContainer* parent)
: QWidget(parent),
m_applet(parent),
m_menuButton(0),
m_drawHandle(false),
m_popupDirection(KPanelApplet::Up),
m_handleHoverTimer(0)
{
setBackgroundOrigin(AncestorOrigin);
setMinimumSize(widthForHeight(0), heightForWidth(0));
m_layout = new QBoxLayout(this, QBoxLayout::BottomToTop, 0, 0);
m_dragBar = new AppletHandleDrag(this);
m_dragBar->installEventFilter(this);
m_layout->addWidget(m_dragBar);
if (kapp->authorizeKAction("kicker_rmb"))
{
m_menuButton = new AppletHandleButton( this );
m_menuButton->setPixmap(xpmPixmap(up_xpm, "up"));
m_menuButton->installEventFilter(this);
m_layout->addWidget(m_menuButton);
connect(m_menuButton, SIGNAL(pressed()),
this, SLOT(menuButtonPressed()));
QToolTip::add(m_menuButton, i18n("%1 menu").arg(parent->info().name()));
}
QToolTip::add(this, i18n("%1 applet handle").arg(parent->info().name()));
resetLayout();
}
MagicMenuItem::MagicMenuItem()
{
int itemSize = 55;
setRect( -itemSize/2, -itemSize/2, itemSize, itemSize );
setBrush( QColor( 230,229,229 ) );
QPen pen;
pen.setBrush( Qt::NoBrush );
setPen( pen );
QGraphicsTextItem *textItem = new QGraphicsTextItem( i18n("Magic"), this );
int textWidth = textItem->boundingRect().width();
int textHeight = textItem->boundingRect().height();
textItem->setPos( - textWidth / 2, - textHeight / 2 );
m_fanMenu = new FanMenu( this );
m_fanMenu->setZValue( 50 );
m_fanMenu->hide();
m_fanMenu->setStartAngle( 80 );
m_fanMenu->setEndAngle( 280 );
FanMenuItem *menuItem = m_fanMenu->addItem( i18n("Reset\nlayout") );
connect( menuItem, SIGNAL( clicked() ), SIGNAL( resetLayout() ) );
menuItem = m_fanMenu->addItem( i18n("Settings") );
connect( menuItem, SIGNAL( clicked() ), SIGNAL( showSettings() ) );
m_fanMenu->setupItems( 80 );
setAcceptHoverEvents( true );
}
void KScrollBar::setSliderMinimumHeight( qreal height )
{
if(m_sliderMinimumHeight == height)
return;
m_sliderMinimumHeight = height;
resetLayout();
}
void KCommonDecoration::reset( unsigned long changed )
{
if (changed & SettingButtons) {
resetLayout();
widget()->update();
}
}
void KScrollBar::setButtonHeight( qreal height )
{
if(m_buttonHeight == height)
return;
m_buttonHeight = height;
resetLayout();
}
void Manager::init()
{
createMainWidget(WNoAutoErase);
widget()->installEventFilter(this);
widget()->setBackgroundMode(NoBackground);
leftButtonList_.setAutoDelete(true);
rightButtonList_.setAutoDelete(true);
resetLayout();
}
void AppletHandle::checkHandleHover()
{
if (!m_handleHoverTimer ||
(m_menuButton && m_menuButton->isOn()) ||
m_applet->geometry().contains(m_applet->mapToParent(
m_applet->mapFromGlobal(QCursor::pos()))))
{
return;
}
m_handleHoverTimer->stop();
m_drawHandle = false;
resetLayout();
}
void KCommonDecoration::init()
{
createMainWidget(WNoAutoErase);
// for flicker-free redraws
widget()->setBackgroundMode(NoBackground);
widget()->installEventFilter( this );
resetLayout();
connect(this, SIGNAL(keepAboveChanged(bool) ), SLOT(keepAboveChange(bool) ) );
connect(this, SIGNAL(keepBelowChanged(bool) ), SLOT(keepBelowChange(bool) ) );
updateCaption();
}
/* ------------------------------------------------------------------ */
int initLayout(int level) {
int i;
for (i=0; i<nMenu; i++) { /* init the menu*/
guiMenu[i].x = OFFX + (MX+GAPX)*i;
guiMenu[i].y = MYZERO;
}
strcpy(guiMenu[0].name, " New Game ");
strcpy(guiMenu[1].name, " Restart ");
strcpy(guiMenu[2].name, " Backward ");
strcpy(guiMenu[3].name, " Forward ");
strcpy(guiMenu[4].name, " Strategy ");
strcpy(guiMenu[5].name, " Play ");
strcpy(guiMenu[6].name, " Quit ");
strcpy(guiMenu[7].name, " Save ");
guiCountLabel.x = OFFX + (MX+GAPX)*i; /* init the count label*/
guiCountLabel.y = MYZERO+10;
resetLayout();
return (0);
}
void AppletHandle::setFadeOutHandle(bool fadeOut)
{
if (fadeOut)
{
if (!m_handleHoverTimer)
{
m_handleHoverTimer = new QTimer(this);
connect(m_handleHoverTimer, SIGNAL(timeout()),
this, SLOT(checkHandleHover()));
m_applet->installEventFilter(this);
}
}
else
{
delete m_handleHoverTimer;
m_handleHoverTimer = 0;
m_applet->removeEventFilter(this);
}
resetLayout();
}
bool AppletHandle::eventFilter(QObject *o, QEvent *e)
{
if (o == parent())
{
switch (e->type())
{
case QEvent::Enter:
{
m_drawHandle = true;
resetLayout();
if (m_handleHoverTimer)
{
m_handleHoverTimer->start(250);
}
break;
}
case QEvent::Leave:
{
if (m_menuButton && m_menuButton->isOn())
{
break;
}
QWidget* w = dynamic_cast<QWidget*>(o);
bool nowDrawIt = false;
if (w)
{
// a hack for applets that have out-of-process
// elements (e.g the systray) so that the handle
// doesn't flicker when moving over those elements
if (w->rect().contains(w->mapFromGlobal(QCursor::pos())))
{
nowDrawIt = true;
}
}
if (nowDrawIt != m_drawHandle)
{
if (m_handleHoverTimer)
{
m_handleHoverTimer->stop();
}
m_drawHandle = nowDrawIt;
resetLayout();
}
break;
}
default:
break;
}
return QWidget::eventFilter( o, e );
}
else if (o == m_dragBar)
{
if (e->type() == QEvent::MouseButtonPress)
{
QMouseEvent* ev = static_cast<QMouseEvent*>(e);
if (ev->button() == LeftButton || ev->button() == MidButton)
{
emit moveApplet(m_applet->mapFromGlobal(ev->globalPos()));
}
}
}
if (m_menuButton && e->type() == QEvent::MouseButtonPress)
{
QMouseEvent* ev = static_cast<QMouseEvent*>(e);
if (ev->button() == RightButton)
{
if (!m_menuButton->isDown())
{
m_menuButton->setDown(true);
menuButtonPressed();
}
return true;
}
}
return QWidget::eventFilter(o, e); // standard event processing
}
void ArtsControlApplet::positionChange( Position ) {
kdDebug() << k_funcinfo << endl;
resetLayout();
}
DialogEditSIMDRegister::DialogEditSIMDRegister(QWidget* parent)
: QDialog(parent),
byteHexValidator (new QRegExpValidator(QRegExp("[0-9a-fA-F]{0,2}"),this)),
wordHexValidator (new QRegExpValidator(QRegExp("[0-9a-fA-F]{0,4}"),this)),
dwordHexValidator(new QRegExpValidator(QRegExp("[0-9a-fA-F]{0,8}"),this)),
qwordHexValidator(new QRegExpValidator(QRegExp("[0-9a-fA-F]{0,16}"),this)),
byteSignedValidator (new QLongValidator(INT8_MIN,INT8_MAX,this)),
wordSignedValidator (new QLongValidator(INT16_MIN,INT16_MAX,this)),
dwordSignedValidator(new QLongValidator(INT32_MIN,INT32_MAX,this)),
qwordSignedValidator(new QLongValidator(INT64_MIN,INT64_MAX,this)),
byteUnsignedValidator (new QULongValidator(0,UINT8_MAX,this)),
wordUnsignedValidator (new QULongValidator(0,UINT16_MAX,this)),
dwordUnsignedValidator(new QULongValidator(0,UINT32_MAX,this)),
qwordUnsignedValidator(new QULongValidator(0,UINT64_MAX,this)),
float32Validator(new FloatXValidator<float>(this)),
float64Validator(new FloatXValidator<double>(this)),
mode(IntDisplayMode::Hex)
{
setWindowTitle(tr("Edit SIMD Register"));
setModal(true);
const auto allContentsGrid = new QGridLayout(this);
for(int byteIndex=0;byteIndex<numBytes;++byteIndex)
{
columnLabels[byteIndex] = new QLabel(std::to_string(byteIndex).c_str(),this);
columnLabels[byteIndex]->setAlignment(Qt::AlignCenter);
allContentsGrid->addWidget(columnLabels[byteIndex], BYTE_INDICES_ROW, ENTRIES_FIRST_COL+numBytes-1-byteIndex);
}
setupEntries(tr("Byte"),bytes,BYTES_ROW,SLOT(onByteEdited()),4);
setupEntries(tr("Word"),words,WORDS_ROW,SLOT(onWordEdited()),6);
setupEntries(tr("Doubleword"),dwords,DWORDS_ROW,SLOT(onDwordEdited()),11);
setupEntries(tr("Quadword"),qwords,QWORDS_ROW,SLOT(onQwordEdited()),21);
setupEntries(tr("float32"),floats32,FLOATS32_ROW,SLOT(onFloat32Edited()),14);
setupEntries(tr("float64"),floats64,FLOATS64_ROW,SLOT(onFloat64Edited()),24);
for(const auto& entry : floats32)
entry->setValidator(float32Validator);
for(const auto& entry : floats64)
entry->setValidator(float64Validator);
hexSignOKCancelLayout = new QHBoxLayout();
{
const auto hexSignRadiosLayout = new QVBoxLayout();
radioHex = new QRadioButton(tr("Hexadecimal"),this);
connect(radioHex,SIGNAL(toggled(bool)),this,SLOT(onHexToggled(bool)));
radioHex->setChecked(true); // must be after connecting of toggled()
hexSignRadiosLayout->addWidget(radioHex);
radioSigned = new QRadioButton(tr("Signed"),this);
connect(radioSigned,SIGNAL(toggled(bool)),this,SLOT(onSignedToggled(bool)));
hexSignRadiosLayout->addWidget(radioSigned);
radioUnsigned = new QRadioButton(tr("Unsigned"),this);
connect(radioUnsigned,SIGNAL(toggled(bool)),this,SLOT(onUnsignedToggled(bool)));
hexSignRadiosLayout->addWidget(radioUnsigned);
hexSignOKCancelLayout->addLayout(hexSignRadiosLayout);
}
{
const auto okCancelLayout = new QVBoxLayout();
okCancelLayout->addItem(new QSpacerItem(20, 40, QSizePolicy::Minimum, QSizePolicy::Expanding));
okCancel = new QDialogButtonBox(QDialogButtonBox::Cancel|QDialogButtonBox::Ok,Qt::Horizontal,this);
connect(okCancel, SIGNAL(accepted()), this, SLOT(accept()));
connect(okCancel, SIGNAL(rejected()), this, SLOT(reject()));
okCancelLayout->addWidget(okCancel);
hexSignOKCancelLayout->addLayout(okCancelLayout);
}
resetLayout();
for(int byte=numBytes-1;byte>0;--byte)
setTabOrder(bytes[byte], bytes[byte-1]);
setTabOrder(bytes.back(), words.front());
for(int word=numBytes/2-1;word>0;--word)
setTabOrder(words[word], words[word-1]);
setTabOrder(words.back(), dwords.front());
for(int dword=numBytes/4-1;dword>0;--dword)
setTabOrder(dwords[dword], dwords[dword-1]);
setTabOrder(dwords.back(), qwords.front());
for(int qword=numBytes/4-1;qword>0;--qword)
setTabOrder(qwords[qword], qwords[qword-1]);
setTabOrder(qwords.back(), floats32.front());
for(int float32=numBytes/4-1;float32>0;--float32)
setTabOrder(floats32[float32], floats32[float32-1]);
setTabOrder(floats32.back(), floats64.front());
for(int float64=numBytes/4-1;float64>0;--float64)
setTabOrder(floats64[float64], floats64[float64-1]);
setTabOrder(floats64.front(), radioHex);
setTabOrder(radioHex, radioSigned);
setTabOrder(radioSigned, radioUnsigned);
setTabOrder(radioUnsigned, okCancel);
}
void Manager::reset(unsigned long /*changed*/)
{
resetLayout();
}
void Manager::paletteChange(const TQPalette &)
{
resetLayout();
}
void KScrollBar::resizeEvent( QGraphicsSceneResizeEvent *event )
{
__super::resizeEvent(event);
resetLayout();
}
TilesetEditor::TilesetEditor(QObject *parent)
: Editor(parent)
, mMainWindow(new TilesetEditorWindow(this))
, mMainToolBar(new MainToolBar(mMainWindow))
, mWidgetStack(new QStackedWidget(mMainWindow))
, mAddTiles(new QAction(this))
, mRemoveTiles(new QAction(this))
, mShowAnimationEditor(new QAction(this))
, mPropertiesDock(new PropertiesDock(mMainWindow))
, mUndoDock(new UndoDock(mMainWindow))
, mTerrainDock(new TerrainDock(mMainWindow))
, mTileCollisionDock(new TileCollisionDock(mMainWindow))
, mWangDock(new WangDock(mMainWindow))
, mZoomComboBox(new QComboBox)
, mStatusInfoLabel(new QLabel)
, mTileAnimationEditor(new TileAnimationEditor(mMainWindow))
, mCurrentTilesetDocument(nullptr)
, mCurrentTile(nullptr)
{
#if QT_VERSION >= 0x050600
mMainWindow->setDockOptions(mMainWindow->dockOptions() | QMainWindow::GroupedDragging);
#endif
mMainWindow->setDockNestingEnabled(true);
mMainWindow->setCentralWidget(mWidgetStack);
QAction *editTerrain = mTerrainDock->toggleViewAction();
QAction *editCollision = mTileCollisionDock->toggleViewAction();
QAction *editWang = mWangDock->toggleViewAction();
mAddTiles->setIcon(QIcon(QLatin1String(":images/16x16/add.png")));
mRemoveTiles->setIcon(QIcon(QLatin1String(":images/16x16/remove.png")));
mShowAnimationEditor->setIcon(QIcon(QLatin1String(":images/24x24/animation-edit.png")));
mShowAnimationEditor->setCheckable(true);
mShowAnimationEditor->setIconVisibleInMenu(false);
editTerrain->setIcon(QIcon(QLatin1String(":images/24x24/terrain.png")));
editTerrain->setIconVisibleInMenu(false);
editCollision->setIcon(QIcon(QLatin1String(":images/48x48/tile-collision-editor.png")));
editCollision->setIconVisibleInMenu(false);
editWang->setIcon(QIcon(QLatin1String(":images/24x24/wangtile.png")));
editWang->setIconVisibleInMenu(false);
Utils::setThemeIcon(mAddTiles, "add");
Utils::setThemeIcon(mRemoveTiles, "remove");
mTilesetToolBar = mMainWindow->addToolBar(tr("Tileset"));
mTilesetToolBar->setObjectName(QLatin1String("TilesetToolBar"));
mTilesetToolBar->addAction(mAddTiles);
mTilesetToolBar->addAction(mRemoveTiles);
mTilesetToolBar->addSeparator();
mTilesetToolBar->addAction(editTerrain);
mTilesetToolBar->addAction(editCollision);
mTilesetToolBar->addAction(editWang);
mTilesetToolBar->addAction(mShowAnimationEditor);
mMainWindow->statusBar()->addPermanentWidget(mZoomComboBox);
mMainWindow->statusBar()->addWidget(mStatusInfoLabel);
resetLayout();
connect(mMainWindow, &TilesetEditorWindow::urlsDropped, this, &TilesetEditor::addTiles);
connect(mWidgetStack, &QStackedWidget::currentChanged, this, &TilesetEditor::currentWidgetChanged);
connect(mAddTiles, &QAction::triggered, this, &TilesetEditor::openAddTilesDialog);
connect(mRemoveTiles, &QAction::triggered, this, &TilesetEditor::removeTiles);
connect(editTerrain, &QAction::toggled, this, &TilesetEditor::setEditTerrain);
connect(editCollision, &QAction::toggled, this, &TilesetEditor::setEditCollision);
connect(editWang, &QAction::toggled, this, &TilesetEditor::setEditWang);
connect(mShowAnimationEditor, &QAction::toggled, mTileAnimationEditor, &TileAnimationEditor::setVisible);
connect(mTileAnimationEditor, &TileAnimationEditor::closed, this, &TilesetEditor::onAnimationEditorClosed);
connect(mTerrainDock, &TerrainDock::currentTerrainChanged, this, &TilesetEditor::currentTerrainChanged);
connect(mTerrainDock, &TerrainDock::addTerrainTypeRequested, this, &TilesetEditor::addTerrainType);
connect(mTerrainDock, &TerrainDock::removeTerrainTypeRequested, this, &TilesetEditor::removeTerrainType);
connect(mWangDock, &WangDock::currentWangSetChanged, this, &TilesetEditor::currentWangSetChanged);
connect(mWangDock, &WangDock::currentWangIdChanged, this, &TilesetEditor::currentWangIdChanged);
connect(mWangDock, &WangDock::wangColorChanged, this, &TilesetEditor::wangColorChanged);
connect(mWangDock, &WangDock::addWangSetRequested, this, &TilesetEditor::addWangSet);
connect(mWangDock, &WangDock::removeWangSetRequested, this, &TilesetEditor::removeWangSet);
connect(mWangDock->wangColorView(), &WangColorView::wangColorColorPicked,
this, &TilesetEditor::setWangColorColor);
connect(this, &TilesetEditor::currentTileChanged,
mTileAnimationEditor, &TileAnimationEditor::setTile);
connect(this, &TilesetEditor::currentTileChanged,
mTileCollisionDock, &TileCollisionDock::setTile);
connect(mTileCollisionDock, &TileCollisionDock::dummyMapDocumentChanged,
this, [this]() {
mPropertiesDock->setDocument(mCurrentTilesetDocument);
});
connect(mTileCollisionDock, &TileCollisionDock::hasSelectedObjectsChanged,
this, &TilesetEditor::hasSelectedCollisionObjectsChanged);
connect(mTileCollisionDock, &TileCollisionDock::statusInfoChanged,
mStatusInfoLabel, &QLabel::setText);
connect(mTileCollisionDock, &TileCollisionDock::visibilityChanged,
this, &Editor::enabledStandardActionsChanged);
connect(TilesetManager::instance(), &TilesetManager::tilesetImagesChanged,
this, &TilesetEditor::updateTilesetView);
retranslateUi();
connect(Preferences::instance(), &Preferences::languageChanged, this, &TilesetEditor::retranslateUi);
}
MainWindow::MainWindow(QWidget* parent)
: QMainWindow(parent), m_ui(new Ui::MainWindow), m_context(0), m_sync(0),
m_loadedScenes(0)
{
if (!s_instance)
s_instance = this;
m_ui->setupUi(this);
//m_ui->filelist->init();
m_ui->renderpass_properties->init();
m_ui->material_properties->init();
createViewport();
/* QDockWidget *dw = new QDockWidget;
dw->setObjectName("Foo");
dw->setWindowTitle("Bar");
dw->setWidget(new QTextEdit);
addDockWidget(Qt::LeftDockWidgetArea, dw);*/
//m_ui->properties
connect(m_ui->action_textures, SIGNAL(triggered()), this, SLOT(openTextureBrowser()));
connect(m_ui->error_list, SIGNAL(itemActivated(QTableWidgetItem*)),
this, SLOT(errorItemActivated(QTableWidgetItem*)));
connect(m_ui->action_savematerial, SIGNAL(triggered()), this, SLOT(saveMaterial()));
connect(m_ui->action_open, SIGNAL(triggered()), this, SLOT(load()));
connect(m_ui->action_savescene, SIGNAL(triggered()), this, SLOT(saveScene()));
connect(m_ui->action_newscene, SIGNAL(triggered()), this, SLOT(newScene()));
connect(m_ui->action_savescene_as, SIGNAL(triggered()), this, SLOT(saveSceneAs()));
/*connect(m_ui->action_new, SIGNAL(triggered()), this, SLOT(open()));
connect(m_ui->action_saveas, SIGNAL(triggered()), this, SLOT(open()));
connect(m_ui->action_open, SIGNAL(triggered()), this, SLOT(open()));*/
connect(m_ui->action_autosave_scene, SIGNAL(triggered(bool)), this, SLOT(setAutosaveScene(bool)));
connect(m_ui->action_import, SIGNAL(triggered()), this, SLOT(import()));
connect(m_ui->action_reload, SIGNAL(triggered()), this, SLOT(reload()));
QAction* actions[] = {m_ui->action_toggle_materials,
m_ui->action_toggle_render_passes, m_ui->action_toggle_error_log
};
QDockWidget* widgets[] = {m_ui->materials_dock, m_ui->render_passes_dock, m_ui->error_dock};
for (size_t i = 0; i < sizeof(actions)/sizeof(*actions); ++i) {
connect(actions[i], SIGNAL(triggered(bool)), widgets[i], SLOT(setVisible(bool)));
connect(widgets[i], SIGNAL(visibilityChanged(bool)), actions[i], SLOT(setChecked(bool)));
}
connect(m_ui->action_reset_layout, SIGNAL(triggered()),
this, SLOT(resetLayout()));
connect(m_ui->action_about, SIGNAL(triggered()),
this, SLOT(about()));
connect(m_ui->editor_tabs, SIGNAL(tabCloseRequested(int)),
this, SLOT(closeEditor(int)));
connect(m_ui->action_sandbox_compiler, SIGNAL(toggled(bool)),
this, SLOT(setSandboxCompiler(bool)));
QSettings settings("Shaderkit", "Shaderkit");
m_ui->action_autosave_scene->setChecked(settings.value("gui/autosave_scene", true).toBool());
m_ui->action_sandbox_compiler->setChecked(settings.value("core/use_sandbox_compiler", true).toBool());
{
m_ui->editor_menu->layout()->setMargin(0);
QIcon icon(":/btns/nosync.png");
icon.addFile(":/btns/sync.png", QSize(), QIcon::Normal, QIcon::On);
m_sync = m_ui->editor_menu->addAction(icon, "Auto-compile");
m_sync->setCheckable(true);
m_sync->setChecked(true);
icon.addFile(":/btns/sync.png", QSize(), QIcon::Normal, QIcon::On);
m_ui->editor_menu->addAction(QIcon(":/btns/compile.png"), "Compile all",
this, SLOT(compileAll()));
}
}
