LTMWindow::LTMWindow(Context *context) :
GcChartWindow(context), context(context), dirty(true), stackDirty(true), compareDirty(true)
{
useToToday = useCustom = false;
plotted = DateRange(QDate(01,01,01), QDate(01,01,01));
lastRefresh = QTime::currentTime().addSecs(-10);
// the plot
QVBoxLayout *mainLayout = new QVBoxLayout;
QPalette palette;
palette.setBrush(QPalette::Background, QBrush(GColor(CTRENDPLOTBACKGROUND)));
// single plot
plotWidget = new QWidget(this);
plotWidget->setPalette(palette);
QVBoxLayout *plotLayout = new QVBoxLayout(plotWidget);
plotLayout->setSpacing(0);
plotLayout->setContentsMargins(0,0,0,0);
ltmPlot = new LTMPlot(this, context, true);
spanSlider = new QxtSpanSlider(Qt::Horizontal, this);
spanSlider->setFocusPolicy(Qt::NoFocus);
spanSlider->setHandleMovementMode(QxtSpanSlider::NoOverlapping);
spanSlider->setLowerValue(0);
spanSlider->setUpperValue(15);
QFont small;
small.setPointSize(6);
scrollLeft = new QPushButton("<", this);
scrollLeft->setFont(small);
scrollLeft->setAutoRepeat(true);
scrollLeft->setFixedHeight(16);
scrollLeft->setFixedWidth(16);
scrollLeft->setContentsMargins(0,0,0,0);
scrollRight = new QPushButton(">", this);
scrollRight->setFont(small);
scrollRight->setAutoRepeat(true);
scrollRight->setFixedHeight(16);
scrollRight->setFixedWidth(16);
scrollRight->setContentsMargins(0,0,0,0);
QHBoxLayout *span = new QHBoxLayout;
span->addWidget(scrollLeft);
span->addWidget(spanSlider);
span->addWidget(scrollRight);
plotLayout->addWidget(ltmPlot);
plotLayout->addLayout(span);
#ifdef Q_OS_MAC
// BUG in QMacStyle and painting of spanSlider
// so we use a plain style to avoid it, but only
// on a MAC, since win and linux are fine
#if QT_VERSION > 0x5000
QStyle *style = QStyleFactory::create("fusion");
#else
QStyle *style = QStyleFactory::create("Cleanlooks");
#endif
spanSlider->setStyle(style);
scrollLeft->setStyle(style);
scrollRight->setStyle(style);
#endif
// the stack of plots
plotsWidget = new QWidget(this);
plotsWidget->setPalette(palette);
plotsLayout = new QVBoxLayout(plotsWidget);
plotsLayout->setSpacing(0);
plotsLayout->setContentsMargins(0,0,0,0);
plotArea = new QScrollArea(this);
#ifdef Q_OS_WIN
QStyle *cde = QStyleFactory::create(OS_STYLE);
plotArea->setStyle(cde);
#endif
plotArea->setAutoFillBackground(false);
plotArea->setWidgetResizable(true);
plotArea->setWidget(plotsWidget);
plotArea->setFrameStyle(QFrame::NoFrame);
plotArea->setContentsMargins(0,0,0,0);
plotArea->setPalette(palette);
// the data table
dataSummary = new QWebView(this);
dataSummary->setContentsMargins(0,0,0,0);
dataSummary->page()->view()->setContentsMargins(0,0,0,0);
dataSummary->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
dataSummary->setAcceptDrops(false);
QFont defaultFont; // mainwindow sets up the defaults.. we need to apply
dataSummary->settings()->setFontSize(QWebSettings::DefaultFontSize, defaultFont.pointSize()+1);
dataSummary->settings()->setFontFamily(QWebSettings::StandardFont, defaultFont.family());
// compare plot page
compareplotsWidget = new QWidget(this);
compareplotsWidget->setPalette(palette);
compareplotsLayout = new QVBoxLayout(compareplotsWidget);
compareplotsLayout->setSpacing(0);
compareplotsLayout->setContentsMargins(0,0,0,0);
compareplotArea = new QScrollArea(this);
#ifdef Q_OS_WIN
cde = QStyleFactory::create(OS_STYLE);
compareplotArea->setStyle(cde);
#endif
compareplotArea->setAutoFillBackground(false);
compareplotArea->setWidgetResizable(true);
compareplotArea->setWidget(compareplotsWidget);
compareplotArea->setFrameStyle(QFrame::NoFrame);
compareplotArea->setContentsMargins(0,0,0,0);
compareplotArea->setPalette(palette);
// the stack
stackWidget = new QStackedWidget(this);
stackWidget->addWidget(plotWidget);
stackWidget->addWidget(dataSummary);
stackWidget->addWidget(plotArea);
stackWidget->addWidget(compareplotArea);
stackWidget->setCurrentIndex(0);
mainLayout->addWidget(stackWidget);
setChartLayout(mainLayout);
HelpWhatsThis *helpStack = new HelpWhatsThis(stackWidget);
stackWidget->setWhatsThis(helpStack->getWhatsThisText(HelpWhatsThis::ChartTrends_MetricTrends));
// reveal controls
QHBoxLayout *revealLayout = new QHBoxLayout;
revealLayout->setContentsMargins(0,0,0,0);
revealLayout->addStretch();
revealLayout->addWidget(new QLabel(tr("Group by"),this));
rGroupBy = new QxtStringSpinBox(this);
QStringList strings;
strings << tr("Days")
<< tr("Weeks")
<< tr("Months")
<< tr("Years")
<< tr("Time Of Day")
<< tr("All");
rGroupBy->setStrings(strings);
rGroupBy->setValue(0);
revealLayout->addWidget(rGroupBy);
rData = new QCheckBox(tr("Data Table"), this);
rStack = new QCheckBox(tr("Stacked"), this);
QVBoxLayout *checks = new QVBoxLayout;
checks->setSpacing(2);
checks->setContentsMargins(0,0,0,0);
checks->addWidget(rData);
checks->addWidget(rStack);
revealLayout->addLayout(checks);
revealLayout->addStretch();
setRevealLayout(revealLayout);
// add additional menu items before setting
// controls since the menu is SET from setControls
QAction *exportData = new QAction(tr("Export Chart Data..."), this);
addAction(exportData);
// the controls
QWidget *c = new QWidget;
c->setContentsMargins(0,0,0,0);
HelpWhatsThis *helpConfig = new HelpWhatsThis(c);
c->setWhatsThis(helpConfig->getWhatsThisText(HelpWhatsThis::ChartTrends_MetricTrends));
QVBoxLayout *cl = new QVBoxLayout(c);
cl->setContentsMargins(0,0,0,0);
cl->setSpacing(0);
setControls(c);
// the popup
popup = new GcPane();
ltmPopup = new LTMPopup(context);
QVBoxLayout *popupLayout = new QVBoxLayout();
popupLayout->addWidget(ltmPopup);
popup->setLayout(popupLayout);
ltmTool = new LTMTool(context, &settings);
// initialise
settings.ltmTool = ltmTool;
settings.groupBy = LTM_DAY;
settings.legend = ltmTool->showLegend->isChecked();
settings.events = ltmTool->showEvents->isChecked();
settings.shadeZones = ltmTool->shadeZones->isChecked();
settings.showData = ltmTool->showData->isChecked();
settings.stack = ltmTool->showStack->isChecked();
settings.stackWidth = ltmTool->stackSlider->value();
rData->setChecked(ltmTool->showData->isChecked());
rStack->setChecked(ltmTool->showStack->isChecked());
cl->addWidget(ltmTool);
connect(this, SIGNAL(dateRangeChanged(DateRange)), this, SLOT(dateRangeChanged(DateRange)));
connect(this, SIGNAL(styleChanged(int)), this, SLOT(styleChanged(int)));
connect(ltmTool, SIGNAL(filterChanged()), this, SLOT(filterChanged()));
connect(context, SIGNAL(homeFilterChanged()), this, SLOT(filterChanged()));
connect(ltmTool->groupBy, SIGNAL(currentIndexChanged(int)), this, SLOT(groupBySelected(int)));
connect(rGroupBy, SIGNAL(valueChanged(int)), this, SLOT(rGroupBySelected(int)));
connect(ltmTool->applyButton, SIGNAL(clicked(bool)), this, SLOT(applyClicked(void)));
connect(ltmTool->shadeZones, SIGNAL(stateChanged(int)), this, SLOT(shadeZonesClicked(int)));
connect(ltmTool->showData, SIGNAL(stateChanged(int)), this, SLOT(showDataClicked(int)));
connect(rData, SIGNAL(stateChanged(int)), this, SLOT(showDataClicked(int)));
connect(ltmTool->showStack, SIGNAL(stateChanged(int)), this, SLOT(showStackClicked(int)));
connect(rStack, SIGNAL(stateChanged(int)), this, SLOT(showStackClicked(int)));
connect(ltmTool->stackSlider, SIGNAL(valueChanged(int)), this, SLOT(zoomSliderChanged()));
connect(ltmTool->showLegend, SIGNAL(stateChanged(int)), this, SLOT(showLegendClicked(int)));
connect(ltmTool->showEvents, SIGNAL(stateChanged(int)), this, SLOT(showEventsClicked(int)));
connect(ltmTool, SIGNAL(useCustomRange(DateRange)), this, SLOT(useCustomRange(DateRange)));
connect(ltmTool, SIGNAL(useThruToday()), this, SLOT(useThruToday()));
connect(ltmTool, SIGNAL(useStandardRange()), this, SLOT(useStandardRange()));
connect(ltmTool, SIGNAL(curvesChanged()), this, SLOT(refresh()));
connect(context, SIGNAL(filterChanged()), this, SLOT(filterChanged()));
connect(context, SIGNAL(refreshUpdate(QDate)), this, SLOT(refreshUpdate(QDate)));
connect(context, SIGNAL(refreshEnd()), this, SLOT(refresh()));
// comparing things
connect(context, SIGNAL(compareDateRangesStateChanged(bool)), this, SLOT(compareChanged()));
connect(context, SIGNAL(compareDateRangesChanged()), this, SLOT(compareChanged()));
connect(context, SIGNAL(rideAdded(RideItem*)), this, SLOT(refresh(void)));
connect(context, SIGNAL(rideDeleted(RideItem*)), this, SLOT(refresh(void)));
connect(context, SIGNAL(rideSaved(RideItem*)), this, SLOT(refresh(void)));
connect(context, SIGNAL(configChanged(qint32)), this, SLOT(configChanged(qint32)));
connect(context, SIGNAL(presetSelected(int)), this, SLOT(presetSelected(int)));
// custom menu item
connect(exportData, SIGNAL(triggered()), this, SLOT(exportData()));
// normal view
connect(spanSlider, SIGNAL(lowerPositionChanged(int)), this, SLOT(spanSliderChanged()));
connect(spanSlider, SIGNAL(upperPositionChanged(int)), this, SLOT(spanSliderChanged()));
connect(scrollLeft, SIGNAL(clicked()), this, SLOT(moveLeft()));
connect(scrollRight, SIGNAL(clicked()), this, SLOT(moveRight()));
configChanged(CONFIG_APPEARANCE);
}
void LLAgentPilot::updateTarget()
{
if (mPlaying)
{
if (mCurrentAction < mActions.count())
{
if (0 == mCurrentAction)
{
if (gAgent.getAutoPilot())
{
// Wait until we get to the first location before starting.
return;
}
else
{
if (!mStarted)
{
llinfos << "At start, beginning playback" << llendl;
mTimer.reset();
mStarted = TRUE;
}
}
}
if (mTimer.getElapsedTimeF32() > mActions[mCurrentAction].mTime)
{
//gAgent.stopAutoPilot();
mCurrentAction++;
if (mCurrentAction < mActions.count())
{
gAgent.startAutoPilotGlobal(mActions[mCurrentAction].mTarget);
}
else
{
stopPlayback();
mNumRuns--;
if (sLoop)
{
if ((mNumRuns < 0) || (mNumRuns > 0))
{
llinfos << "Looping, restarting playback" << llendl;
startPlayback();
}
else if (mQuitAfterRuns)
{
llinfos << "Done with all runs, quitting viewer!" << llendl;
LLAppViewer::instance()->forceQuit();
}
else
{
llinfos << "Done with all runs, disabling pilot" << llendl;
stopPlayback();
}
}
}
}
}
else
{
stopPlayback();
}
}
else if (mRecording)
{
if (mTimer.getElapsedTimeF32() - mLastRecordTime > 1.f)
{
addAction(STRAIGHT);
}
}
}
CSVWorld::Table::Table (const CSMWorld::UniversalId& id, CSMWorld::Data& data, QUndoStack& undoStack,
bool createAndDelete, bool sorting)
: mUndoStack (undoStack), mCreateAction (0), mCloneAction(0), mEditLock (false), mRecordStatusDisplay (0)
{
mModel = &dynamic_cast<CSMWorld::IdTable&> (*data.getTableModel (id));
mProxyModel = new CSMWorld::IdTableProxyModel (this);
mProxyModel->setSourceModel (mModel);
setModel (mProxyModel);
horizontalHeader()->setResizeMode (QHeaderView::Interactive);
verticalHeader()->hide();
setSortingEnabled (sorting);
setSelectionBehavior (QAbstractItemView::SelectRows);
setSelectionMode (QAbstractItemView::ExtendedSelection);
int columns = mModel->columnCount();
for (int i=0; i<columns; ++i)
{
int flags = mModel->headerData (i, Qt::Horizontal, CSMWorld::ColumnBase::Role_Flags).toInt();
if (flags & CSMWorld::ColumnBase::Flag_Table)
{
CSMWorld::ColumnBase::Display display = static_cast<CSMWorld::ColumnBase::Display> (
mModel->headerData (i, Qt::Horizontal, CSMWorld::ColumnBase::Role_Display).toInt());
CommandDelegate *delegate = CommandDelegateFactoryCollection::get().makeDelegate (display,
undoStack, this);
mDelegates.push_back (delegate);
setItemDelegateForColumn (i, delegate);
}
else
hideColumn (i);
}
mEditAction = new QAction (tr ("Edit Record"), this);
connect (mEditAction, SIGNAL (triggered()), this, SLOT (editRecord()));
addAction (mEditAction);
if (createAndDelete)
{
mCreateAction = new QAction (tr ("Add Record"), this);
connect (mCreateAction, SIGNAL (triggered()), this, SIGNAL (createRequest()));
addAction (mCreateAction);
mCloneAction = new QAction (tr ("Clone Record"), this);
connect(mCloneAction, SIGNAL (triggered()), this, SLOT (cloneRecord()));
addAction(mCloneAction);
}
mRevertAction = new QAction (tr ("Revert Record"), this);
connect (mRevertAction, SIGNAL (triggered()), this, SLOT (revertRecord()));
addAction (mRevertAction);
mDeleteAction = new QAction (tr ("Delete Record"), this);
connect (mDeleteAction, SIGNAL (triggered()), this, SLOT (deleteRecord()));
addAction (mDeleteAction);
mMoveUpAction = new QAction (tr ("Move Up"), this);
connect (mMoveUpAction, SIGNAL (triggered()), this, SLOT (moveUpRecord()));
addAction (mMoveUpAction);
mMoveDownAction = new QAction (tr ("Move Down"), this);
connect (mMoveDownAction, SIGNAL (triggered()), this, SLOT (moveDownRecord()));
addAction (mMoveDownAction);
connect (mProxyModel, SIGNAL (rowsInserted (const QModelIndex&, int, int)),
this, SLOT (tableSizeUpdate()));
/// \note This signal could instead be connected to a slot that filters out changes not affecting
/// the records status column (for permanence reasons)
connect (mProxyModel, SIGNAL (dataChanged (const QModelIndex&, const QModelIndex&)),
this, SLOT (tableSizeUpdate()));
connect (selectionModel(), SIGNAL (selectionChanged (const QItemSelection&, const QItemSelection&)),
this, SLOT (selectionSizeUpdate ()));
}
void HistoryMenu::setInitialActions(QList<QAction*> actions)
{
m_initialActions = actions;
for (int i = 0; i < m_initialActions.count(); ++i)
addAction(m_initialActions.at(i));
}
MainWindow::MainWindow(QWidget *parent) :
QDialog(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
ui->fEditor->setAcceptRichText(false);
fSimpleNote = 0;
ui->fNoteList->setItemDelegate(new ListDelegate(ui->fNoteList));
ui->fTagsComboBox->view()->setItemDelegate(new TagListDelegate(ui->fTagsComboBox));
QList<int> sizes;
sizes << 200 << 400;
ui->fSplitter->setSizes(sizes);
fTimer = new QTimer(this);
fTimer->setInterval(5000);
fTimer->start();
connect(fTimer, SIGNAL(timeout()), this, SLOT(OnTimeout()));
QAction* quitAction = new QAction(tr("Quit"), this);
quitAction->setShortcut(QKeySequence("Ctrl+Q"));
connect(quitAction, SIGNAL(triggered(bool)), this, SLOT(close()));
addAction(quitAction);
QAction* addNoteAction = new QAction(tr("New Note"), this);
addNoteAction->setIcon(QIcon(":/images/images/add2.png"));
addNoteAction->setShortcut(QKeySequence("Ctrl+N"));
connect(addNoteAction, SIGNAL(triggered(bool)), this, SLOT(OnAdd()));
ui->fNoteList->addAction(addNoteAction);
ui->fAddButton->setDefaultAction(addNoteAction);
QAction* deleteCurrent = new QAction(tr("Remove"), ui->fNoteList);
deleteCurrent->setIcon(QIcon(":/images/images/delete2.png"));
connect(deleteCurrent, SIGNAL(triggered(bool)), this, SLOT(RemoveCurrent()));
ui->fNoteList->addAction(deleteCurrent);
ui->fNoteList->setContextMenuPolicy(Qt::ActionsContextMenu);
QAction* syncCurrentAction = new QAction("Sync Current", this);
syncCurrentAction->setShortcut(QKeySequence("Ctrl+S"));
connect(syncCurrentAction, SIGNAL(triggered(bool)), this, SLOT(SaveCurrent()));
addAction(syncCurrentAction);
QAction* syncAction = new QAction("Full Sync", this);
syncAction->setShortcut(QKeySequence("Ctrl+Shift+S"));
connect(syncAction, SIGNAL(triggered(bool)), this, SLOT(FullSync()));
addAction(syncAction);
QAction* tagsAction = new QAction("Edit Tags", this);
tagsAction->setShortcut(QKeySequence("Ctrl+G"));
connect(tagsAction, SIGNAL(triggered(bool)), this, SLOT(EditTags()));
addAction(tagsAction);
QAction* settingsAction = new QAction("Settings...", this);
connect(settingsAction, SIGNAL(triggered(bool)), this, SLOT(OnSettings()));
addAction(settingsAction);
ui->fSettingsButton->addAction(syncCurrentAction);
ui->fSettingsButton->addAction(syncAction);
ui->fSettingsButton->addAction(settingsAction);
ui->fSettingsButton->setPopupMode(QToolButton::InstantPopup);
connect(ui->fFavouriteButton, SIGNAL(clicked(bool)), this, SLOT(OnFavourite()));
connect(ui->fEditor, SIGNAL(textChanged()), this, SLOT(OnTextChanged()));
connect(ui->fSearchEdit, SIGNAL(textChanged(QString)), this, SLOT(OnSearchChanged()));
connect(ui->fTagsEdit, SIGNAL(textChanged(QString)), this, SLOT(OnTagsChanged()));
connect(ui->fExportButton, SIGNAL(clicked(bool)), this, SLOT(OnExport()));
connect(ui->fTagsComboBox, SIGNAL(activated(int)), this, SLOT(OnTagSelected()));
connect(ui->fEditor, SIGNAL(OpenNote(QString)), this, SLOT(OpenNote(QString)));
fCurrent = -1;
fNotes.SetMessageReceiver(this);
fSnippets.reset(new SnippetCollection);
ui->fEditor->SetSnippets(fSnippets);
fNotesModel = new NoteListModel(&fNotes, this);
fFilterModel = new NoteSortFilterModel(this);
fFilterModel->setFilterCaseSensitivity(Qt::CaseInsensitive);
fFilterModel->setSortCaseSensitivity(Qt::CaseInsensitive);
fFilterModel->setSourceModel(fNotesModel);
ui->fNoteList->setModel(fFilterModel);
connect(ui->fNoteList->selectionModel(), SIGNAL(currentRowChanged(QModelIndex,QModelIndex)), this, SLOT(OnSelection(QModelIndex)));
LoadNotes();
UpdateNoteList();
ui->fNoteList->setCurrentIndex(fFilterModel->index(0, 0));
ui->fNoteList->setFocus();
RestoreSettings();
SetEditorFont(SettingsDialog::CurrentFont(), SettingsDialog::CurrentTabSize());
}
CustomActionDialog::CustomActionDialog(QWidget* parent, Qt::WFlags fl)
: QDialog(parent, fl)
{
setWindowTitle(tr("QtiPlot") + " - " + tr("Add Custom Action"));
itemsList = new QListWidget();
itemsList->setSelectionMode(QAbstractItemView::SingleSelection);
itemsList->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred));
itemsList->setSpacing(2);
QGroupBox *gb1 = new QGroupBox();
gb1->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred));
QGridLayout *gl1 = new QGridLayout(gb1);
gl1->addWidget(new QLabel(tr("Folder")), 0, 0);
folderBox = new QLineEdit();
gl1->addWidget(folderBox, 0, 1);
folderBtn = new QPushButton(tr("Choose &Folder"));
gl1->addWidget(folderBtn, 0, 2);
gl1->addWidget(new QLabel(tr("Script File")), 1, 0);
fileBox = new QLineEdit();
gl1->addWidget(fileBox, 1, 1);
fileBtn = new QPushButton(tr("Choose &Script"));
gl1->addWidget(fileBtn, 1, 2);
gl1->addWidget(new QLabel(tr("Icon")), 2, 0);
iconBox = new QLineEdit();
gl1->addWidget(iconBox, 2, 1);
iconBtn = new QPushButton(tr("Choose &Icon"));
gl1->addWidget(iconBtn, 2, 2);
gl1->addWidget(new QLabel(tr("Text")), 3, 0);
textBox = new QLineEdit();
gl1->addWidget(textBox, 3, 1);
gl1->addWidget(new QLabel(tr("Tool Tip Text")), 4, 0);
toolTipBox = new QLineEdit();
gl1->addWidget(toolTipBox, 4, 1);
gl1->addWidget(new QLabel(tr("Shortcut")), 5, 0);
shortcutBox = new QLineEdit();
gl1->addWidget(shortcutBox, 5, 1);
menuBtn = new QRadioButton(tr("&Menu"));
gl1->addWidget(menuBtn, 6, 0);
menuBox = new QComboBox();
gl1->addWidget(menuBox, 6, 1);
toolBarBtn = new QRadioButton(tr("&Tool Bar"));
toolBarBtn->setChecked(true);
gl1->addWidget(toolBarBtn, 7, 0);
toolBarBox = new QComboBox();
gl1->addWidget(toolBarBox, 7, 1);
gl1->setRowStretch(8, 1);
gl1->setColumnStretch(1, 10);
QHBoxLayout * bottomButtons = new QHBoxLayout();
bottomButtons->addStretch();
buttonSave = new QPushButton(tr("&Save"));
buttonSave->setAutoDefault( true );
bottomButtons->addWidget(buttonSave);
buttonAdd = new QPushButton(tr("&Add"));
buttonAdd->setAutoDefault( true );
bottomButtons->addWidget(buttonAdd);
buttonRemove = new QPushButton(tr("&Remove"));
buttonRemove->setAutoDefault(true);
bottomButtons->addWidget(buttonRemove);
buttonCancel = new QPushButton(tr("&Close"));
buttonCancel->setAutoDefault( true );
bottomButtons->addWidget( buttonCancel );
QHBoxLayout *vl = new QHBoxLayout();
vl->addWidget(itemsList);
vl->addWidget(gb1);
QVBoxLayout *mainLayout = new QVBoxLayout(this);
mainLayout->addLayout(vl);
mainLayout->addLayout(bottomButtons);
init();
QShortcut *accelRemove = new QShortcut(QKeySequence(Qt::Key_Delete), this);
connect(accelRemove, SIGNAL(activated()), this, SLOT(removeAction()));
connect(buttonSave, SIGNAL(clicked()), this, SLOT(saveCurrentAction()));
connect(buttonAdd, SIGNAL(clicked()), this, SLOT(addAction()));
connect(buttonRemove, SIGNAL(clicked()), this, SLOT(removeAction()));
connect(buttonCancel, SIGNAL(clicked()), this, SLOT(reject()));
connect(iconBtn, SIGNAL(clicked()), this, SLOT(chooseIcon()));
connect(fileBtn, SIGNAL(clicked()), this, SLOT(chooseFile()));
connect(folderBtn, SIGNAL(clicked()), this, SLOT(chooseFolder()));
connect(itemsList, SIGNAL(currentRowChanged(int)), this, SLOT(setCurrentAction(int)));
}
void MSAOverviewContextMenu::initExportAsImageAction() {
exportAsImage = new QAction(tr("Export as image"), this);
exportAsImage->setObjectName("Export as image");
addAction(exportAsImage);
}
void btDiscreteDynamicsWorld::addCharacter(btActionInterface* character)
{
addAction(character);
}
VCXYPadProperties::VCXYPadProperties(VCXYPad* xypad, Doc* doc)
: QDialog(xypad)
, m_xypad(xypad)
, m_doc(doc)
{
Q_ASSERT(doc != NULL);
Q_ASSERT(xypad != NULL);
setupUi(this);
// IDs 0-15 are reserved for XYPad base controls
m_lastAssignedID = 15;
QAction* action = new QAction(this);
action->setShortcut(QKeySequence(QKeySequence::Close));
connect(action, SIGNAL(triggered(bool)), this, SLOT(reject()));
addAction(action);
/********************************************************************
* General page
********************************************************************/
m_nameEdit->setText(m_xypad->caption());
if (m_xypad->invertedAppearance() == true)
m_YInvertedRadio->setChecked(true);
m_panInputWidget = new InputSelectionWidget(m_doc, this);
m_panInputWidget->setTitle(tr("Pan / Horizontal Axis"));
m_panInputWidget->setKeyInputVisibility(false);
m_panInputWidget->setInputSource(m_xypad->inputSource(VCXYPad::panInputSourceId));
m_panInputWidget->setWidgetPage(m_xypad->page());
m_panInputWidget->emitOddValues(true);
m_panInputWidget->show();
m_extInputLayout->addWidget(m_panInputWidget);
connect(m_panInputWidget, SIGNAL(autoDetectToggled(bool)),
this, SLOT(slotPanAutoDetectToggled(bool)));
connect(m_panInputWidget, SIGNAL(inputValueChanged(quint32,quint32)),
this, SLOT(slotPanInputValueChanged(quint32,quint32)));
m_tiltInputWidget = new InputSelectionWidget(m_doc, this);
m_tiltInputWidget->setTitle(tr("Tilt / Vertical Axis"));
m_tiltInputWidget->setKeyInputVisibility(false);
m_tiltInputWidget->setInputSource(m_xypad->inputSource(VCXYPad::tiltInputSourceId));
m_tiltInputWidget->setWidgetPage(m_xypad->page());
m_tiltInputWidget->emitOddValues(true);
m_tiltInputWidget->show();
m_extInputLayout->addWidget(m_tiltInputWidget);
connect(m_tiltInputWidget, SIGNAL(autoDetectToggled(bool)),
this, SLOT(slotTiltAutoDetectToggled(bool)));
connect(m_tiltInputWidget, SIGNAL(inputValueChanged(quint32,quint32)),
this, SLOT(slotTiltInputValueChanged(quint32,quint32)));
m_widthInputWidget = new InputSelectionWidget(m_doc, this);
m_widthInputWidget->setTitle(tr("Width"));
m_widthInputWidget->setKeyInputVisibility(false);
m_widthInputWidget->setInputSource(m_xypad->inputSource(VCXYPad::widthInputSourceId));
m_widthInputWidget->setWidgetPage(m_xypad->page());
m_widthInputWidget->show();
m_sizeInputLayout->addWidget(m_widthInputWidget);
m_heightInputWidget = new InputSelectionWidget(m_doc, this);
m_heightInputWidget->setTitle(tr("Height"));
m_heightInputWidget->setKeyInputVisibility(false);
m_heightInputWidget->setInputSource(m_xypad->inputSource(VCXYPad::heightInputSourceId));
m_heightInputWidget->setWidgetPage(m_xypad->page());
m_heightInputWidget->show();
m_sizeInputLayout->addWidget(m_heightInputWidget);
/********************************************************************
* Fixtures page
********************************************************************/
slotSelectionChanged(NULL);
fillFixturesTree();
connect(m_percentageRadio, SIGNAL(clicked(bool)),
this, SLOT(slotPercentageRadioChecked()));
connect(m_degreesRadio, SIGNAL(clicked(bool)),
this, SLOT(slotDegreesRadioChecked()));
connect(m_dmxRadio, SIGNAL(clicked(bool)),
this, SLOT(slotDMXRadioChecked()));
/********************************************************************
* Presets page
********************************************************************/
m_presetInputWidget = new InputSelectionWidget(m_doc, this);
m_presetInputWidget->setCustomFeedbackVisibility(true);
m_presetInputWidget->setWidgetPage(m_xypad->page());
m_presetInputWidget->show();
m_presetInputLayout->addWidget(m_presetInputWidget);
connect(m_presetInputWidget, SIGNAL(inputValueChanged(quint32,quint32)),
this, SLOT(slotInputValueChanged(quint32,quint32)));
connect(m_presetInputWidget, SIGNAL(keySequenceChanged(QKeySequence)),
this, SLOT(slotKeySequenceChanged(QKeySequence)));
connect(m_addPositionButton, SIGNAL(clicked(bool)),
this, SLOT(slotAddPositionClicked()));
connect(m_addEfxButton, SIGNAL(clicked(bool)),
this, SLOT(slotAddEFXClicked()));
connect(m_addSceneButton, SIGNAL(clicked(bool)),
this, SLOT(slotAddSceneClicked()));
connect(m_addFxGroupButton, SIGNAL(clicked(bool)),
this, SLOT(slotAddFixtureGroupClicked()));
connect(m_removePresetButton, SIGNAL(clicked()),
this, SLOT(slotRemovePresetClicked()));
connect(m_moveUpPresetButton, SIGNAL(clicked()),
this, SLOT(slotMoveUpPresetClicked()));
connect(m_moveDownPresetButton, SIGNAL(clicked()),
this, SLOT(slotMoveDownPresetClicked()));
connect(m_presetNameEdit, SIGNAL(textEdited(QString const&)),
this, SLOT(slotPresetNameEdited(QString const&)));
connect(m_presetsTree, SIGNAL(itemClicked(QTreeWidgetItem*,int)),
this, SLOT(slotPresetSelectionChanged()));
m_xyArea = new VCXYPadArea(this);
//m_xyArea->setFixedSize(140, 140);
m_xyArea->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
m_xyArea->setMode(Doc::Operate);
m_presetLayout->addWidget(m_xyArea);
connect(m_xyArea, SIGNAL(positionChanged(QPointF)),
this, SLOT(slotXYPadPositionChanged(QPointF)));
foreach(const VCXYPadPreset *preset, m_xypad->presets())
{
m_presetList.append(new VCXYPadPreset(*preset));
if (preset->m_id > m_lastAssignedID)
m_lastAssignedID = preset->m_id;
}
updatePresetsTree();
QSettings settings;
QVariant var = settings.value(SETTINGS_GEOMETRY);
if (var.isValid() == true)
restoreGeometry(var.toByteArray());
AppUtil::ensureWidgetIsVisible(this);
m_doc->masterTimer()->registerDMXSource(this, "XYPadCfg");
}
AddFixture::AddFixture(QWidget* parent, const Doc* doc, const Fixture* fxi)
: QDialog(parent)
, m_doc(doc)
{
m_addressValue = 0;
m_universeValue = 0;
m_amountValue = 1;
m_gapValue = 0;
m_channelsValue = 1;
m_fixtureDef = NULL;
m_mode = NULL;
m_fxiCount = 0;
m_fixtureID = Fixture::invalidId();
m_invalidAddressFlag = false;
setupUi(this);
m_addrErrorLabel->hide();
QAction* action = new QAction(this);
action->setShortcut(QKeySequence(QKeySequence::Close));
connect(action, SIGNAL(triggered(bool)), this, SLOT(reject()));
addAction(action);
connect(m_tree, SIGNAL(itemSelectionChanged()),
this, SLOT(slotSelectionChanged()));
connect(m_tree, SIGNAL(itemDoubleClicked(QTreeWidgetItem*,int)),
this, SLOT(slotTreeDoubleClicked(QTreeWidgetItem*)));
connect(m_modeCombo, SIGNAL(activated(const QString&)),
this, SLOT(slotModeActivated(const QString&)));
connect(m_universeCombo, SIGNAL(activated(int)),
this, SLOT(slotUniverseActivated(int)));
connect(m_addressSpin, SIGNAL(valueChanged(int)),
this, SLOT(slotAddressChanged(int)));
connect(m_channelsSpin, SIGNAL(valueChanged(int)),
this, SLOT(slotChannelsChanged(int)));
connect(m_nameEdit, SIGNAL(textEdited(const QString&)),
this, SLOT(slotNameEdited(const QString&)));
connect(m_gapSpin, SIGNAL(valueChanged(int)),
this, SLOT(slotGapSpinChanged(int)));
connect(m_amountSpin, SIGNAL(valueChanged(int)),
this, SLOT(slotAmountSpinChanged(int)));
/* Fill fixture definition tree (and select a fixture def) */
if (fxi != NULL && fxi->isDimmer() == false)
fillTree(fxi->fixtureDef()->manufacturer(), fxi->fixtureDef()->model());
else
fillTree(KXMLFixtureGeneric, KXMLFixtureGeneric);
m_fixturesCount->setText(tr("Fixtures found: %1").arg(m_fxiCount));
/* Fill universe combo with available universes */
m_universeCombo->addItems(m_doc->outputMap()->universeNames());
/* Simulate first selection and find the next free address */
slotSelectionChanged();
// Universe
if (fxi != NULL)
{
m_fixtureID = fxi->id();
m_universeCombo->setCurrentIndex(fxi->universe());
slotUniverseActivated(fxi->universe());
m_addressSpin->setValue(fxi->address() + 1);
m_addressValue = fxi->address();
m_multipleGroup->setEnabled(false);
}
else
{
slotUniverseActivated(0);
findAddress();
}
// Name
if (fxi != NULL)
{
m_nameEdit->setText(fxi->name());
slotNameEdited(fxi->name());
m_nameEdit->setModified(true); // Prevent auto-naming
}
// Mode
if (fxi != NULL)
{
if (fxi->isDimmer() == false)
{
int index = m_modeCombo->findText(fxi->fixtureMode()->name());
if (index != -1)
{
m_modeCombo->setCurrentIndex(index);
slotModeActivated(m_modeCombo->itemText(index));
}
}
else
{
m_channelsSpin->setValue(fxi->channels());
}
}
else
{
m_channelsSpin->setValue(1);
}
QSettings settings;
QVariant var = settings.value(SETTINGS_GEOMETRY);
if (var.isValid() == true)
restoreGeometry(var.toByteArray());
AppUtil::ensureWidgetIsVisible(this);
}
void btDiscreteDynamicsWorld::addVehicle(btActionInterface* vehicle)
{
addAction(vehicle);
}
TermWidgetImpl::TermWidgetImpl(const QString & wdir, const QString & shell, QWidget * parent)
: QTermWidget(0, parent)
{
TermWidgetCount++;
QString name("TermWidget_%1");
setObjectName(name.arg(TermWidgetCount));
setFlowControlEnabled(FLOW_CONTROL_ENABLED);
setFlowControlWarningEnabled(FLOW_CONTROL_WARNING_ENABLED);
propertiesChanged();
setHistorySize(5000);
if (!wdir.isNull())
setWorkingDirectory(wdir);
if (shell.isNull())
{
if (!Properties::Instance()->shell.isNull())
setShellProgram(Properties::Instance()->shell);
}
else
{
qDebug() << "Settings custom shell program:" << shell;
QStringList parts = shell.split(QRegExp("\\s+"), QString::SkipEmptyParts);
qDebug() << parts;
setShellProgram(parts.at(0));
parts.removeAt(0);
if (parts.count())
setArgs(parts);
}
setMotionAfterPasting(Properties::Instance()->m_motionAfterPaste);
actionMap[COPY_SELECTION] = new QAction(QIcon(":/icons/edit-copy.png"), tr(COPY_SELECTION), this);
connect(actionMap[COPY_SELECTION], SIGNAL(triggered()), this, SLOT(copyClipboard()));
addAction(actionMap[COPY_SELECTION]);
actionMap[PASTE_CLIPBOARD] = new QAction(QIcon(":/icons/edit-paste.png"), tr(PASTE_CLIPBOARD), this);
connect(actionMap[PASTE_CLIPBOARD], SIGNAL(triggered()), this, SLOT(pasteClipboard()));
addAction(actionMap[PASTE_CLIPBOARD]);
actionMap[PASTE_SELECTION] = new QAction(QIcon(":/icons/edit-paste.png"), tr(PASTE_SELECTION), this);
connect(actionMap[PASTE_SELECTION], SIGNAL(triggered()), this, SLOT(pasteSelection()));
addAction(actionMap[PASTE_SELECTION]);
actionMap[ZOOM_IN] = new QAction(QIcon(":/icons/zoom-in.png"), tr(ZOOM_IN), this);
connect(actionMap[ZOOM_IN], SIGNAL(triggered()), this, SLOT(zoomIn()));
addAction(actionMap[ZOOM_IN]);
actionMap[ZOOM_OUT] = new QAction(QIcon(":/icons/zoom-out.png"), tr(ZOOM_OUT), this);
connect(actionMap[ZOOM_OUT], SIGNAL(triggered()), this, SLOT(zoomOut()));
addAction(actionMap[ZOOM_OUT]);
actionMap[ZOOM_RESET] = new QAction(QIcon(":/icons/zoom-out.png"), tr(ZOOM_RESET), this);
connect(actionMap[ZOOM_RESET], SIGNAL(triggered()), this, SLOT(zoomReset()));
addAction(actionMap[ZOOM_RESET]);
QAction *act = new QAction(this);
act->setSeparator(true);
addAction(act);
actionMap[CLEAR_TERMINAL] = new QAction(tr(CLEAR_TERMINAL), this);
connect(actionMap[CLEAR_TERMINAL], SIGNAL(triggered()), this, SLOT(clear()));
addAction(actionMap[CLEAR_TERMINAL]);
actionMap[SPLIT_HORIZONTAL] = new QAction(tr(SPLIT_HORIZONTAL), this);
connect(actionMap[SPLIT_HORIZONTAL], SIGNAL(triggered()), this, SLOT(act_splitHorizontal()));
addAction(actionMap[SPLIT_HORIZONTAL]);
actionMap[SPLIT_VERTICAL] = new QAction(tr(SPLIT_VERTICAL), this);
connect(actionMap[SPLIT_VERTICAL], SIGNAL(triggered()), this, SLOT(act_splitVertical()));
addAction(actionMap[SPLIT_VERTICAL]);
actionMap[SUB_COLLAPSE] = new QAction(tr(SUB_COLLAPSE), this);
connect(actionMap[SUB_COLLAPSE], SIGNAL(triggered()), this, SLOT(act_splitCollapse()));
addAction(actionMap[SUB_COLLAPSE]);
//act = new QAction(this);
//act->setSeparator(true);
//addAction(act);
//
//act = new QAction(tr("&Rename session..."), this);
//act->setShortcut(Properties::Instance()->shortcuts[RENAME_SESSION]);
//connect(act, SIGNAL(triggered()), this, SIGNAL(renameSession()));
//addAction(act);
setContextMenuPolicy(Qt::CustomContextMenu);
connect(this, SIGNAL(customContextMenuRequested(const QPoint &)),
this, SLOT(customContextMenuCall(const QPoint &)));
updateShortcuts();
//setKeyBindings("linux");
startShellProgram();
}
/* Mini-toolbar constructor */
VBoxMiniToolBar::VBoxMiniToolBar(QWidget *pParent, Alignment alignment, bool fActive, bool fAutoHide)
: UIToolBar(pParent)
, m_pAutoHideAction(0)
, m_pDisplayLabel(0)
, m_pMinimizeAction(0)
, m_pRestoreAction(0)
, m_pCloseAction(0)
, m_fActive(fActive)
, m_fPolished(false)
, m_fSeamless(false)
, m_fAutoHide(fAutoHide)
, m_fSlideToScreen(true)
, m_fHideAfterSlide(false)
, m_iAutoHideCounter(0)
, m_iPositionX(0)
, m_iPositionY(0)
, m_pInsertPosition(0)
, m_alignment(alignment)
, m_fAnimated(true)
, m_iScrollDelay(10)
, m_iAutoScrollDelay(100)
, m_iAutoHideTotalCounter(10)
{
/* Check parent widget presence: */
AssertMsg(parentWidget(), ("Parent widget must be set!\n"));
/* Toolbar options: */
setIconSize(QSize(16, 16));
setVisible(false);
/* Left margin of tool-bar: */
m_Margins << widgetForAction(addWidget(new QWidget(this)));
/* Add pushpin: */
m_pAutoHideAction = new QAction(this);
m_pAutoHideAction->setIcon(UIIconPool::iconSet(":/pin_16px.png"));
m_pAutoHideAction->setToolTip(tr("Always show the toolbar"));
m_pAutoHideAction->setCheckable(true);
m_pAutoHideAction->setChecked(!m_fAutoHide);
connect(m_pAutoHideAction, SIGNAL(toggled(bool)), this, SLOT(togglePushpin(bool)));
addAction(m_pAutoHideAction);
/* Left menu margin: */
m_Spacings << widgetForAction(addWidget(new QWidget(this)));
/* Right menu margin: */
m_pInsertPosition = addWidget(new QWidget(this));
m_Spacings << widgetForAction(m_pInsertPosition);
/* Left label margin: */
m_LabelMargins << widgetForAction(addWidget(new QWidget(this)));
/* Insert a label for VM Name: */
m_pDisplayLabel = new QLabel(this);
m_pDisplayLabel->setAlignment(Qt::AlignCenter);
addWidget(m_pDisplayLabel);
/* Right label margin: */
m_LabelMargins << widgetForAction(addWidget(new QWidget(this)));
/* Minimize action: */
m_pMinimizeAction = new QAction(this);
m_pMinimizeAction->setIcon(UIIconPool::iconSet(":/minimize_16px.png"));
m_pMinimizeAction->setToolTip(tr("Minimize Window"));
connect(m_pMinimizeAction, SIGNAL(triggered()), this, SIGNAL(minimizeAction()));
addAction(m_pMinimizeAction);
/* Exit action: */
m_pRestoreAction = new QAction(this);
m_pRestoreAction->setIcon(UIIconPool::iconSet(":/restore_16px.png"));
m_pRestoreAction->setToolTip(tr("Exit Full Screen or Seamless Mode"));
connect(m_pRestoreAction, SIGNAL(triggered()), this, SIGNAL(exitAction()));
addAction(m_pRestoreAction);
/* Close action: */
m_pCloseAction = new QAction(this);
m_pCloseAction->setIcon(UIIconPool::iconSet(":/close_16px.png"));
m_pCloseAction->setToolTip(tr("Close VM"));
connect(m_pCloseAction, SIGNAL(triggered()), this, SIGNAL(closeAction()));
addAction(m_pCloseAction);
/* Right margin of tool-bar: */
m_Margins << widgetForAction(addWidget(new QWidget(this)));
/* Event-filter for parent widget to control resize: */
pParent->installEventFilter(this);
/* Enable mouse-tracking for this & children allowing to get mouse-move events: */
setMouseTrackingEnabled(m_fAutoHide);
}
/*
Init our module
*/
void Supernovae::init()
{
try
{
StelFileMgr::makeSureDirExistsAndIsWritable(StelFileMgr::getUserDir()+"/modules/Supernovae");
// If no settings in the main config file, create with defaults
if (!conf->childGroups().contains("Supernovae"))
{
qDebug() << "Supernovae: no Supernovae section exists in main config file - creating with defaults";
restoreDefaultConfigIni();
}
// populate settings from main config file.
readSettingsFromConfig();
sneJsonPath = StelFileMgr::findFile("modules/Supernovae", (StelFileMgr::Flags)(StelFileMgr::Directory|StelFileMgr::Writable)) + "/supernovae.json";
if (sneJsonPath.isEmpty())
return;
texPointer = StelApp::getInstance().getTextureManager().createTexture(StelFileMgr::getInstallationDir()+"/textures/pointeur2.png");
// key bindings and other actions
addAction("actionShow_Supernovae_ConfigDialog", N_("Historical Supernovae"), N_("Historical Supernovae configuration window"), configDialog, "visible");
}
catch (std::runtime_error &e)
{
qWarning() << "Supernovas: init error:" << e.what();
return;
}
// A timer for hiding alert messages
messageTimer = new QTimer(this);
messageTimer->setSingleShot(true); // recurring check for update
messageTimer->setInterval(9000); // 6 seconds should be enough time
messageTimer->stop();
connect(messageTimer, SIGNAL(timeout()), this, SLOT(messageTimeout()));
// If the json file does not already exist, create it from the resource in the Qt resource
if(QFileInfo(sneJsonPath).exists())
{
if (!checkJsonFileFormat() || getJsonFileVersion()<CATALOG_FORMAT_VERSION)
{
restoreDefaultJsonFile();
}
}
else
{
qDebug() << "Supernovae: supernovae.json does not exist - copying default file to" << QDir::toNativeSeparators(sneJsonPath);
restoreDefaultJsonFile();
}
qDebug() << "Supernovae: loading catalog file:" << QDir::toNativeSeparators(sneJsonPath);
readJsonFile();
// Set up download manager and the update schedule
downloadMgr = new QNetworkAccessManager(this);
connect(downloadMgr, SIGNAL(finished(QNetworkReply*)), this, SLOT(updateDownloadComplete(QNetworkReply*)));
updateState = CompleteNoUpdates;
updateTimer = new QTimer(this);
updateTimer->setSingleShot(false); // recurring check for update
updateTimer->setInterval(13000); // check once every 13 seconds to see if it is time for an update
connect(updateTimer, SIGNAL(timeout()), this, SLOT(checkForUpdate()));
updateTimer->start();
GETSTELMODULE(StelObjectMgr)->registerStelObjectMgr(this);
}
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent), ui(new Ui::MainWindowClass)
{
ui->setupUi(this);
ui->view->setScrollBar( ui->scroll );
QIcon icon = QIcon(":/icons/icons/cr3.png");
CRLog::warn("\n\n\n*** ######### application icon %s\n\n\n", icon.isNull() ? "null" : "found");
qApp->setWindowIcon(icon);
addAction(ui->actionOpen);
addAction(ui->actionRecentBooks);
addAction(ui->actionTOC);
addAction(ui->actionToggle_Full_Screen);
addAction(ui->actionSettings);
addAction(ui->actionClose);
addAction(ui->actionToggle_Pages_Scroll);
addAction(ui->actionMinimize);
addAction(ui->actionNextPage);
addAction(ui->actionPrevPage);
addAction(ui->actionNextPage2);
addAction(ui->actionPrevPage2);
addAction(ui->actionNextPage3);
addAction(ui->actionNextLine);
addAction(ui->actionPrevLine);
addAction(ui->actionFirstPage);
addAction(ui->actionLastPage);
addAction(ui->actionBack);
addAction(ui->actionForward);
addAction(ui->actionNextChapter);
addAction(ui->actionPrevChapter);
addAction(ui->actionZoom_In);
addAction(ui->actionZoom_Out);
addAction(ui->actionCopy);
addAction(ui->actionCopy2); // alternative shortcut
addAction(ui->actionAddBookmark);
addAction(ui->actionShowBookmarksList);
addAction(ui->actionToggleEditMode);
addAction(ui->actionNextSentence);
addAction(ui->actionPrevSentence);
#ifdef _LINUX
QString homeDir = QDir::toNativeSeparators(QDir::homePath() + "/.cr3/");
#else
QString homeDir = QDir::toNativeSeparators(QDir::homePath() + "/cr3/");
#endif
#ifdef _LINUX
QString exeDir = QString(CR3_DATA_DIR);
#else
QString exeDir = QDir::toNativeSeparators(qApp->applicationDirPath() + "/"); //QDir::separator();
#endif
QString cacheDir = homeDir + "cache";
QString bookmarksDir = homeDir + "bookmarks";
QString histFile = exeDir + "cr3hist.bmk";
QString histFile2 = homeDir + "cr3hist.bmk";
QString iniFile2 = exeDir + "cr3.ini";
QString iniFile = homeDir + "cr3.ini";
QString cssFile = homeDir + "fb2.css";
QString cssFile2 = exeDir + "fb2.css";
//QString translations = exeDir + "i18n";
//CRLog::info("Translations directory: %s", LCSTR(qt2cr(translations)) );
QString hyphDir = exeDir + "hyph" + QDir::separator();
ui->view->setHyphDir(hyphDir);
ui->view->setHyphDir(homeDir + "hyph" + QDir::separator(), false);
ldomDocCache::init( qt2cr( cacheDir ), DOC_CACHE_SIZE );
ui->view->setPropsChangeCallback( this );
if ( !ui->view->loadSettings( iniFile ) )
ui->view->loadSettings( iniFile2 );
if ( !ui->view->loadHistory( histFile ) )
ui->view->loadHistory( histFile2 );
if ( !ui->view->loadCSS( cssFile ) )
ui->view->loadCSS( cssFile2 );
#if ENABLE_BOOKMARKS_DIR==1
ui->view->setBookmarksDir( bookmarksDir );
#endif
QStringList args( qApp->arguments() );
for ( int i=1; i<args.length(); i++ ) {
if ( args[i].startsWith("--") ) {
// option
} else {
// filename to open
if ( _filenameToOpen.length()==0 )
_filenameToOpen = args[i];
}
}
// QTranslator qtTranslator;
// if (qtTranslator.load("qt_" + QLocale::system().name(),
// QLibraryInfo::location(QLibraryInfo::TranslationsPath)))
// QApplication::installTranslator(&qtTranslator);
//
// QTranslator myappTranslator;
// QString trname = "cr3_" + QLocale::system().name();
// CRLog::info("Using translation file %s from dir %s", UnicodeToUtf8(qt2cr(trname)).c_str(), UnicodeToUtf8(qt2cr(translations)).c_str() );
// if ( myappTranslator.load(trname, translations) )
// QApplication::installTranslator(&myappTranslator);
ui->view->restoreWindowPos( this, "main.", true );
}
BBEditor::BBEditor( BBTrackContainer* tc ) :
Editor(false),
m_trackContainerView( new BBTrackContainerView(tc) )
{
setWindowIcon( embed::getIconPixmap( "bb_track_btn" ) );
setWindowTitle( tr( "Beat+Bassline Editor" ) );
setCentralWidget(m_trackContainerView);
setAcceptDrops(true);
m_toolBar->setAcceptDrops(true);
connect(m_toolBar, SIGNAL(dragEntered(QDragEnterEvent*)), m_trackContainerView, SLOT(dragEnterEvent(QDragEnterEvent*)));
connect(m_toolBar, SIGNAL(dropped(QDropEvent*)), m_trackContainerView, SLOT(dropEvent(QDropEvent*)));
// TODO: Use style sheet
if( ConfigManager::inst()->value( "ui",
"compacttrackbuttons" ).toInt() )
{
setMinimumWidth( TRACK_OP_WIDTH_COMPACT + DEFAULT_SETTINGS_WIDGET_WIDTH_COMPACT
+ 2 * TCO_BORDER_WIDTH + 264 );
}
else
{
setMinimumWidth( TRACK_OP_WIDTH + DEFAULT_SETTINGS_WIDGET_WIDTH
+ 2 * TCO_BORDER_WIDTH + 264 );
}
m_playAction->setToolTip(tr( "Play/pause current beat/bassline (Space)" ));
m_stopAction->setToolTip(tr( "Stop playback of current beat/bassline (Space)" ));
m_playAction->setWhatsThis(
tr( "Click here to play the current "
"beat/bassline. The beat/bassline is automatically "
"looped when its end is reached." ) );
m_stopAction->setWhatsThis(
tr( "Click here to stop playing of current "
"beat/bassline." ) );
// Beat selector
DropToolBar *beatSelectionToolBar = addDropToolBarToTop(tr("Beat selector"));
m_bbComboBox = new ComboBox( m_toolBar );
m_bbComboBox->setFixedSize( 200, 22 );
m_bbComboBox->setModel( &tc->m_bbComboBoxModel );
beatSelectionToolBar->addWidget( m_bbComboBox );
// Track actions
DropToolBar *trackAndStepActionsToolBar = addDropToolBarToTop(tr("Track and step actions"));
trackAndStepActionsToolBar->addAction(embed::getIconPixmap("add_bb_track"), tr("Add beat/bassline"),
Engine::getSong(), SLOT(addBBTrack()));
trackAndStepActionsToolBar->addAction(embed::getIconPixmap("add_automation"), tr("Add automation-track"),
m_trackContainerView, SLOT(addAutomationTrack()));
QWidget* stretch = new QWidget(m_toolBar);
stretch->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
trackAndStepActionsToolBar->addWidget(stretch);
// Step actions
trackAndStepActionsToolBar->addAction(embed::getIconPixmap("step_btn_remove"), tr("Remove steps"),
m_trackContainerView, SLOT(removeSteps()));
trackAndStepActionsToolBar->addAction(embed::getIconPixmap("step_btn_add"), tr("Add steps"),
m_trackContainerView, SLOT( addSteps()));
trackAndStepActionsToolBar->addAction( embed::getIconPixmap( "step_btn_duplicate" ), tr( "Clone Steps" ),
m_trackContainerView, SLOT( cloneSteps() ) );
connect( &tc->m_bbComboBoxModel, SIGNAL( dataChanged() ),
m_trackContainerView, SLOT( updatePosition() ) );
QAction* viewNext = new QAction(this);
connect(viewNext, SIGNAL(triggered()), m_bbComboBox, SLOT(selectNext()));
viewNext->setShortcut(Qt::Key_Plus);
addAction(viewNext);
QAction* viewPrevious = new QAction(this);
connect(viewPrevious, SIGNAL(triggered()), m_bbComboBox, SLOT(selectPrevious()));
viewPrevious->setShortcut(Qt::Key_Minus);
addAction(viewPrevious);
}
void DkCropToolBar::createLayout() {
QList<QKeySequence> enterSc;
enterSc.append(QKeySequence(Qt::Key_Enter));
enterSc.append(QKeySequence(Qt::Key_Return));
QAction* cropAction = new QAction(mIcons[crop_icon], tr("Crop (ENTER)"), this);
cropAction->setShortcuts(enterSc);
cropAction->setObjectName("cropAction");
QAction* cancelAction = new QAction(mIcons[cancel_icon], tr("Cancel (ESC)"), this);
cancelAction->setShortcut(QKeySequence(Qt::Key_Escape));
cancelAction->setObjectName("cancelAction");
mPanAction = new QAction(mIcons[pan_icon], tr("Pan"), this);
mPanAction->setShortcut(QKeySequence(Qt::Key_P));
mPanAction->setObjectName("panAction");
mPanAction->setCheckable(true);
mPanAction->setChecked(false);
QStringList ratios;
ratios << "1:1" << "4:3" << "5:4" << "14:10" << "14:11" << "16:9" << "16:10";
ratios.prepend(tr("User Defined"));
ratios.prepend(tr("No Aspect Ratio"));
mRatioBox = new QComboBox(this);
mRatioBox->addItems(ratios);
mRatioBox->setObjectName("ratioBox");
mHorValBox = new QDoubleSpinBox(this);
mHorValBox->setObjectName("horValBox");
mHorValBox->setSpecialValueText(" ");
mHorValBox->setToolTip(tr("Horizontal Constraint"));
mHorValBox->setStatusTip(mHorValBox->toolTip());
QAction* swapAction = new QAction(QIcon(":/nomacs/img/swap.svg"), tr("Swap"), this);
swapAction->setObjectName("swapAction");
swapAction->setToolTip(tr("Swap Dimensions"));
swapAction->setStatusTip(swapAction->toolTip());
mVerValBox = new QDoubleSpinBox(this);
mVerValBox->setObjectName("verValBox");
mVerValBox->setSpecialValueText(" ");
mHorValBox->setToolTip(tr("Vertical Constraint"));
mHorValBox->setStatusTip(mHorValBox->toolTip());
mAngleBox = new QDoubleSpinBox(this);
mAngleBox->setObjectName("angleBox");
mAngleBox->setSuffix(dk_degree_str);
mAngleBox->setMinimum(-180);
mAngleBox->setMaximum(180);
// background color
mBgCol = QColor(0,0,0,0);
mBgColButton = new QPushButton(this);
mBgColButton->setObjectName("bgColButton");
mBgColButton->setStyleSheet("QPushButton {background-color: " + DkUtils::colorToString(mBgCol) + "; border: 1px solid #888;}");
mBgColButton->setToolTip(tr("Background Color"));
mBgColButton->setStatusTip(mBgColButton->toolTip());
mColorDialog = new QColorDialog(this);
mColorDialog->setObjectName("colorDialog");
mColorDialog->setOption(QColorDialog::ShowAlphaChannel, true);
// crop customization
QStringList guides;
guides << tr("Guides") << tr("Rule of Thirds") << tr("Grid");
mGuideBox = new QComboBox(this);
mGuideBox->addItems(guides);
mGuideBox->setObjectName("guideBox");
mGuideBox->setToolTip(tr("Show Guides in the Preview"));
mGuideBox->setStatusTip(mGuideBox->toolTip());
mInvertAction = new QAction(mIcons[invert_icon], tr("Invert Crop Tool Color"), this);
mInvertAction->setObjectName("invertAction");
mInvertAction->setCheckable(true);
mInvertAction->setChecked(false);
mInfoAction = new QAction(mIcons[info_icon], tr("Show Info"), this);
mInfoAction->setObjectName("infoAction");
mInfoAction->setCheckable(true);
mInfoAction->setChecked(false);
addAction(cropAction);
addAction(mPanAction);
addAction(cancelAction);
addSeparator();
addWidget(mRatioBox);
addWidget(mHorValBox);
addAction(swapAction);
addWidget(mVerValBox);
addWidget(mAngleBox);
addSeparator();
addWidget(mBgColButton);
addSeparator();
addWidget(mGuideBox);
addAction(mInvertAction);
addAction(mInfoAction);
}
void MainWindow::addSoftKeys()
{
addAction(ok);
addAction(cancel);
}
void MSAOverviewContextMenu::initSimpleOverviewAction() {
showSimpleOverviewAction = createCheckableAction(tr("Show simple overview"));
showSimpleOverviewAction->setObjectName("Show simple overview");
showSimpleOverviewAction->setChecked( simpleOverview->isVisible() );
addAction(showSimpleOverviewAction);
}
/*!
\overload
Creates a new action with the given \a icon and \a text. This
action is added to the end of the toolbar.
*/
QAction *QToolBar::addAction(const QIcon &icon, const QString &text)
{
QAction *action = new QAction(icon, text, this);
addAction(action);
return action;
}
LifeWidget::LifeWidget(QWidget *parent, int nbCases)
: QGLWidget(QGLFormat(QGL::SampleBuffers), parent)
{
assert(nbCases);
showGrid = true;
refreshTimer.setSingleShot(false);
connect(&refreshTimer, SIGNAL(timeout()), this, SLOT(update()));
refreshTimer.start(15);
setAttribute(Qt::WA_NoSystemBackground);
setMinimumSize(320, 320);
setWindowTitle("LifeGame");
mouseX = 0.0;
mouseY = 0.0;
posX = 0;
posY = 0;
setMouseTracking(true);
this->nbCases = nbCases;
lifeGame = new LifeGame(this->nbCases);
toggleFullScreenAction = new QAction(this);
toggleFullScreenAction->setShortcutContext(Qt::ApplicationShortcut);
toggleFullScreenAction->setCheckable(true);
toggleFullScreenAction->setShortcut(Qt::Key_Return | Qt::AltModifier);
connect(toggleFullScreenAction, SIGNAL(triggered(bool)),
this, SLOT(toggleFullScreen(bool)));
toggleGridAction = new QAction(this);
toggleGridAction->setShortcutContext(Qt::ApplicationShortcut);
toggleGridAction->setCheckable(true);
toggleGridAction->setShortcut(Qt::Key_G | Qt::AltModifier);
connect(toggleGridAction, SIGNAL(triggered(bool)),
this, SLOT(toggleGrid(bool)));
nextGenerationAction = new QAction(this);
nextGenerationAction->setShortcutContext(Qt::ApplicationShortcut);
nextGenerationAction->setShortcut(Qt::Key_Plus);
connect(nextGenerationAction, SIGNAL(triggered()),
this, SLOT(computeNextGeneration()));
clearGameAction = new QAction(this);
clearGameAction->setShortcutContext(Qt::ApplicationShortcut);
clearGameAction->setShortcut(Qt::Key_Asterisk);
connect(clearGameAction, SIGNAL(triggered()),
this, SLOT(clearGameTable()));
addAction(toggleFullScreenAction);
addAction(toggleGridAction);
addAction(nextGenerationAction);
addAction(clearGameAction);
gameHud = new QtHud(this);
QFont font;
font.setFamily("Lucida Console");
font.setPixelSize(14);
font.setBold(true);
gameHud->setFont(font);
gameHud->setForeColor(QColor::fromRgb(0, 255, 127));
}
EditStaff::EditStaff(Staff* s, int /*tick*/, QWidget* parent)
: QDialog(parent)
{
orgStaff = s;
setupUi(this);
setWindowFlags(this->windowFlags() & ~Qt::WindowContextHelpButtonHint);
setModal(true);
const QIcon &editIcon = *icons[int(Icons::edit_ICON)];
minPitchASelect->setIcon(editIcon);
maxPitchASelect->setIcon(editIcon);
minPitchPSelect->setIcon(editIcon);
maxPitchPSelect->setIcon(editIcon);
Part* part = orgStaff->part();
instrument = *part->instrument(/*tick*/);
Score* score = part->score();
staff = new Staff(score);
staff->setSmall(orgStaff->small());
staff->setInvisible(orgStaff->invisible());
staff->setUserDist(orgStaff->userDist());
staff->setColor(orgStaff->color());
staff->setStaffType(orgStaff->staffType());
staff->setPart(part);
staff->setCutaway(orgStaff->cutaway());
staff->setHideWhenEmpty(orgStaff->hideWhenEmpty());
staff->setShowIfEmpty(orgStaff->showIfEmpty());
staff->setUserMag(orgStaff->userMag());
staff->setHideSystemBarLine(orgStaff->hideSystemBarLine());
// get tick range for instrument
auto i = part->instruments()->upper_bound(0); // tick
if (i == part->instruments()->end())
_tickEnd = -1;
else
_tickEnd = i->first;
#if 1
_tickStart = -1;
#else
--i;
if (i == part->instruments()->begin())
_tickStart = 0;
else
_tickStart = i->first;
#endif
// set dlg controls
spinExtraDistance->setValue(s->userDist() / score->spatium());
invisible->setChecked(staff->invisible());
small->setChecked(staff->small());
color->setColor(s->color());
partName->setText(part->partName());
cutaway->setChecked(staff->cutaway());
hideMode->setCurrentIndex(int(staff->hideWhenEmpty()));
showIfEmpty->setChecked(staff->showIfEmpty());
hideSystemBarLine->setChecked(staff->hideSystemBarLine());
mag->setValue(staff->userMag() * 100.0);
updateStaffType();
updateInstrument();
if (!useFactorySettings) {
QSettings settings;
settings.beginGroup("EditStaff");
resize(settings.value("size", QSize(484, 184)).toSize());
move(settings.value("pos", QPoint(10, 10)).toPoint());
settings.endGroup();
}
connect(buttonBox, SIGNAL(clicked(QAbstractButton*)), SLOT(bboxClicked(QAbstractButton*)));
connect(changeInstrument, SIGNAL(clicked()), SLOT(showInstrumentDialog()));
connect(changeStaffType, SIGNAL(clicked()), SLOT(showStaffTypeDialog()));
connect(minPitchASelect, SIGNAL(clicked()), SLOT(minPitchAClicked()));
connect(maxPitchASelect, SIGNAL(clicked()), SLOT(maxPitchAClicked()));
connect(minPitchPSelect, SIGNAL(clicked()), SLOT(minPitchPClicked()));
connect(maxPitchPSelect, SIGNAL(clicked()), SLOT(maxPitchPClicked()));
connect(editStringData, SIGNAL(clicked()), SLOT(editStringDataClicked()));
connect(lines, SIGNAL(valueChanged(int)), SLOT(numOfLinesChanged()));
connect(lineDistance, SIGNAL(valueChanged(double)), SLOT(lineDistanceChanged()));
connect(showClef, SIGNAL(clicked()), SLOT(showClefChanged()));
connect(showTimesig, SIGNAL(clicked()), SLOT(showTimeSigChanged()));
connect(showBarlines, SIGNAL(clicked()), SLOT(showBarlinesChanged()));
addAction(getAction("local-help")); // why is this needed?
}
StoragePoolToolBar::StoragePoolToolBar(QWidget *parent) :
QToolBar(parent)
{
start_Action = new QAction(this);
start_Action->setIcon(QIcon::fromTheme("start"));
start_Action->setToolTip("Start");
destroy_Action = new QAction(this);
destroy_Action->setIcon(QIcon::fromTheme("destroy"));
destroy_Action->setToolTip("Stop");
create_Action = new QAction(this);
create_Action->setIcon(QIcon::fromTheme("create"));
create_Action->setToolTip("Create for once usage");
create_Menu = new OpenFileMenu(this, "create", "storagePool");
create_Action->setMenu(create_Menu);
connect(create_Action, SIGNAL(triggered()), this, SLOT(showMenu()));
define_Action = new QAction(this);
define_Action->setIcon(QIcon::fromTheme("define"));
define_Action->setToolTip("Define for persistent usage");
define_Menu = new OpenFileMenu(this, "define", "storagePool");
define_Action->setMenu(define_Menu);
connect(define_Action, SIGNAL(triggered()), this, SLOT(showMenu()));
undefine_Action = new QAction(this);
undefine_Action->setIcon(QIcon::fromTheme("undefine"));
undefine_Action->setToolTip("Undefine");
setAutostart_Action = new QAction(this);
setAutostart_Action->setIcon(QIcon::fromTheme("autostart"));
setAutostart_Action->setToolTip("Change AutoStart State");
delete_Menu = new Delete_Pool_Menu(this);
delete_Action = new QAction(this);
delete_Action->setIcon(QIcon::fromTheme("delete"));
delete_Action->setToolTip("Delete");
delete_Action->setMenu(delete_Menu);
getXMLDesc_Action = new QAction(this);
getXMLDesc_Action->setIcon(QIcon::fromTheme("application-xml"));
getXMLDesc_Action->setToolTip("Get XML Description");
overview_Action = new QAction(this);
overview_Action->setIcon(QIcon::fromTheme("overview"));
overview_Action->setToolTip("Overview Pool");
_autoReload = new QPushButton(this);
_autoReload->setToolTip("AutoReload Pool Overview");
_autoReload->setIcon(QIcon::fromTheme("view-refresh"));
_autoReload->setCheckable(true);
addAction(start_Action);
addAction(destroy_Action);
addSeparator();
addAction(create_Action);
addAction(define_Action);
addAction(undefine_Action);
//addSeparator();
addAction(setAutostart_Action);
addAction(delete_Action);
addSeparator();
addAction(getXMLDesc_Action);
addSeparator();
addAction(overview_Action);
addSeparator();
autoReload = addWidget(_autoReload);
addAction(autoReload);
settings.beginGroup("VirtStoragePoolControl");
interval = settings.value("UpdateTime", 3).toInt();
_autoReload->setChecked(settings.value("AutoReload", false).toBool());
settings.endGroup();
connect(_autoReload, SIGNAL(toggled(bool)), this, SLOT(changeAutoReloadState(bool)));
connect(create_Menu, SIGNAL(fileForMethod(QStringList&)),
this, SLOT(repeatParameters(QStringList&)));
connect(define_Menu, SIGNAL(fileForMethod(QStringList&)),
this, SLOT(repeatParameters(QStringList&)));
connect(delete_Menu, SIGNAL(execMethod(const QStringList&)),
this, SIGNAL(execMethod(const QStringList&)));
connect(this, SIGNAL(actionTriggered(QAction*)),
this, SLOT(detectTriggerredAction(QAction*)));
}
void modelUavoProxy::modelToObjects()
{
PathAction * act=NULL;
Waypoint * wp=NULL;
QModelIndex index;
double distance;
double bearing;
double altitude;
int lastaction=-1;
for(int x=0;x<myModel->rowCount();++x)
{
int instances=objManager->getNumInstances(waypointObj->getObjID());
if(x>instances-1)
{
wp=new Waypoint;
wp->initialize(x,wp->getMetaObject());
objManager->registerObject(wp);
}
else
{
wp=Waypoint::GetInstance(objManager,x);
}
act=new PathAction;
Q_ASSERT(act);
Q_ASSERT(wp);
Waypoint::DataFields waypoint = wp->getData();
PathAction::DataFields action = act->getData();
///Waypoint object data
index=myModel->index(x,flightDataModel::DISRELATIVE);
distance=myModel->data(index).toDouble();
index=myModel->index(x,flightDataModel::BEARELATIVE);
bearing=myModel->data(index).toDouble();
index=myModel->index(x,flightDataModel::ALTITUDERELATIVE);
altitude=myModel->data(index).toFloat();
index=myModel->index(x,flightDataModel::VELOCITY);
waypoint.Velocity=myModel->data(index).toFloat();
waypoint.Position[Waypoint::POSITION_NORTH]=distance*cos(bearing/180*M_PI);
waypoint.Position[Waypoint::POSITION_EAST]=distance*sin(bearing/180*M_PI);
waypoint.Position[Waypoint::POSITION_DOWN]=(-1.0f)*altitude;
///PathAction object data
index=myModel->index(x,flightDataModel::MODE);
action.Mode=myModel->data(index).toInt();
index=myModel->index(x,flightDataModel::MODE_PARAMS0);
action.ModeParameters[0]=myModel->data(index).toFloat();
index=myModel->index(x,flightDataModel::MODE_PARAMS1);
action.ModeParameters[1]=myModel->data(index).toFloat();
index=myModel->index(x,flightDataModel::MODE_PARAMS2);
action.ModeParameters[2]=myModel->data(index).toFloat();
index=myModel->index(x,flightDataModel::MODE_PARAMS3);
action.ModeParameters[3]=myModel->data(index).toFloat();
index=myModel->index(x,flightDataModel::CONDITION);
action.EndCondition=myModel->data(index).toInt();
index=myModel->index(x,flightDataModel::CONDITION_PARAMS0);
action.ConditionParameters[0]=myModel->data(index).toFloat();
index=myModel->index(x,flightDataModel::CONDITION_PARAMS1);
action.ConditionParameters[1]=myModel->data(index).toFloat();
index=myModel->index(x,flightDataModel::CONDITION_PARAMS2);
action.ConditionParameters[2]=myModel->data(index).toFloat();
index=myModel->index(x,flightDataModel::CONDITION_PARAMS3);
action.ConditionParameters[3]=myModel->data(index).toFloat();
index=myModel->index(x,flightDataModel::COMMAND);
action.Command=myModel->data(index).toInt();
index=myModel->index(x,flightDataModel::JUMPDESTINATION);
action.JumpDestination=myModel->data(index).toInt()-1;
index=myModel->index(x,flightDataModel::ERRORDESTINATION);
action.ErrorDestination=myModel->data(index).toInt()-1;
int actionNumber=addAction(act,action,lastaction);
if(actionNumber>lastaction)
lastaction=actionNumber;
waypoint.Action=actionNumber;
wp->setData(waypoint);
wp->updated();
}
}
MainWindow::MainWindow( const QStringList &_params )
: QWidget()
, cardsGroup( new QActionGroup( this ) )
, quitOnClose( false )
{
setAttribute( Qt::WA_DeleteOnClose, true );
setupUi( this );
cards->hide();
cards->hack();
languages->hack();
setWindowFlags( Qt::Window | Qt::CustomizeWindowHint | Qt::WindowMinimizeButtonHint );
#if QT_VERSION >= 0x040500
setWindowFlags( windowFlags() | Qt::WindowCloseButtonHint );
#else
setWindowFlags( windowFlags() | Qt::WindowSystemMenuHint );
#endif
Settings s;
// Mobile
infoMobileCode->setValidator( new IKValidator( infoMobileCode ) );
infoMobileCode->setText( s.value( "Client/MobileCode" ).toString() );
infoMobileCell->setText( s.value( "Client/MobileNumber", "+372" ).toString() );
connect( infoMobileCode, SIGNAL(textEdited(QString)), SLOT(enableSign()) );
connect( infoMobileCell, SIGNAL(textEdited(QString)), SLOT(enableSign()) );
connect( infoSignMobile, SIGNAL(toggled(bool)), SLOT(showCardStatus()) );
// Buttons
QButtonGroup *buttonGroup = new QButtonGroup( this );
buttonGroup->addButton( settings, HeadSettings );
buttonGroup->addButton( help, HeadHelp );
buttonGroup->addButton( about, HeadAbout );
buttonGroup->addButton( homeSign, HomeSign );
buttonGroup->addButton( homeView, HomeView );
buttonGroup->addButton( homeCrypt, HomeCrypt );
introNext = introButtons->addButton( tr( "Next" ), QDialogButtonBox::ActionRole );
buttonGroup->addButton( introNext, IntroNext );
buttonGroup->addButton( introButtons->button( QDialogButtonBox::Cancel ), IntroBack );
signButton = signButtons->addButton( tr("Sign"), QDialogButtonBox::AcceptRole );
buttonGroup->addButton( signButton, SignSign );
buttonGroup->addButton( signButtons->button( QDialogButtonBox::Cancel ), SignCancel );
viewAddSignature = viewButtons->addButton( tr("Add signature"), QDialogButtonBox::ActionRole );
buttonGroup->addButton( viewAddSignature, ViewAddSignature );
buttonGroup->addButton( viewButtons->button( QDialogButtonBox::Close ), ViewClose );
connect( buttonGroup, SIGNAL(buttonClicked(int)),
SLOT(buttonClicked(int)) );
connect( infoCard, SIGNAL(linkActivated(QString)), SLOT(parseLink(QString)) );
connect( cards, SIGNAL(activated(QString)), qApp->signer(), SLOT(selectCard(QString)), Qt::QueuedConnection );
connect( qApp, SIGNAL(dataChanged()), SLOT(showCardStatus()) );
// Digidoc
doc = new DigiDoc( this );
// Translations
lang << "et" << "en" << "ru";
QString deflang;
switch( QLocale().language() )
{
case QLocale::English: deflang = "en"; break;
case QLocale::Russian: deflang = "ru"; break;
case QLocale::Estonian:
default: deflang = "et"; break;
}
on_languages_activated( lang.indexOf(
s.value( "Main/Language", deflang ).toString() ) );
QActionGroup *langGroup = new QActionGroup( this );
QAction *etAction = langGroup->addAction( new QAction( langGroup ) );
QAction *enAction = langGroup->addAction( new QAction( langGroup ) );
QAction *ruAction = langGroup->addAction( new QAction( langGroup ) );
etAction->setData( 0 );
enAction->setData( 1 );
ruAction->setData( 2 );
etAction->setShortcut( Qt::CTRL + Qt::SHIFT + Qt::Key_1 );
enAction->setShortcut( Qt::CTRL + Qt::SHIFT + Qt::Key_2 );
ruAction->setShortcut( Qt::CTRL + Qt::SHIFT + Qt::Key_3 );
addAction( etAction );
addAction( enAction );
addAction( ruAction );
connect( langGroup, SIGNAL(triggered(QAction*)), SLOT(changeLang(QAction*)) );
connect( cardsGroup, SIGNAL(triggered(QAction*)), SLOT(changeCard(QAction*)) );
// Views
signContentView->setColumnHidden( 2, true );
viewContentView->setColumnHidden( 3, true );
connect( signContentView, SIGNAL(remove(unsigned int)),
SLOT(removeDocument(unsigned int)) );
connect( viewContentView, SIGNAL(remove(unsigned int)),
SLOT(removeDocument(unsigned int)) );
if( !_params.empty() )
{
quitOnClose = true;
params = _params;
buttonClicked( HomeSign );
}
}
VolumeRenderWidget::VolumeRenderWidget(QWidget *parent)
:m_renderMode(0), QWidget(parent)
{
m_openGLWidget = new QVTKOpenGLWidget(this);
vtkNew<vtkGenericOpenGLRenderWindow> renderWindow;
m_openGLWidget->SetRenderWindow(renderWindow);
m_renderer = vtkSmartPointer<vtkOpenGLRenderer>::New();
m_renderer->BackingStoreOn();
renderWindow->AddRenderer(m_renderer);
renderWindow->Render(); // making opengl context
vtkSmartPointer<vtkVolumeProperty> volumeProperty = vtkSmartPointer<vtkVolumeProperty>::New();
vtkSmartPointer<vtkColorTransferFunction> colorFun = vtkSmartPointer<vtkColorTransferFunction>::New();
vtkSmartPointer<vtkPiecewiseFunction> opacityFun = vtkSmartPointer<vtkPiecewiseFunction>::New();
vtkSmartPointer<vtkPiecewiseFunction> gradientFun = vtkSmartPointer<vtkPiecewiseFunction>::New();
volumeProperty->SetColor(colorFun);
volumeProperty->SetScalarOpacity(opacityFun);
volumeProperty->SetGradientOpacity(gradientFun);
volumeProperty->ShadeOn();
volumeProperty->SetInterpolationTypeToLinear();
volumeProperty->SetAmbient(0.6);
volumeProperty->SetDiffuse(0.9);
volumeProperty->SetSpecular(0.5);
volumeProperty->SetSpecularPower(10.0);
//volumeProperty->IndependentComponentsOff();
m_settingsWidget = new VolumeRenderSettingsWidget(volumeProperty, this);
connect(this, &VolumeRenderWidget::imageDataChanged, m_settingsWidget, &VolumeRenderSettingsWidget::setImage);
connect(m_settingsWidget, &VolumeRenderSettingsWidget::propertyChanged, this, &VolumeRenderWidget::updateRendering);
connect(m_settingsWidget, &VolumeRenderSettingsWidget::renderModeChanged, this, &VolumeRenderWidget::setRenderMode);
connect(m_settingsWidget, &VolumeRenderSettingsWidget::cropPlanesChanged, this, &VolumeRenderWidget::setCropPlanes);
auto layout = new QVBoxLayout;
layout->setContentsMargins(0, 0, 0, 0);
layout->addWidget(m_openGLWidget);
this->setLayout(layout);
//adding orientation prop
m_orientationProp = std::make_shared<OrientationActorContainer>();
auto orientationPropPtr = std::static_pointer_cast<VolumeActorContainer>(m_orientationProp).get();
m_volumeProps.push_back(orientationPropPtr);
m_renderer->AddActor(m_orientationProp->getActor());
//window settings
m_renderer->SetBackground(0, 0, 0);
auto menuIcon = QIcon(QString("resources/icons/settings.svg"));
auto menuButton = new QPushButton(menuIcon, QString(), m_openGLWidget);
menuButton->setIconSize(QSize(24, 24));
menuButton->setStyleSheet("QPushButton {background-color:transparent;}");
auto menu = new QMenu(menuButton);
menuButton->setMenu(menu);
auto showAdvancedAction = menu->addAction(tr("Advanced"));
connect(showAdvancedAction, &QAction::triggered, m_settingsWidget, &VolumeRenderSettingsWidget::toggleVisibility);
auto showGrapicsAction = menu->addAction(tr("Show graphics"));
showGrapicsAction->setCheckable(true);
showGrapicsAction->setChecked(true);
connect(showGrapicsAction, &QAction::toggled, this, &VolumeRenderWidget::setActorsVisible);
menu->addAction(QString(tr("Set background color")), [=]() {
auto color = QColorDialog::getColor(Qt::black, this);
if (color.isValid())
m_renderer->SetBackground(color.redF(), color.greenF(), color.blueF());
updateRendering();
});
menu->addAction(QString(tr("Save image to file")), [=]() {
auto filename = QFileDialog::getSaveFileName(this, tr("Save File"), "untitled.png", tr("Images (*.png)"));
if (!filename.isEmpty())
{
auto renderWindow = m_openGLWidget->GetRenderWindow();
vtkSmartPointer<vtkWindowToImageFilter> windowToImageFilter =
vtkSmartPointer<vtkWindowToImageFilter>::New();
windowToImageFilter->SetInput(renderWindow);
windowToImageFilter->SetScale(3, 3); //set the resolution of the output image (3 times the current resolution of vtk render window)
windowToImageFilter->SetInputBufferTypeToRGBA(); //also record the alpha (transparency) channel
windowToImageFilter->ReadFrontBufferOff(); // read from the back buffer
windowToImageFilter->Update();
vtkSmartPointer<vtkPNGWriter> writer =
vtkSmartPointer<vtkPNGWriter>::New();
writer->SetFileName(filename.toLatin1().data());
writer->SetInputConnection(windowToImageFilter->GetOutputPort());
writer->Write();
}
});
}
ViewerToolBar::ViewerToolBar(QWidget *parent) :
QToolBar(parent)
{
downloadIsCompleted = true;
//start_Action = new QAction(this);
//start_Action->setIcon(QIcon::fromTheme("start"));
//start_Action->setToolTip(tr("Start"));
//start_Menu = new QMenu(this);
//restore_Action = start_Menu->addAction(tr("Restore"));
//restore_Action->setIcon(QIcon::fromTheme("start"));
//start_Action->setMenu(start_Menu);
pause_Action = new QAction(this);
pause_Action->setIcon(QIcon::fromTheme("pause"));
pause_Action->setToolTip(tr("Pause"));
destroy_Menu = new QMenu(this);
reboot_Action = destroy_Menu->addAction(tr("Reboot"));
reboot_Action->setIcon(QIcon::fromTheme("reboot"));
reset_Action = destroy_Menu->addAction(tr("Reset"));
reset_Action->setIcon(QIcon::fromTheme("reset"));
destroy_Menu->addSeparator();
shutdown_Action = destroy_Menu->addAction(tr("Shutdown"));
shutdown_Action->setIcon(QIcon::fromTheme("shutdown"));
save_Action = destroy_Menu->addAction(tr("Save"));
save_Action->setIcon(QIcon::fromTheme("save"));
destroy_Action = new QAction(this);
destroy_Action->setIcon(QIcon::fromTheme("destroy"));
destroy_Action->setToolTip(tr("Stop"));
destroy_Action->setMenu(destroy_Menu);
snapshot_Menu = new QMenu(this);
createSnapshot = snapshot_Menu->addAction(
tr("create Snapshot of Current Domain"));
createSnapshot->setIcon(QIcon::fromTheme("camera-photo"));
moreSnapshot_Actions = snapshot_Menu->addAction(
tr("more Snapshot actions for Domain"));
moreSnapshot_Actions->setIcon(QIcon::fromTheme("camera-photo"));
snapshot_Action = new QAction(this);
snapshot_Action->setIcon(QIcon::fromTheme("camera-photo"));
snapshot_Action->setToolTip(tr("Snapshot now!"));
snapshot_Action->setMenu(snapshot_Menu);
reconnect_Action = new QAction(this);
reconnect_Action->setIcon(QIcon::fromTheme("view-refresh"));
reconnect_Action->setToolTip(tr("Reconnect"));
keySeq_Action = new QAction(this);
keySeq_Action->setIcon(QIcon::fromTheme("input-keyboard"));
keySeq_Action->setToolTip(tr("Send key sequence"));
keySequenceMenu = new QMenu(this);
keySeq_Action->setMenu(keySequenceMenu);
sendKeySeq_BackSpc = keySequenceMenu->addAction("Ctrl+Alt+BackSpace");
sendKeySeq_Del = keySequenceMenu->addAction("Ctrl+Alt+Del");
keySequenceMenu->addSeparator();
sendKeySeq_1 = keySequenceMenu->addAction("Ctrl+Alt+F1");
sendKeySeq_2 = keySequenceMenu->addAction("Ctrl+Alt+F2");
sendKeySeq_3 = keySequenceMenu->addAction("Ctrl+Alt+F3");
sendKeySeq_4 = keySequenceMenu->addAction("Ctrl+Alt+F4");
sendKeySeq_5 = keySequenceMenu->addAction("Ctrl+Alt+F5");
sendKeySeq_6 = keySequenceMenu->addAction("Ctrl+Alt+F6");
sendKeySeq_7 = keySequenceMenu->addAction("Ctrl+Alt+F7");
sendKeySeq_8 = keySequenceMenu->addAction("Ctrl+Alt+F8");
keySequenceMenu->addSeparator();
getScreenshot = keySequenceMenu->addAction(tr("get Guest Screenshot"));
copyFiles_Action = new QAction(this);
copyFiles_Action->setIcon(QIcon::fromTheme("document-send"));
copyFiles_Action->setToolTip(tr("Copy Files to Guest"));
copyToClipboard = new QAction(this);
copyToClipboard->setIcon(QIcon::fromTheme("edit-copy"));
copyToClipboard->setToolTip(tr("Copy from Guest to Clipboard"));
pasteClipboard = new QAction(this);
pasteClipboard->setIcon(QIcon::fromTheme("edit-paste"));
pasteClipboard->setToolTip(tr("Paste Clipboard to Guest"));
fullScreen = new QAction(this);
fullScreen->setIcon(QIcon::fromTheme("fullscreen"));
fullScreen->setToolTip(tr("FullScreen"));
scaled_to = new QAction(this);
scaled_to->setIcon(QIcon::fromTheme("scaled_to_window"));
scaled_to->setToolTip(tr("Scale to window"));
vm_stateWdg = new VM_State_Widget(this);
//addAction(start_Action);
addAction(pause_Action);
addAction(destroy_Action);
sep1 = addSeparator();
addAction(snapshot_Action);
sep2 = addSeparator();
addAction(reconnect_Action);
addSeparator();
addAction(keySeq_Action);
addAction(copyFiles_Action);
addAction(copyToClipboard);
addAction(pasteClipboard);
addSeparator();
addAction(fullScreen);
addAction(scaled_to);
addSeparator();
stateWdg_Action = addWidget(vm_stateWdg);
connect(this, SIGNAL(actionTriggered(QAction*)),
this, SLOT(detectTriggeredAction(QAction*)));
setContentsMargins(0,0,0,0);
}
/** Initialyse Stacked Page*/
void MainWindow::initStackedPage()
{
/* WORK OUT IF WE"RE IN ADVANCED MODE OR NOT */
bool advancedMode = false;
std::string advsetting;
if (rsConfig->getConfigurationOption(RS_CONFIG_ADVANCED, advsetting) && (advsetting == "YES")) {
advancedMode = true;
}
QList<QPair<MainPage*, QPair<QAction*, QListWidgetItem*> > > notify;
/* Create the Main pages and actions */
QActionGroup *grp = new QActionGroup(this);
addPage(newsFeed = new NewsFeed(ui->stackPages), grp, ¬ify);
addPage(friendsDialog = new FriendsDialog(ui->stackPages), grp, ¬ify);
#ifdef RS_USE_CIRCLES
PeopleDialog *peopleDialog = NULL;
addPage(peopleDialog = new PeopleDialog(ui->stackPages), grp, ¬ify);
#endif
IdDialog *idDialog = NULL;
addPage(idDialog = new IdDialog(ui->stackPages), grp, ¬ify);
#ifdef RS_USE_CIRCLES
CirclesDialog *circlesDialog = NULL;
addPage(circlesDialog = new CirclesDialog(ui->stackPages), grp, ¬ify);
#endif
addPage(transfersDialog = new TransfersDialog(ui->stackPages), grp, ¬ify);
addPage(chatLobbyDialog = new ChatLobbyWidget(ui->stackPages), grp, ¬ify);
addPage(messagesDialog = new MessagesDialog(ui->stackPages), grp, ¬ify);
addPage(gxschannelDialog = new GxsChannelDialog(ui->stackPages), grp, ¬ify);
addPage(gxsforumDialog = new GxsForumsDialog(ui->stackPages), grp, ¬ify);
addPage(postedDialog = new PostedDialog(ui->stackPages), grp, ¬ify);
#ifdef RS_USE_WIKI
WikiDialog *wikiDialog = NULL;
addPage(wikiDialog = new WikiDialog(ui->stackPages), grp, ¬ify);
#endif
#ifdef BLOGS
addPage(blogsFeed = new BlogsDialog(ui->stackPages), grp, NULL);
#endif
std::cerr << "Looking for interfaces in existing plugins:" << std::endl;
for(int i = 0;i<rsPlugins->nbPlugins();++i)
{
QIcon icon ;
if(rsPlugins->plugin(i) != NULL && rsPlugins->plugin(i)->qt_page() != NULL)
{
if(rsPlugins->plugin(i)->qt_icon() != NULL)
icon = *rsPlugins->plugin(i)->qt_icon() ;
else
icon = QIcon(":images/extension_48.png") ;
std::cerr << " Addign widget page for plugin " << rsPlugins->plugin(i)->getPluginName() << std::endl;
MainPage *pluginPage = rsPlugins->plugin(i)->qt_page();
pluginPage->setIconPixmap(icon);
pluginPage->setPageName(QString::fromUtf8(rsPlugins->plugin(i)->getPluginName().c_str()));
addPage(pluginPage, grp, ¬ify);
}
else if(rsPlugins->plugin(i) == NULL)
std::cerr << " No plugin object !" << std::endl;
else
std::cerr << " No plugin page !" << std::endl;
}
#ifndef RS_RELEASE_VERSION
#ifdef PLUGINMGR
addPage(pluginsPage = new PluginsPage(ui->stackPages), grp, NULL);
#endif
#endif
#ifdef GETSTARTED_GUI
MainPage *getStartedPage = NULL;
if (!advancedMode)
{
//ui->stackPages->add(getStartedPage = new GetStartedDialog(ui->stackPages),
// createPageAction(QIcon(IMG_HELP), tr("Getting Started"), grp));
addPage(getStartedPage = new GetStartedDialog(ui->stackPages), grp, NULL);
}
#endif
/* Create the toolbar */
ui->toolBarPage->addActions(grp->actions());
connect(grp, SIGNAL(triggered(QAction *)), ui->stackPages, SLOT(showPage(QAction *)));
#ifdef UNFINISHED
addAction(new QAction(QIcon(IMAGE_UNFINISHED), tr("Unfinished"), ui->toolBar), &MainWindow::showApplWindow, SLOT(showApplWindow()));
ui->toolBarAction->addSeparator();
notify += applicationWindow->getNotify();
#endif
/** Add icon on Action bar */
addAction(new QAction(QIcon(IMAGE_ADDFRIEND), tr("Add"), ui->toolBarAction), &MainWindow::addFriend, SLOT(addFriend()));
//addAction(new QAction(QIcon(IMAGE_NEWRSCOLLECTION), tr("New"), ui->toolBarAction), &MainWindow::newRsCollection, SLOT(newRsCollection()));
addAction(new QAction(QIcon(IMAGE_PREFERENCES), tr("Options"), ui->toolBarAction), &MainWindow::showSettings, SLOT(showSettings()));
addAction(new QAction(QIcon(IMAGE_ABOUT), tr("About"), ui->toolBarAction), &MainWindow::showabout, SLOT(showabout()));
addAction(new QAction(QIcon(IMAGE_QUIT), tr("Quit"), ui->toolBarAction), &MainWindow::doQuit, SLOT(doQuit()));
QList<QPair<MainPage*, QPair<QAction*, QListWidgetItem*> > >::iterator notifyIt;
for (notifyIt = notify.begin(); notifyIt != notify.end(); ++notifyIt) {
UserNotify *userNotify = notifyIt->first->getUserNotify(this);
if (userNotify) {
userNotify->initialize(ui->toolBarPage, notifyIt->second.first, notifyIt->second.second);
connect(userNotify, SIGNAL(countChanged()), this, SLOT(updateTrayCombine()));
userNotifyList.push_back(userNotify);
}
}
}
Interface::Interface(Plasma::RunnerManager *runnerManager, QWidget *parent)
: KRunnerDialog(runnerManager, parent),
m_delayedRun(false),
m_running(false),
m_queryRunning(false)
{
m_resultData.processHoverEvents = true;
m_resultData.mouseHovering = false;
m_resultData.runnerManager = runnerManager;
m_hideResultsTimer.setSingleShot(true);
connect(&m_hideResultsTimer, SIGNAL(timeout()), this, SLOT(hideResultsArea()));
m_reenableHoverEventsTimer.setSingleShot(true);
m_reenableHoverEventsTimer.setInterval(50);
connect(&m_reenableHoverEventsTimer, SIGNAL(timeout()), this, SLOT(reenableHoverEvents()));
m_layout = new QVBoxLayout(this);
m_layout->setMargin(0);
m_buttonContainer = new QWidget(this);
QHBoxLayout *bottomLayout = new QHBoxLayout(m_buttonContainer);
bottomLayout->setMargin(0);
m_configButton = new ToolButton(m_buttonContainer);
m_configButton->setText(i18n("Settings"));
m_configButton->setToolTip(i18n("Settings"));
connect(m_configButton, SIGNAL(clicked()), SLOT(toggleConfigDialog()));
bottomLayout->addWidget(m_configButton);
//Set up the system activity button, using the krunner global action, showing the global shortcut in the tooltip
m_activityButton = new ToolButton(m_buttonContainer);
KRunnerApp *krunnerApp = KRunnerApp::self();
QAction *showSystemActivityAction = krunnerApp->actionCollection()->action(QLatin1String( "Show System Activity" ));
m_activityButton->setDefaultAction(showSystemActivityAction);
updateSystemActivityToolTip();
connect(showSystemActivityAction, SIGNAL(globalShortcutChanged(QKeySequence)), this, SLOT(updateSystemActivityToolTip()));
connect(showSystemActivityAction, SIGNAL(triggered(bool)), this, SLOT(resetAndClose()));
bottomLayout->addWidget(m_activityButton);
m_singleRunnerIcon = new QLabel();
bottomLayout->addWidget(m_singleRunnerIcon);
m_singleRunnerDisplayName = new QLabel();
bottomLayout->addWidget(m_singleRunnerDisplayName);
m_helpButton = new ToolButton(m_buttonContainer);
m_helpButton->setText(i18n("Help"));
m_helpButton->setToolTip(i18n("Information on using this application"));
connect(m_helpButton, SIGNAL(clicked(bool)), SLOT(showHelp()));
connect(m_helpButton, SIGNAL(clicked(bool)), SLOT(configCompleted()));
bottomLayout->addWidget(m_helpButton);
QSpacerItem* closeButtonSpacer = new QSpacerItem(0,0,QSizePolicy::MinimumExpanding,QSizePolicy::Fixed);
bottomLayout->addSpacerItem(closeButtonSpacer);
m_closeButton = new ToolButton(m_buttonContainer);
KGuiItem guiItem = KStandardGuiItem::close();
m_closeButton->setText(guiItem.text());
m_closeButton->setToolTip(guiItem.text().remove(QLatin1Char( '&' )));
connect(m_closeButton, SIGNAL(clicked(bool)), SLOT(resetAndClose()));
bottomLayout->addWidget(m_closeButton);
m_layout->addWidget(m_buttonContainer);
m_searchTerm = new KrunnerHistoryComboBox(false, this);
KLineEdit *lineEdit = new KLineEdit(m_searchTerm);
QAction *focusEdit = new QAction(this);
focusEdit->setShortcut(Qt::Key_F6);
connect(focusEdit, SIGNAL(triggered(bool)), this, SLOT(searchTermSetFocus()));
addAction(focusEdit);
// the order of these next few lines if very important.
// QComboBox::setLineEdit sets the autoComplete flag on the lineedit,
// and KComboBox::setAutoComplete resets the autocomplete mode! ugh!
m_searchTerm->setLineEdit(lineEdit);
m_completion = new KCompletion();
lineEdit->setCompletionObject(m_completion);
lineEdit->setCompletionMode(static_cast<KGlobalSettings::Completion>(KRunnerSettings::queryTextCompletionMode()));
lineEdit->setClearButtonShown(true);
QStringList pastQueryItems = KRunnerSettings::pastQueries();
m_searchTerm->setHistoryItems(pastQueryItems);
m_completion->insertItems(pastQueryItems);
bottomLayout->insertWidget(4, m_searchTerm, 10);
m_singleRunnerSearchTerm = new KLineEdit(this);
bottomLayout->insertWidget(4, m_singleRunnerSearchTerm, 10 );
//kDebug() << "size:" << m_resultsView->size() << m_resultsView->minimumSize();
m_resultsScene = new ResultScene(&m_resultData, runnerManager, m_searchTerm, this);
m_resultsView = new ResultsView(m_resultsScene, &m_resultData, this);
m_layout->addWidget(m_resultsView);
connect(m_resultsScene, SIGNAL(viewableHeightChanged()), this, SLOT(fitWindow()));
connect(m_resultsScene, SIGNAL(matchCountChanged(int)), this, SLOT(matchCountChanged(int)));
connect(m_resultsScene, SIGNAL(itemActivated(ResultItem*)), this, SLOT(run(ResultItem*)));
connect(m_searchTerm, SIGNAL(queryTextEdited(QString)), this, SLOT(queryTextEdited(QString)));
connect(m_searchTerm, SIGNAL(returnPressed()), this, SLOT(runDefaultResultItem()));
connect(m_singleRunnerSearchTerm, SIGNAL(textChanged(QString)), this, SLOT(queryTextEdited(QString)));
connect(m_singleRunnerSearchTerm, SIGNAL(returnPressed()), this, SLOT(runDefaultResultItem()));
lineEdit->installEventFilter(this);
m_searchTerm->installEventFilter(this);
themeUpdated();
connect(Plasma::Theme::defaultTheme(), SIGNAL(themeChanged()), this, SLOT(themeUpdated()));
new QShortcut(QKeySequence(Qt::Key_Escape), this, SLOT(resetAndClose()));
m_layout->setAlignment(Qt::AlignTop);
setTabOrder(0, m_configButton);
setTabOrder(m_configButton, m_activityButton);
setTabOrder(m_activityButton, m_searchTerm);
setTabOrder(m_searchTerm, m_singleRunnerSearchTerm);
setTabOrder(m_singleRunnerSearchTerm, m_resultsView);
setTabOrder(m_resultsView, m_helpButton);
setTabOrder(m_helpButton, m_closeButton);
//kDebug() << "size:" << m_resultsView->size() << m_resultsView->minimumSize() << minimumSizeHint();
// we restore the original size, which will set the results view back to its
// normal size, then we hide the results view and resize the dialog
setMinimumSize(QSize(MIN_WIDTH, m_searchTerm->sizeHint().height()));
// we load the last used size; the saved value is the size of the dialog when the
// results are visible;
adjustSize();
if (KGlobal::config()->hasGroup("Interface")) {
KConfigGroup interfaceConfig(KGlobal::config(), "Interface");
restoreDialogSize(interfaceConfig);
m_defaultSize = size();
} else {
const int screenWidth = qApp->desktop()->screenGeometry().width();
int width = size().width();
if (screenWidth >= 1920) {
width = qMax(width, 550);
} else if (screenWidth >= 1024) {
width = qMax(width, 300);
}
m_defaultSize = QSize(width, 500);
}
m_resultsView->hide();
m_delayedQueryTimer.setSingleShot(true);
m_delayedQueryTimer.setInterval(50);
connect(&m_delayedQueryTimer, SIGNAL(timeout()), this, SLOT(delayedQueryLaunch()));
m_saveDialogSizeTimer.setSingleShot(true);
m_saveDialogSizeTimer.setInterval(1000);
connect(&m_saveDialogSizeTimer, SIGNAL(timeout()), SLOT(saveCurrentDialogSize()));
QTimer::singleShot(0, this, SLOT(resetInterface()));
}
void XHTMLReader::fillTagTable() {
if (ourTagActions.empty()) {
//addAction("html", new XHTMLTagAction());
addAction("body", new XHTMLTagBodyAction());
//addAction("title", new XHTMLTagAction());
//addAction("meta", new XHTMLTagAction());
//addAction("script", new XHTMLTagAction());
//addAction("font", new XHTMLTagAction());
addAction("style", new XHTMLTagStyleAction());
addAction("p", new XHTMLTagParagraphAction(XHTML_TAG_P));
addAction("h1", new XHTMLTagParagraphWithControlAction(H1));
addAction("h2", new XHTMLTagParagraphWithControlAction(H2));
addAction("h3", new XHTMLTagParagraphWithControlAction(H3));
addAction("h4", new XHTMLTagParagraphWithControlAction(H4));
addAction("h5", new XHTMLTagParagraphWithControlAction(H5));
addAction("h6", new XHTMLTagParagraphWithControlAction(H6));
addAction("ol", new XHTMLTagListAction(1));
addAction("ul", new XHTMLTagListAction(0));
//addAction("dl", new XHTMLTagAction());
addAction("li", new XHTMLTagItemAction());
addAction("strong", new XHTMLTagControlAction(STRONG));
addAction("b", new XHTMLTagControlAction(BOLD));
addAction("em", new XHTMLTagControlAction(EMPHASIS));
addAction("i", new XHTMLTagControlAction(ITALIC));
addAction("code", new XHTMLTagControlAction(CODE));
addAction("tt", new XHTMLTagControlAction(CODE));
addAction("kbd", new XHTMLTagControlAction(CODE));
addAction("var", new XHTMLTagControlAction(CODE));
addAction("samp", new XHTMLTagControlAction(CODE));
addAction("cite", new XHTMLTagControlAction(CITE));
addAction("sub", new XHTMLTagControlAction(SUB));
addAction("sup", new XHTMLTagControlAction(SUP));
addAction("dd", new XHTMLTagControlAction(DEFINITION_DESCRIPTION));
addAction("dfn", new XHTMLTagControlAction(DEFINITION));
addAction("strike", new XHTMLTagControlAction(STRIKETHROUGH));
addAction("a", new XHTMLTagHyperlinkAction());
addAction("img", new XHTMLTagImageAction("src"));
addAction("object", new XHTMLTagImageAction("data"));
XHTMLSvgImageNamePredicate *predicate = new XHTMLSvgImageNamePredicate();
addAction("svg", new XHTMLTagSvgAction(*predicate));
addAction("image", new XHTMLTagImageAction(predicate));
addAction(ZLXMLNamespace::Svg, "svg", new XHTMLTagSvgAction(*predicate));
addAction(ZLXMLNamespace::Svg, "image", new XHTMLTagImageAction(predicate));
//addAction("area", new XHTMLTagAction());
//addAction("map", new XHTMLTagAction());
//addAction("base", new XHTMLTagAction());
//addAction("blockquote", new XHTMLTagAction());
//addAction("br", new XHTMLTagRestartParagraphAction());
//addAction("center", new XHTMLTagAction());
addAction("div", new XHTMLTagParagraphAction());
addAction("dt", new XHTMLTagParagraphAction());
//addAction("head", new XHTMLTagAction());
//addAction("hr", new XHTMLTagAction());
addAction("link", new XHTMLTagLinkAction());
//addAction("param", new XHTMLTagAction());
//addAction("q", new XHTMLTagAction());
//addAction("s", new XHTMLTagAction());
addAction("pre", new XHTMLTagPreAction());
//addAction("big", new XHTMLTagAction());
//addAction("small", new XHTMLTagAction());
//addAction("u", new XHTMLTagAction());
//addAction("table", new XHTMLTagAction());
addAction("td", new XHTMLTagParagraphAction());
addAction("th", new XHTMLTagParagraphAction());
//addAction("tr", new XHTMLTagAction());
//addAction("caption", new XHTMLTagAction());
//addAction("span", new XHTMLTagAction());
addAction("video", new XHTMLTagVideoAction());
addAction("source", new XHTMLTagSourceAction());
}
}