GolangPresentEdit::GolangPresentEdit(LiteApi::IApplication *app, LiteApi::IEditor *editor, QObject *parent) :
QObject(parent), m_liteApp(app), m_htmldoc(0), m_process(0)
{
m_editor = LiteApi::getLiteEditor(editor);
if (!m_editor) {
return;
}
m_ed = LiteApi::getPlainTextEdit(editor);
m_editor->setWordWrap(true);
connect(m_liteApp->editorManager(),SIGNAL(editorSaved(LiteApi::IEditor*)),this,SLOT(editorSaved(LiteApi::IEditor*)));
LiteApi::IActionContext *actionContext = m_liteApp->actionManager()->getActionContext(this,"GoSlide");
QAction *s1 = new QAction(QIcon("icon:golangpresent/images/s1.png"),tr("Section (s1)"),this);
actionContext->regAction(s1,"Section","Ctrl+1");
QAction *s2 = new QAction(QIcon("icon:golangpresent/images/s2.png"),tr("Subsection (s2)"),this);
actionContext->regAction(s2,"Subsection","Ctrl+2");
QAction *s3 = new QAction(QIcon("icon:golangpresent/images/s3.png"),tr("Sub-subsection (s3)"),this);
actionContext->regAction(s3,"Sub-subsection","Ctrl+3");
QAction *bold = new QAction(QIcon("icon:golangpresent/images/bold.png"),tr("Bold"),this);
actionContext->regAction(bold,"Bold",QKeySequence::Bold);
QAction *italic = new QAction(QIcon("icon:golangpresent/images/italic.png"),tr("Italic"),this);
actionContext->regAction(italic,"Italic",QKeySequence::Italic);
QAction *code = new QAction(QIcon("icon:golangpresent/images/code.png"),tr("Inline Code"),this);
actionContext->regAction(code,"InlineCode","Ctrl+K");
QAction *bullets = new QAction(QIcon("icon:golangpresent/images/bullets.png"),tr("Switch Bullets"),this);
actionContext->regAction(bullets,"Switch Bullets","Ctrl+Shift+U");
QAction *comment = new QAction(tr("Comment/Uncomment Selection"),this);
actionContext->regAction(comment,"Comment","Ctrl+/");
QAction *exportHtml = new QAction(QIcon("icon:golangpresent/images/exporthtml.png"),tr("Export HTML"),this);
actionContext->regAction(exportHtml,"Export HTML","");
QAction *verify = new QAction(QIcon("icon:golangpresent/images/verify.png"),tr("Verify Present"),this);
actionContext->regAction(verify,"Verify Present","");
//QAction *exportPdf = new QAction(QIcon("icon:golangpresent/images/exportpdf.png"),tr("Export PDF"),this);
//actionContext->regAction(exportPdf,"Export PDF","");
connect(m_editor,SIGNAL(destroyed()),this,SLOT(deleteLater()));
connect(s1,SIGNAL(triggered()),this,SLOT(s1()));
connect(s2,SIGNAL(triggered()),this,SLOT(s2()));
connect(s3,SIGNAL(triggered()),this,SLOT(s3()));
connect(bold,SIGNAL(triggered()),this,SLOT(bold()));
connect(italic,SIGNAL(triggered()),this,SLOT(italic()));
connect(code,SIGNAL(triggered()),this,SLOT(code()));
connect(bullets,SIGNAL(triggered()),this,SLOT(bullets()));
connect(comment,SIGNAL(triggered()),this,SLOT(comment()));
connect(exportHtml,SIGNAL(triggered()),this,SLOT(exportHtml()));
connect(verify,SIGNAL(triggered()),this,SLOT(verify()));
//connect(exportPdf,SIGNAL(triggered()),this,SLOT(exportPdf()));
QToolBar *toolBar = LiteApi::findExtensionObject<QToolBar*>(editor,"LiteApi.QToolBar");
if (toolBar) {
toolBar->addSeparator();
toolBar->addAction(s1);
toolBar->addAction(s2);
toolBar->addAction(s3);
toolBar->addSeparator();
toolBar->addAction(bold);
toolBar->addAction(italic);
toolBar->addAction(code);
toolBar->addSeparator();
toolBar->addAction(bullets);
toolBar->addSeparator();
toolBar->addAction(verify);
toolBar->addSeparator();
toolBar->addAction(exportHtml);
//toolBar->addAction(exportPdf);
}
QMenu *menu = LiteApi::getEditMenu(editor);
if (menu) {
menu->addSeparator();
menu->addAction(s1);
menu->addAction(s2);
menu->addAction(s3);
menu->addSeparator();
menu->addAction(bold);
menu->addAction(italic);
menu->addAction(code);
menu->addSeparator();
menu->addAction(bullets);
menu->addSeparator();
menu->addAction(comment);
menu->addSeparator();
menu->addAction(verify);
menu->addSeparator();
menu->addAction(exportHtml);
//menu->addAction(exportPdf);
}
menu = LiteApi::getContextMenu(editor);
if (menu) {
menu->addSeparator();
menu->addAction(s1);
menu->addAction(s2);
menu->addAction(s3);
menu->addSeparator();
menu->addAction(bold);
menu->addAction(italic);
menu->addAction(code);
menu->addSeparator();
menu->addAction(bullets);
menu->addSeparator();
menu->addAction(comment);
}
}
void TextEdit::setupTextActions()
{
QToolBar *tb = new QToolBar(this);
tb->setWindowTitle(tr("Format Actions"));
addToolBar(tb);
QMenu *menu = new QMenu(tr("F&ormat"), this);
menuBar()->addMenu(menu);
actionTextBold = new QAction(QIcon(rsrcPath + "/textbold.png"), tr("&Bold"), this);
actionTextBold->setShortcut(Qt::CTRL + Qt::Key_B);
QFont bold;
bold.setBold(true);
actionTextBold->setFont(bold);
connect(actionTextBold, SIGNAL(triggered()), this, SLOT(textBold()));
tb->addAction(actionTextBold);
menu->addAction(actionTextBold);
actionTextBold->setCheckable(true);
actionTextItalic = new QAction(QIcon(rsrcPath + "/textitalic.png"), tr("&Italic"), this);
actionTextItalic->setShortcut(Qt::CTRL + Qt::Key_I);
QFont italic;
italic.setItalic(true);
actionTextItalic->setFont(italic);
connect(actionTextItalic, SIGNAL(triggered()), this, SLOT(textItalic()));
tb->addAction(actionTextItalic);
menu->addAction(actionTextItalic);
actionTextItalic->setCheckable(true);
actionTextUnderline = new QAction(QIcon(rsrcPath + "/textunder.png"), tr("&Underline"), this);
actionTextUnderline->setShortcut(Qt::CTRL + Qt::Key_U);
QFont underline;
underline.setUnderline(true);
actionTextUnderline->setFont(underline);
connect(actionTextUnderline, SIGNAL(triggered()), this, SLOT(textUnderline()));
tb->addAction(actionTextUnderline);
menu->addAction(actionTextUnderline);
actionTextUnderline->setCheckable(true);
menu->addSeparator();
QActionGroup *grp = new QActionGroup(this);
connect(grp, SIGNAL(triggered(QAction *)), this, SLOT(textAlign(QAction *)));
// Make sure the alignLeft is always left of the alignRight
if (QApplication::isLeftToRight()) {
actionAlignLeft = new QAction(QIcon(rsrcPath + "/textleft.png"), tr("&Left"), grp);
actionAlignCenter = new QAction(QIcon(rsrcPath + "/textcenter.png"), tr("C&enter"), grp);
actionAlignRight = new QAction(QIcon(rsrcPath + "/textright.png"), tr("&Right"), grp);
} else {
actionAlignRight = new QAction(QIcon(rsrcPath + "/textright.png"), tr("&Right"), grp);
actionAlignCenter = new QAction(QIcon(rsrcPath + "/textcenter.png"), tr("C&enter"), grp);
actionAlignLeft = new QAction(QIcon(rsrcPath + "/textleft.png"), tr("&Left"), grp);
}
actionAlignJustify = new QAction(QIcon(rsrcPath + "/textjustify.png"), tr("&Justify"), grp);
actionAlignLeft->setShortcut(Qt::CTRL + Qt::Key_L);
actionAlignLeft->setCheckable(true);
actionAlignCenter->setShortcut(Qt::CTRL + Qt::Key_E);
actionAlignCenter->setCheckable(true);
actionAlignRight->setShortcut(Qt::CTRL + Qt::Key_R);
actionAlignRight->setCheckable(true);
actionAlignJustify->setShortcut(Qt::CTRL + Qt::Key_J);
actionAlignJustify->setCheckable(true);
tb->addActions(grp->actions());
menu->addActions(grp->actions());
menu->addSeparator();
QPixmap pix(16, 16);
pix.fill(Qt::black);
actionTextColor = new QAction(pix, tr("&Color..."), this);
connect(actionTextColor, SIGNAL(triggered()), this, SLOT(textColor()));
tb->addAction(actionTextColor);
menu->addAction(actionTextColor);
tb = new QToolBar(this);
tb->setAllowedAreas(Qt::TopToolBarArea | Qt::BottomToolBarArea);
tb->setWindowTitle(tr("Format Actions"));
addToolBarBreak(Qt::TopToolBarArea);
addToolBar(tb);
comboStyle = new QComboBox(tb);
tb->addWidget(comboStyle);
comboStyle->addItem("Standard");
comboStyle->addItem("Bullet List (Disc)");
comboStyle->addItem("Bullet List (Circle)");
comboStyle->addItem("Bullet List (Square)");
comboStyle->addItem("Ordered List (Decimal)");
comboStyle->addItem("Ordered List (Alpha lower)");
comboStyle->addItem("Ordered List (Alpha upper)");
connect(comboStyle, SIGNAL(activated(int)),
this, SLOT(textStyle(int)));
comboFont = new QFontComboBox(tb);
tb->addWidget(comboFont);
connect(comboFont, SIGNAL(activated(const QString &)),
this, SLOT(textFamily(const QString &)));
comboSize = new QComboBox(tb);
comboSize->setObjectName("comboSize");
tb->addWidget(comboSize);
comboSize->setEditable(true);
QFontDatabase db;
foreach(int size, db.standardSizes())
comboSize->addItem(QString::number(size));
connect(comboSize, SIGNAL(activated(const QString &)),
this, SLOT(textSize(const QString &)));
comboSize->setCurrentIndex(comboSize->findText(QString::number(QApplication::font()
.pointSize())));
}
void QmitkExtWorkbenchWindowAdvisor::PostWindowCreate()
{
QmitkCommonWorkbenchWindowAdvisor::PostWindowCreate();
// very bad hack...
berry::IWorkbenchWindow::Pointer window =
this->GetWindowConfigurer()->GetWindow();
QMainWindow* mainWindow =
static_cast<QMainWindow*> (window->GetShell()->GetControl());
if (!windowIcon.empty())
{
mainWindow->setWindowIcon(QIcon(QString::fromStdString(windowIcon)));
}
mainWindow->setContextMenuPolicy(Qt::PreventContextMenu);
/*mainWindow->setStyleSheet("color: white;"
"background-color: #808080;"
"selection-color: #659EC7;"
"selection-background-color: #808080;"
" QMenuBar {"
"background-color: #808080; }");*/
// ==== Application menu ============================
QMenuBar* menuBar = mainWindow->menuBar();
menuBar->setContextMenuPolicy(Qt::PreventContextMenu);
QMenu* fileMenu = menuBar->addMenu("&File");
fileMenu->setObjectName("FileMenu");
QAction* fileOpenAction = new QmitkExtFileOpenAction(QIcon(":/org.mitk.gui.qt.ext/Load_48.png"), window);
fileMenu->addAction(fileOpenAction);
fileSaveProjectAction = new QmitkExtFileSaveProjectAction(window);
fileSaveProjectAction->setIcon(QIcon(":/org.mitk.gui.qt.ext/Save_48.png"));
fileMenu->addAction(fileSaveProjectAction);
closeProjectAction = new QmitkCloseProjectAction(window);
closeProjectAction->setIcon(QIcon(":/org.mitk.gui.qt.ext/Remove_48.png"));
fileMenu->addAction(closeProjectAction);
fileMenu->addSeparator();
QAction* fileExitAction = new QmitkFileExitAction(window);
fileExitAction->setObjectName("QmitkFileExitAction");
fileMenu->addAction(fileExitAction);
berry::IViewRegistry* viewRegistry =
berry::PlatformUI::GetWorkbench()->GetViewRegistry();
const std::vector<berry::IViewDescriptor::Pointer>& viewDescriptors =
viewRegistry->GetViews();
// another bad hack to get an edit/undo menu...
QMenu* editMenu = menuBar->addMenu("&Edit");
undoAction = editMenu->addAction(QIcon(":/org.mitk.gui.qt.ext/Undo_48.png"),
"&Undo",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onUndo()),
QKeySequence("CTRL+Z"));
undoAction->setToolTip("Undo the last action (not supported by all modules)");
redoAction = editMenu->addAction(QIcon(":/org.mitk.gui.qt.ext/Redo_48.png")
, "&Redo",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onRedo()),
QKeySequence("CTRL+Y"));
redoAction->setToolTip("execute the last action that was undone again (not supported by all modules)");
imageNavigatorAction = new QAction(QIcon(":/org.mitk.gui.qt.ext/Slider.png"), "&Image Navigator", NULL);
bool imageNavigatorViewFound = window->GetWorkbench()->GetViewRegistry()->Find("org.mitk.views.imagenavigator");
if (imageNavigatorViewFound)
{
QObject::connect(imageNavigatorAction, SIGNAL(triggered(bool)), QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onImageNavigator()));
imageNavigatorAction->setCheckable(true);
// add part listener for image navigator
imageNavigatorPartListener = new PartListenerForImageNavigator(imageNavigatorAction);
window->GetPartService()->AddPartListener(imageNavigatorPartListener);
berry::IViewPart::Pointer imageNavigatorView =
window->GetActivePage()->FindView("org.mitk.views.imagenavigator");
imageNavigatorAction->setChecked(false);
if (imageNavigatorView)
{
bool isImageNavigatorVisible = window->GetActivePage()->IsPartVisible(imageNavigatorView);
if (isImageNavigatorVisible)
imageNavigatorAction->setChecked(true);
}
imageNavigatorAction->setToolTip("Open image navigator for navigating through image");
}
// toolbar for showing file open, undo, redo and other main actions
QToolBar* mainActionsToolBar = new QToolBar;
mainActionsToolBar->setContextMenuPolicy(Qt::PreventContextMenu);
#ifdef __APPLE__
mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextUnderIcon );
#else
mainActionsToolBar->setToolButtonStyle ( Qt::ToolButtonTextBesideIcon );
#endif
mainActionsToolBar->addAction(fileOpenAction);
mainActionsToolBar->addAction(fileSaveProjectAction);
mainActionsToolBar->addAction(closeProjectAction);
mainActionsToolBar->addAction(undoAction);
mainActionsToolBar->addAction(redoAction);
if (imageNavigatorViewFound)
{
mainActionsToolBar->addAction(imageNavigatorAction);
}
mainWindow->addToolBar(mainActionsToolBar);
#ifdef __APPLE__
mainWindow->setUnifiedTitleAndToolBarOnMac(true);
#endif
// ==== Window Menu ==========================
QMenu* windowMenu = menuBar->addMenu("Window");
if (showNewWindowMenuItem)
{
windowMenu->addAction("&New Window", QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onNewWindow()));
windowMenu->addSeparator();
}
QMenu* perspMenu = windowMenu->addMenu("&Open Perspective");
QMenu* viewMenu;
if (showViewMenuItem)
{
viewMenu = windowMenu->addMenu("Show &View");
viewMenu->setObjectName("Show View");
}
windowMenu->addSeparator();
resetPerspAction = windowMenu->addAction("&Reset Perspective",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onResetPerspective()));
if(showClosePerspectiveMenuItem)
closePerspAction = windowMenu->addAction("&Close Perspective", QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onClosePerspective()));
windowMenu->addSeparator();
windowMenu->addAction("&Preferences...",
QmitkExtWorkbenchWindowAdvisorHack::undohack, SLOT(onEditPreferences()),
QKeySequence("CTRL+P"));
// fill perspective menu
berry::IPerspectiveRegistry* perspRegistry =
window->GetWorkbench()->GetPerspectiveRegistry();
QActionGroup* perspGroup = new QActionGroup(menuBar);
std::vector<berry::IPerspectiveDescriptor::Pointer> perspectives(
perspRegistry->GetPerspectives());
bool skip = false;
for (std::vector<berry::IPerspectiveDescriptor::Pointer>::iterator perspIt =
perspectives.begin(); perspIt != perspectives.end(); ++perspIt)
{
// if perspectiveExcludeList is set, it contains the id-strings of perspectives, which
// should not appear as an menu-entry in the perspective menu
if (perspectiveExcludeList.size() > 0)
{
for (unsigned int i=0; i<perspectiveExcludeList.size(); i++)
{
if (perspectiveExcludeList.at(i) == (*perspIt)->GetId())
{
skip = true;
break;
}
}
if (skip)
{
skip = false;
continue;
}
}
QAction* perspAction = new berry::QtOpenPerspectiveAction(window,
*perspIt, perspGroup);
mapPerspIdToAction.insert(std::make_pair((*perspIt)->GetId(), perspAction));
}
perspMenu->addActions(perspGroup->actions());
// sort elements (converting vector to map...)
std::vector<berry::IViewDescriptor::Pointer>::const_iterator iter;
std::map<std::string, berry::IViewDescriptor::Pointer> VDMap;
skip = false;
for (iter = viewDescriptors.begin(); iter != viewDescriptors.end(); ++iter)
{
// if viewExcludeList is set, it contains the id-strings of view, which
// should not appear as an menu-entry in the menu
if (viewExcludeList.size() > 0)
{
for (unsigned int i=0; i<viewExcludeList.size(); i++)
{
if (viewExcludeList.at(i) == (*iter)->GetId())
{
skip = true;
break;
}
}
if (skip)
{
skip = false;
continue;
}
}
if ((*iter)->GetId() == "org.blueberry.ui.internal.introview")
continue;
if ((*iter)->GetId() == "org.mitk.views.imagenavigator")
continue;
std::pair<std::string, berry::IViewDescriptor::Pointer> p(
(*iter)->GetLabel(), (*iter));
VDMap.insert(p);
}
// ==================================================
// ==== Perspective Toolbar ==================================
QToolBar* qPerspectiveToolbar = new QToolBar;
if (showPerspectiveToolbar)
{
qPerspectiveToolbar->addActions(perspGroup->actions());
mainWindow->addToolBar(qPerspectiveToolbar);
}
else
delete qPerspectiveToolbar;
// ==== View Toolbar ==================================
QToolBar* qToolbar = new QToolBar;
std::map<std::string, berry::IViewDescriptor::Pointer>::const_iterator
MapIter;
for (MapIter = VDMap.begin(); MapIter != VDMap.end(); ++MapIter)
{
berry::QtShowViewAction* viewAction = new berry::QtShowViewAction(window,
(*MapIter).second);
viewActions.push_back(viewAction);
if(showViewMenuItem)
viewMenu->addAction(viewAction);
if (showViewToolbar)
{
qToolbar->addAction(viewAction);
}
}
if (showViewToolbar)
{
mainWindow->addToolBar(qToolbar);
}
else
delete qToolbar;
QSettings settings(GetQSettingsFile(), QSettings::IniFormat);
mainWindow->restoreState(settings.value("ToolbarPosition").toByteArray());
// ====================================================
// ===== Help menu ====================================
QMenu* helpMenu = menuBar->addMenu("Help");
helpMenu->addAction("&Welcome",this, SLOT(onIntro()));
helpMenu->addAction("&Help Contents",this, SLOT(onHelp()), QKeySequence("F1"));
helpMenu->addAction("&About",this, SLOT(onAbout()));
// =====================================================
QStatusBar* qStatusBar = new QStatusBar();
//creating a QmitkStatusBar for Output on the QStatusBar and connecting it with the MainStatusBar
QmitkStatusBar *statusBar = new QmitkStatusBar(qStatusBar);
//disabling the SizeGrip in the lower right corner
statusBar->SetSizeGripEnabled(false);
QmitkProgressBar *progBar = new QmitkProgressBar();
qStatusBar->addPermanentWidget(progBar, 0);
progBar->hide();
// progBar->AddStepsToDo(2);
// progBar->Progress(1);
mainWindow->setStatusBar(qStatusBar);
QmitkMemoryUsageIndicatorView* memoryIndicator =
new QmitkMemoryUsageIndicatorView();
qStatusBar->addPermanentWidget(memoryIndicator, 0);
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
pDetectorProgress = NULL;
mLogAllXmlRpcOutput = false;
mDbUpdated = false;
// mSyncRequests tracks how many sync requests have been made
// in order to know when to re-enable the widgets
mSyncRequests = 0;
// mSyncPosition is used to iterate through the backend list,
// so we only sync one repository at a time, rather than flinging
// requests at all of them at once.
mSyncPosition = 0;
mUploading = false;
QSettings settings("Entomologist");
pManager = new QNetworkAccessManager();
connect(pManager, SIGNAL(sslErrors(QNetworkReply *, const QList<QSslError> &)),
this, SLOT(handleSslErrors(QNetworkReply *, const QList<QSslError> &)));
ui->setupUi(this);
QToolBar *toolBar = new QToolBar("Main Toolbar");
toolBar->setObjectName("Main ToolBar");
toolBar->setIconSize(QSize(32,32));
refreshButton = toolBar->addAction(style()->standardIcon(QStyle::SP_BrowserReload), "");
refreshButton->setToolTip("Resync all trackers");
uploadButton = toolBar->addAction(style()->standardIcon(QStyle::SP_ArrowUp), "");
uploadButton->setToolTip("Upload changes");
changelogButton = toolBar->addAction(style()->standardIcon(QStyle::SP_FileDialogInfoView), "");
changelogButton->setToolTip("Show changelog");
toolBar->setMovable(false);
addToolBar(Qt::TopToolBarArea, toolBar);
setupTrayIcon();
// Setup the "Show" menu and "Work Offline"
ui->actionMy_Bugs->setChecked(settings.value("show-my-bugs", true).toBool());
ui->actionMy_Reports->setChecked(settings.value("show-my-reports", true).toBool());
ui->actionMy_CCs->setChecked(settings.value("show-my-ccs", true).toBool());
ui->actionMonitored_Components->setChecked(settings.value("show-my-monitored", true).toBool());
ui->action_Work_Offline->setChecked(settings.value("work-offline", false).toBool());
// Set the default network status
pStatusIcon = new QLabel();
pStatusIcon->setPixmap(QPixmap(":/online"));
pStatusMessage = new QLabel("");
ui->statusBar->addPermanentWidget(pStatusMessage);
ui->statusBar->addPermanentWidget(pStatusIcon);
// We use a spinner animation to show that we're doing things
pSpinnerMovie = new QMovie(this);
pSpinnerMovie->setFileName(":/spinner");
pSpinnerMovie->setScaledSize(QSize(48,48));
ui->spinnerLabel->setMovie(pSpinnerMovie);
ui->spinnerLabel->hide();
ui->syncingLabel->hide();
// Set up the resync timer
pUpdateTimer = new QTimer(this);
connect(pUpdateTimer, SIGNAL(timeout()),
this, SLOT(resync()));
setTimer();
// Keyboard shortcuts for search bar focus / upload changes.
QShortcut* searchFocus;
QShortcut* uploadChange;
QShortcut *logXmlRpc;
searchFocus = new QShortcut(QKeySequence(Qt::META + Qt::Key_Space),this);
searchFocus->setContext(Qt::ApplicationShortcut);
connect(searchFocus,SIGNAL(activated()),this,SLOT(searchFocusTriggered()));
uploadChange = new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_S),this);
uploadChange->setContext(Qt::ApplicationShortcut);
connect(uploadChange,SIGNAL(activated()),this,SLOT(upload()));
logXmlRpc = new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_0), this);
logXmlRpc->setContext(Qt::ApplicationShortcut);
connect(logXmlRpc, SIGNAL(activated()), this, SLOT(toggleXmlRpcLogging()));
// Menu actions
connect(ui->action_Add_Tracker, SIGNAL(triggered()),
this, SLOT(addTrackerTriggered()));
connect(ui->action_Refresh_Tracker,SIGNAL(triggered()),
this, SLOT(resync()));
connect(ui->actionShow_ToDo_List, SIGNAL(triggered()),
this, SLOT(showTodoList()));
connect(ui->action_About, SIGNAL(triggered()),
this, SLOT(aboutTriggered()));
connect(ui->action_Web_Site, SIGNAL(triggered()),
this, SLOT(websiteTriggered()));
connect(ui->action_Preferences, SIGNAL(triggered()),
this, SLOT(prefsTriggered()));
connect(ui->action_Quit, SIGNAL(triggered()),
this, SLOT(quitEvent()));
connect(ui->actionMy_Bugs, SIGNAL(triggered()),
this, SLOT(showActionTriggered()));
connect(ui->actionMy_CCs, SIGNAL(triggered()),
this, SLOT(showActionTriggered()));
connect(ui->actionMy_Reports, SIGNAL(triggered()),
this, SLOT(showActionTriggered()));
connect(ui->actionMonitored_Components, SIGNAL(triggered()),
this, SLOT(showActionTriggered()));
connect(ui->actionEdit_Monitored_Components, SIGNAL(triggered()),
this, SLOT(showEditMonitoredComponents()));
connect(ui->action_Work_Offline, SIGNAL(triggered()),
this, SLOT(workOfflineTriggered()));
// Set up the search button
connect(changelogButton, SIGNAL(triggered()),
this, SLOT(changelogTriggered()));
connect(ui->trackerTab, SIGNAL(showMenu(int)),
this, SLOT(showMenu(int)));
ui->trackerTab->removeTab(0);
ui->trackerTab->removeTab(0);
// And finally set up the various other widgets
connect(refreshButton, SIGNAL(triggered()),
this, SLOT(resync()));
connect(uploadButton, SIGNAL(triggered()),
this, SLOT(upload()));
restoreGeometry(settings.value("window-geometry").toByteArray());
// Set the network status bar and check for updates if possible
if (isOnline())
if (settings.value("update-check", true).toBool() == true)
checkForUpdates();
setupDB();
toggleButtons();
// Now we need the todo list widget
pToDoDock = new QDockWidget(tr("ToDo List"), this);
pToDoDock->setObjectName("ToDoDock");
pToDoDock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
pToDoListWidget = new ToDoListWidget(pToDoDock);
pToDoDock->setWidget(pToDoListWidget);
addDockWidget(Qt::LeftDockWidgetArea, pToDoDock);
pToDoDock->hide();
restoreState(settings.value("entomologist-state").toByteArray());
connect(pToDoDock, SIGNAL(visibilityChanged(bool)),
this, SLOT(dockVisibilityChanged(bool)));
if (pToDoDock->isVisible())
ui->actionShow_ToDo_List->setText("Hide ToDo List");
else
ui->actionShow_ToDo_List->setText("Show ToDo List");
pSearchTab = new SearchTab(this);
connect(pSearchTab, SIGNAL(openSearchedBug(QString,QString)),
this, SLOT(openSearchedBug(QString,QString)));
loadTrackers();
ui->trackerTab->addTab(pSearchTab, QIcon(":/search"), "Search");
if ((settings.value("startup-sync", false).toBool() == true)
|| (mDbUpdated))
syncNextTracker();
}
void EventLog::addActions(QToolBar& bar)
{
bar.addAction(ui_.actionClearLog);
}
kernelinfo::kernelinfo()
: QMainWindow( 0, "kernelinfo", WDestructiveClose )
{
printer = new QPrinter;
QPixmap openIcon, saveIcon, printIcon;
QToolBar * fileTools = new QToolBar( this, "file operations" );
fileTools->setLabel( tr("File Operations") );
openIcon = QPixmap( fileopen );
QToolButton * fileOpen
= new QToolButton( openIcon, tr("Open File"), QString::null,
this, SLOT(choose()), fileTools, "open file" );
saveIcon = QPixmap( filesave );
QToolButton * fileSave
= new QToolButton( saveIcon, tr("Save File"), QString::null,
this, SLOT(save()), fileTools, "save file" );
printIcon = QPixmap( fileprint );
QToolButton * filePrint
= new QToolButton( printIcon, tr("Print File"), QString::null,
this, SLOT(print()), fileTools, "print file" );
(void)QWhatsThis::whatsThisButton( fileTools );
QString fileOpenText = tr("<p><img source=\"fileopen\"> "
"Click this button to open a <em>new file</em>. <br>"
"You can also select the <b>Open</b> command "
"from the <b>File</b> menu.</p>");
QWhatsThis::add( fileOpen, fileOpenText );
QMimeSourceFactory::defaultFactory()->setPixmap( "fileopen", openIcon );
QString fileSaveText = tr("<p>Click this button to save the file you "
"are editing. You will be prompted for a file name.\n"
"You can also select the <b>Save</b> command "
"from the <b>File</b> menu.</p>");
QWhatsThis::add( fileSave, fileSaveText );
QString filePrintText = tr("Click this button to print the file you "
"are editing.\n You can also select the Print "
"command from the File menu.");
QWhatsThis::add( filePrint, filePrintText );
QPopupMenu * file = new QPopupMenu( this );
menuBar()->insertItem( tr("&File"), file );
file->insertItem( tr("&New"), this, SLOT(newDoc()), CTRL+Key_N );
int id;
id = file->insertItem( openIcon, tr("&Open..."),
this, SLOT(choose()), CTRL+Key_O );
file->setWhatsThis( id, fileOpenText );
id = file->insertItem( saveIcon, tr("&Save"),
this, SLOT(save()), CTRL+Key_S );
file->setWhatsThis( id, fileSaveText );
id = file->insertItem( tr("Save &As..."), this, SLOT(saveAs()) );
file->setWhatsThis( id, fileSaveText );
file->insertSeparator();
id = file->insertItem( printIcon, tr("&Print..."),
this, SLOT(print()), CTRL+Key_P );
file->setWhatsThis( id, filePrintText );
file->insertSeparator();
file->insertItem( tr("&Close"), this, SLOT(close()), CTRL+Key_W );
file->insertItem( tr("&Quit"), qApp, SLOT( closeAllWindows() ), CTRL+Key_Q );
menuBar()->insertSeparator();
QPopupMenu * help = new QPopupMenu( this );
menuBar()->insertItem( tr("&Help"), help );
help->insertItem( tr("&About"), this, SLOT(about()), Key_F1 );
help->insertItem( tr("About &Qt"), this, SLOT(aboutQt()) );
help->insertSeparator();
help->insertItem( tr("What's &This"), this, SLOT(whatsThis()), SHIFT+Key_F1 );
e = new QTextEdit( this, "editor" );
e->setFocus();
setCentralWidget( e );
statusBar()->message( tr("Ready"), 2000 );
resize( 450, 600 );
}
void WindowsModernStyle::drawComplexControl( ComplexControl control, const QStyleOptionComplex* option,
QPainter* painter, const QWidget* widget ) const
{
switch ( control ) {
case CC_ToolButton: {
QToolBar* toolBar;
if ( widget && ( toolBar = qobject_cast<QToolBar*>( widget->parentWidget() ) ) ) {
if ( const QStyleOptionToolButton* optionToolButton = qstyleoption_cast<const QStyleOptionToolButton*>( option ) ) {
QRect buttonRect = subControlRect( control, option, SC_ToolButton, widget );
QStyle::State buttonState = option->state & ~State_Sunken;
if ( option->state & State_Sunken ) {
if ( optionToolButton->activeSubControls & SC_ToolButton )
buttonState |= State_Sunken;
else if ( optionToolButton->activeSubControls & SC_ToolButtonMenu )
buttonState |= State_MouseOver;
}
bool selected = buttonState & State_MouseOver && option->state & State_Enabled;
bool checked = buttonState & State_On;
bool sunken = buttonState & State_Sunken;
if ( selected || checked || sunken ) {
QRect rect = buttonRect.adjusted( 0, 0, -1, -1 );
painter->setPen( m_colorItemBorder );
QLinearGradient gradient;
if ( toolBar->orientation() == Qt::Vertical )
gradient = QLinearGradient( rect.topLeft(), rect.topRight() );
else
gradient = QLinearGradient( rect.topLeft(), rect.bottomLeft() );
if ( sunken || (selected && checked) ) {
gradient.setColorAt( 0.0, m_colorItemSunkenBegin );
gradient.setColorAt( 0.5, m_colorItemSunkenMiddle );
gradient.setColorAt( 1.0, m_colorItemSunkenEnd );
} else if ( checked ) {
gradient.setColorAt( 0.0, m_colorItemCheckedBegin );
gradient.setColorAt( 0.5, m_colorItemCheckedMiddle );
gradient.setColorAt( 1.0, m_colorItemCheckedEnd );
} else {
gradient.setColorAt( 0.0, m_colorItemBackgroundBegin );
gradient.setColorAt( 0.5, m_colorItemBackgroundMiddle );
gradient.setColorAt( 1.0, m_colorItemBackgroundEnd );
}
painter->setBrush( gradient );
painter->drawRect( rect );
}
QStyleOptionToolButton optionLabel = *optionToolButton;
int fw = pixelMetric( PM_DefaultFrameWidth, option, widget );
optionLabel.rect = buttonRect.adjusted( fw, fw, -fw, -fw );
drawControl( CE_ToolButtonLabel, &optionLabel, painter, widget );
if ( optionToolButton->subControls & SC_ToolButtonMenu ) {
QStyleOption optionMenu = *optionToolButton;
optionMenu.rect = subControlRect( control, option, SC_ToolButtonMenu, widget );
optionMenu.state = optionToolButton->state & ~State_Sunken;
if ( optionToolButton->state & State_Sunken ) {
if ( optionToolButton->activeSubControls & SC_ToolButton )
optionMenu.state |= State_MouseOver | State_Sunken;
else if ( optionToolButton->activeSubControls & SC_ToolButtonMenu )
optionMenu.state |= State_Sunken;
}
drawPrimitive( PE_IndicatorButtonDropDown, &optionMenu, painter, widget );
} else if ( optionToolButton->features & QStyleOptionToolButton::HasMenu ) {
int size = pixelMetric( PM_MenuButtonIndicator, option, widget );
QRect rect = optionToolButton->rect;
QStyleOptionToolButton optionArrow = *optionToolButton;
optionArrow.rect = QRect( rect.right() + 4 - size, rect.height() - size + 4, size - 5, size - 5 );
drawPrimitive( PE_IndicatorArrowDown, &optionArrow, painter, widget );
}
return;
}
}
break;
}
default:
break;
}
if ( useVista() )
QWindowsVistaStyle::drawComplexControl( control, option, painter, widget );
else
QWindowsXPStyle::drawComplexControl( control, option, painter, widget );
}
void LunarMainWindow::initActions()
{
m_actionImport = new QAction(tr("Import"), this);
m_actionExport = new QAction(tr("Export"), this);
m_actionQuit = new QAction(tr("Quit"), this);
m_actionNewGame = new QAction(tr("New game"), this);
m_actionEditGame = new QAction(tr("Edit game"), this);
m_actionDeleteGame = new QAction(tr("Delete game"), this);
m_actionLaunchGame = new QAction(tr("Launch game"), this);
//m_actionUninstallGame = new QAction(tr("Uninstall game"), this);
m_actionShowEmulators = new QAction(tr("Show Emulators"), this);
m_actionProcessManager = new QAction(tr("Process manager"), this);
m_actionPlugins = new QAction(tr("Plugins"), this);
m_actionOptions = new QAction(tr("Options"), this);
m_actionAboutLunar = new QAction(tr("About Lunar"), this);
m_actionAboutQt = new QAction(tr("About Qt"), this);
m_actionQuit->setIcon(QIcon(QPixmap("resources/imgs/quit.png")));
m_actionNewGame->setIcon(QIcon(QPixmap("resources/imgs/add_game.png")));
m_actionEditGame->setDisabled(true);
m_actionEditGame->setIcon(QIcon(QPixmap("resources/imgs/edit_game.png")));
m_actionDeleteGame->setDisabled(true);
m_actionDeleteGame->setIcon(QIcon(QPixmap("resources/imgs/delete_game.png")));
m_actionLaunchGame->setDisabled(true);
m_actionLaunchGame->setIcon(QIcon(QPixmap("resources/imgs/launch.png")));
m_actionLaunchGame->setToolTip(tr("Start selected game"));
m_actionShowEmulators->setIcon(QIcon(QPixmap("resources/imgs/emulators.png")));
/*m_actionUninstallGame->setDisabled(true);
m_actionUninstallGame->setIcon(QIcon(QPixmap("resources/imgs/uninstall.png")));
m_actionUninstallGame->setToolTip(tr("Uninstall selected game if the option was previously set"));*/
m_actionImport->setIcon(QIcon(QPixmap("resources/imgs/import.png")));
m_actionExport->setIcon(QIcon(QPixmap("resources/imgs/export.png")));
m_actionOptions->setIcon(QIcon(QPixmap("resources/imgs/settings.png")));
m_actionProcessManager->setIcon(QIcon(QPixmap("resources/imgs/process.png")));
m_actionPlugins->setIcon(QIcon(QPixmap("resources/imgs/plugin.png")));
QToolBar *toolbar = addToolBar("Main");
toolbar->setMinimumHeight(48);
toolbar->setIconSize(QSize(32, 32));
toolbar->setMovable(false);
toolbar->addAction(m_actionNewGame);
toolbar->addAction(m_actionEditGame);
toolbar->addAction(m_actionDeleteGame);
toolbar->addSeparator();
toolbar->addAction(m_actionShowEmulators);
/*toolbar->addAction(m_actionUninstallGame);*/
toolbar->addSeparator();
toolbar->addAction(m_actionProcessManager);
toolbar->addSeparator();
toolbar->addAction(m_actionLaunchGame);
}
PluginCreator::PluginCreator(QWidget* parent)
: QMainWindow(parent)
{
state = S_INIT;
item = 0;
view = 0;
dock = 0;
manualDock = 0;
helpBrowser = 0;
setupUi(this);
QToolBar* fileTools = addToolBar(tr("File Operations"));
fileTools->setObjectName("FileOperations");
actionNew->setIcon(*icons[fileNew_ICON]);
actionNew->setShortcut(QKeySequence(QKeySequence::New));
fileTools->addAction(actionNew);
actionOpen->setIcon(*icons[fileOpen_ICON]);
actionOpen->setShortcut(QKeySequence(QKeySequence::Open));
fileTools->addAction(actionOpen);
actionSave->setIcon(*icons[fileSave_ICON]);
actionSave->setShortcut(QKeySequence(QKeySequence::Save));
fileTools->addAction(actionSave);
actionQuit->setShortcut(QKeySequence(QKeySequence::Quit));
actionManual->setIcon(QIcon(":/data/help.png"));
actionManual->setShortcut(QKeySequence(QKeySequence::HelpContents));
fileTools->addAction(actionManual);
QToolBar* editTools = addToolBar(tr("Edit Operations"));
editTools->setObjectName("EditOperations");
actionUndo->setIcon(*icons[undo_ICON]);
actionUndo->setShortcut(QKeySequence(QKeySequence::Undo));
editTools->addAction(actionUndo);
actionRedo->setIcon(*icons[redo_ICON]);
actionRedo->setShortcut(QKeySequence(QKeySequence::Redo));
editTools->addAction(actionRedo);
actionUndo->setEnabled(false);
actionRedo->setEnabled(false);
log->setReadOnly(true);
log->setMaximumBlockCount(1000);
readSettings();
setState(S_EMPTY);
connect(run, SIGNAL(clicked()), SLOT(runClicked()));
connect(stop, SIGNAL(clicked()), SLOT(stopClicked()));
connect(actionOpen, SIGNAL(triggered()), SLOT(loadPlugin()));
connect(actionSave, SIGNAL(triggered()), SLOT(savePlugin()));
connect(actionNew, SIGNAL(triggered()), SLOT(newPlugin()));
connect(actionQuit, SIGNAL(triggered()), SLOT(close()));
connect(actionManual, SIGNAL(triggered()), SLOT(showManual()));
connect(actionUndo, SIGNAL(triggered()), textEdit, SLOT(undo()));
connect(actionRedo, SIGNAL(triggered()), textEdit, SLOT(redo()));
connect(textEdit, SIGNAL(undoAvailable(bool)), actionUndo, SLOT(setEnabled(bool)));
connect(textEdit, SIGNAL(redoAvailable(bool)), actionRedo, SLOT(setEnabled(bool)));
connect(textEdit, SIGNAL(textChanged()), SLOT(textChanged()));
}
MainWindow::MainWindow( QWidget* parent )
: QMainWindow( parent ), filename(), infoFile() {
fileNewA = new QAction( QIcon(":/fileNew.png"), tr( "New" ), this );
fileNewA->setShortcut( tr("Ctrl+N") );
fileNewA->setStatusTip( tr("Create a New NeuralNetwork") );
fileNewA->setCheckable( false );
connect( fileNewA, SIGNAL( triggered() ),
this, SLOT( fileNew() ) );
fileLoadA = new QAction( QIcon(":/fileOpen.png"), tr( "Open" ), this );
fileLoadA->setShortcut( tr("Ctrl+O") );
fileLoadA->setStatusTip( tr("Load a NeuralNetwork from file") );
fileLoadA->setCheckable( false );
connect( fileLoadA, SIGNAL( triggered() ),
this, SLOT( fileLoad() ) );
fileCloseA = new QAction( QIcon(":/fileClose.png"), tr( "Close" ), this );
fileCloseA->setShortcut( tr("Ctrl+W") );
fileCloseA->setStatusTip( tr("Close NeuralNetwork") );
fileCloseA->setCheckable( false );
connect( fileCloseA, SIGNAL( triggered() ),
this, SLOT( fileClose() ) );
fileSaveA = new QAction( QIcon(":/fileSave.png"), tr( "Save" ), this );
fileSaveA->setShortcut( tr("Ctrl+S") );
fileSaveA->setStatusTip( tr("Save NeuralNetwork") );
fileSaveA->setCheckable( false );
connect( fileSaveA, SIGNAL( triggered() ),
this, SLOT( fileSave() ) );
fileSaveasA = new QAction( QIcon(":/fileSaveas.png"), tr( "Save as ..." ), this );
fileSaveasA->setShortcut( tr("Ctrl+S") );
fileSaveasA->setStatusTip( tr("Save NeuralNetwork with differente name") );
fileSaveasA->setCheckable( false );
connect( fileSaveasA, SIGNAL( triggered() ),
this, SLOT( fileSaveas() ) );
addClusterA = new QAction( QIcon(":/addCluster.png"), tr( "Add a new Cluster" ), this );
addClusterA->setShortcut( tr("Alt+C") );
addClusterA->setStatusTip( tr("Create a new Cluster") );
addClusterA->setCheckable( false );
connect( addClusterA, SIGNAL( triggered() ),
this, SLOT( addCluster() ) );
addLinkerA = new QAction( QIcon(":/addLinker.png"), tr( "Add a new Linker" ), this );
addLinkerA->setShortcut( tr("Alt+L") );
addLinkerA->setStatusTip( tr("Create a new Linker") );
addLinkerA->setCheckable( false );
connect( addLinkerA, SIGNAL( triggered() ),
this, SLOT( addLinker() ) );
QAction* showCreditsA = new QAction( tr( "Credits" ), this );
connect( showCreditsA, SIGNAL( triggered() ),
this, SLOT( credits() ) );
// ------- TOOLBAR
QToolBar* fileT = addToolBar( tr("File") );
fileT->setObjectName( "File-ToolBar" );
fileT->addAction( fileNewA );
fileT->addAction( fileLoadA );
fileT->addAction( fileCloseA );
fileT->addAction( fileSaveA );
fileT->addAction( fileSaveasA );
fileT->setMovable( false );
fileT = addToolBar( tr("Edit") );
fileT->setObjectName( "Edit-ToolBar" );
fileT->addAction( addClusterA );
fileT->addAction( addLinkerA );
fileT->setMovable( false );
// ------- MENU
QMenuBar* bar = menuBar();
QMenu* menu = bar->addMenu( tr("File") );
menu->addAction( fileNewA );
menu->addAction( fileLoadA );
menu->addAction( fileCloseA );
menu->addAction( fileSaveA );
menu->addAction( fileSaveasA );
menu = bar->addMenu( tr("Edit") );
menu->addAction( addClusterA );
menu->addAction( addLinkerA );
QMenu* mviews = bar->addMenu( tr("Views") );
menu = bar->addMenu( tr("&About") );
menu->addAction( showCreditsA );
statusBar()->setStyleSheet( "::item { border: 0px }" );
statusBar()->showMessage( tr("Ready") );
centre = new NeuralNetView( this );
nn = 0;
centre->setNeuralNet( 0 );
setCentralWidget( centre );
createBrowser();
createPlotter();
// --- add view/hide checkboxes in the view menu for Toolbars/DockWidgets
QMenu* tmp = createPopupMenu();
QList<QAction*> acts = tmp->actions();
foreach( QAction* a, acts ) {
mviews->addAction( a );
}
PianorollEditor::PianorollEditor(QWidget* parent)
: QMainWindow(parent)
{
setWindowTitle(QString("MuseScore"));
_score = 0;
staff = 0;
QWidget* mainWidget = new QWidget;
QGridLayout* layout = new QGridLayout;
mainWidget->setLayout(layout);
layout->setSpacing(0);
QToolBar* tb = addToolBar(tr("toolbar1"));
tb->addAction(getAction("undo"));
tb->addAction(getAction("redo"));
tb->addSeparator();
tb->addAction(getAction("sound-on"));
#ifdef HAS_MIDI
tb->addAction(getAction("midi-on"));
#endif
QAction* a = getAction("follow");
a->setCheckable(true);
a->setChecked(preferences.followSong);
tb->addAction(a);
tb->addSeparator();
tb->addAction(getAction("rewind"));
tb->addAction(getAction("play"));
tb->addSeparator();
//-------------
tb = addToolBar(tr("toolbar2"));
layout->addWidget(tb, 1, 0, 1, 2);
VoiceSelector* vs = new VoiceSelector;
tb->addWidget(vs);
tb->addSeparator();
tb->addWidget(new QLabel(tr("Cursor:")));
pos = new Awl::PosLabel;
tb->addWidget(pos);
Awl::PitchLabel* pl = new Awl::PitchLabel();
tb->addWidget(pl);
tb->addSeparator();
tb->addWidget(new QLabel(tr("Velocity:")));
veloType = new QComboBox;
veloType->addItem(tr("offset"), OFFSET_VAL);
veloType->addItem(tr("user"), USER_VAL);
tb->addWidget(veloType);
velocity = new QSpinBox;
velocity->setRange(-1, 127);
velocity->setSpecialValueText("--");
velocity->setReadOnly(true);
tb->addWidget(velocity);
tb->addWidget(new QLabel(tr("Pitch:")));
pitch = new Awl::PitchEdit;
pitch->setReadOnly(true);
tb->addWidget(pitch);
double xmag = .1;
gv = new PianoView;
gv->scale(xmag, 1.0);
layout->addWidget(gv, 3, 1);
ruler = new Ruler;
ruler->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
ruler->setFixedHeight(rulerHeight);
ruler->setMag(xmag, 1.0);
layout->addWidget(ruler, 2, 1);
Piano* piano = new Piano;
piano->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding);
piano->setFixedWidth(pianoWidth);
layout->addWidget(piano, 3, 0);
setCentralWidget(mainWidget);
connect(gv->verticalScrollBar(), SIGNAL(valueChanged(int)), piano, SLOT(setYpos(int)));
connect(gv->horizontalScrollBar(), SIGNAL(valueChanged(int)), ruler, SLOT(setXpos(int)));
connect(gv, SIGNAL(xposChanged(int)), ruler, SLOT(setXpos(int)));
connect(gv, SIGNAL(magChanged(double,double)), ruler, SLOT(setMag(double,double)));
connect(gv, SIGNAL(magChanged(double,double)), piano, SLOT(setMag(double,double)));
connect(gv, SIGNAL(pitchChanged(int)), pl, SLOT(setPitch(int)));
connect(gv, SIGNAL(pitchChanged(int)), piano, SLOT(setPitch(int)));
connect(piano, SIGNAL(pitchChanged(int)), pl, SLOT(setPitch(int)));
connect(gv, SIGNAL(posChanged(const Pos&)), pos, SLOT(setValue(const Pos&)));
connect(gv, SIGNAL(posChanged(const Pos&)), ruler, SLOT(setPos(const Pos&)));
connect(ruler, SIGNAL(posChanged(const Pos&)), pos, SLOT(setValue(const Pos&)));
connect(ruler, SIGNAL(locatorMoved(int)), SLOT(moveLocator(int)));
connect(veloType, SIGNAL(activated(int)), SLOT(veloTypeChanged(int)));
connect(velocity, SIGNAL(valueChanged(int)), SLOT(velocityChanged(int)));
connect(gv->scene(), SIGNAL(selectionChanged()), SLOT(selectionChanged()));
connect(piano, SIGNAL(keyPressed(int)), SLOT(keyPressed(int)));
connect(piano, SIGNAL(keyReleased(int)), SLOT(keyReleased(int)));
resize(800, 400);
QActionGroup* ag = new QActionGroup(this);
a = new QAction(this);
a->setData("delete");
a->setShortcut(Qt::Key_Delete);
ag->addAction(a);
addActions(ag->actions());
connect(ag, SIGNAL(triggered(QAction*)), SLOT(cmd(QAction*)));
}
/**
\param bcont
**/
int entryPoint ( BfBulmaFact *bcont )
{
BL_FUNC_DEBUG
g_selcanales = new BcCanalSeleccionarView ( bcont->company(), 0 );
g_selccostes = new BcCentroCosteSeleccionarView (bcont->company(), 0);
/// Inicializa el sistema de traducciones 'gettext'.
setlocale ( LC_ALL, "" );
blBindTextDomain ( "pluginbf_canalyccoste", g_confpr->value( CONF_DIR_TRADUCCION ).toLatin1().constData() );
g_pluginbf_canalyccoste = bcont;
QMenu *pPluginMenu = bcont->menuMaestro;
pPluginMenu->addSeparator();
BlAction *accionA = new BlAction ( _ ( "&Canal" ), 0 );
accionA->setStatusTip ( _ ( "Ver Canales" ) );
accionA->setWhatsThis ( _ ( "Ver Canales" ) );
accionA->setIcon ( QIcon ( QString::fromUtf8 ( ":/BulmaCont32x32/images/png/i_canales.xpm" ) ) );
accionA->setObjectName("mui_actionCanal");
pPluginMenu->addAction ( accionA );
BlAction *accionB = new BlAction ( _ ( "&Centros de Coste" ), 0 );
accionB->setStatusTip ( _ ( "Ver Centros de Coste" ) );
accionB->setWhatsThis ( _ ( "Ver Centros de Coste" ) );
accionB->setIcon ( QIcon ( QString::fromUtf8 ( ":/BulmaCont32x32/images/png/i_centroCoste.xpm" ) ) );
accionB->setObjectName("mui_actionCCoste");
pPluginMenu->addAction ( accionB );
/// Añadimos la nueva opción al menú principal del programa.
/// Usamos un toolBox especial para meter los botones de contabilidad.
QToolBar *toolCont = bcont->findChild<QToolBar *> ( "contabilidad" );
if ( !toolCont) {
toolCont = new QToolBar(bcont);
toolCont->setObjectName("contabilidad");
toolCont->setFocusPolicy(Qt::TabFocus);
toolCont->setOrientation(Qt::Horizontal);
toolCont->setIconSize(QSize(32, 32));
toolCont->setWindowTitle(N_("Contabilidad", 0));
toolCont->setToolTip(N_("Contabilidad", 0));
toolCont->setStatusTip(N_("Contabilidad", 0));
toolCont->setWhatsThis(N_("Contabilidad", 0));
toolCont->setAccessibleName(N_("Contabilidad", 0));
toolCont->setAccessibleDescription(N_("Contabilidad", 0));
bcont->addToolBar(Qt::TopToolBarArea, toolCont);
} // end if
toolCont->addAction(accionA);
toolCont->addAction(accionB);
// =================================================
/// Vamos a probar con un docwindow.
BlDockWidget *doc1 = new BlDockWidget ( _ ( "Selector de Canales" ), bcont );
doc1->setObjectName("mui_selcanales");
doc1->setFeatures ( QDockWidget::AllDockWidgetFeatures );
doc1->setGeometry ( 100, 100, 100, 500 );
doc1->resize ( 330, 250 );
bcont->addDockWidget ( Qt::RightDockWidgetArea, doc1 );
doc1->show();
doc1->setWidget ( g_selcanales );
// =================================================
/**
*
*
*
*
*/
// =================================================
/// Vamos a probar con un docwindow.
BlDockWidget *doc2 = new BlDockWidget ( _ ( "Selector de Centros de Coste" ), bcont );
doc2->setObjectName("mui_selcostes");
doc2->setFeatures ( QDockWidget::AllDockWidgetFeatures );
doc2->setGeometry ( 100, 100, 100, 500 );
doc2->resize ( 330, 250 );
bcont->addDockWidget ( Qt::RightDockWidgetArea, doc2 );
doc2->show();
doc2->setWidget ( g_selccostes );
return 0;
}
void BitcoinGUI::createToolBars()
{
QToolBar *toolbar = addToolBar(tr("Tabs toolbar"));
toolbar->setObjectName("toolbar");
toolbar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
addToolBar(Qt::LeftToolBarArea,toolbar);
toolbar->setOrientation(Qt::Vertical);
toolbar->setMovable(false);
QWidget* header = new QWidget();
header->setMinimumSize(140, 45);
header->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
header->setStyleSheet("QWidget { background-color: rgb(0,0,0); background-repeat: no-repeat; background-image: url(:/images/header); background-position: top center; }");
toolbar->addWidget(header);
toolbar->addAction(overviewAction);
toolbar->addAction(sendCoinsAction);
toolbar->addAction(receiveCoinsAction);
toolbar->addAction(historyAction);
toolbar->addAction(addressBookAction);
toolbar->addAction(bittrexPageAction);
toolbar->addAction(shockBotAction);
toolbar->addAction(blockAction);
toolbar->addAction(socialPageAction);
toolbar->addAction(chatAction);
toolbar->addAction(exportAction);
}
InputStrList::InputStrList( QGridLayout *layout,int &row,
const QString & id,
const QStringList &sl, ListMode lm,
const QString & docs)
: m_default(sl), m_strList(sl), m_docs(docs), m_id(id)
{
m_lab = new HelpLabel( id );
m_le = new QLineEdit;
m_le->clear();
QToolBar *toolBar = new QToolBar;
toolBar->setIconSize(QSize(24,24));
m_add = toolBar->addAction(QIcon(QString::fromAscii(":/images/add.png")),QString(),
this,SLOT(addString()));
m_add->setToolTip(tr("Add item"));
m_del = toolBar->addAction(QIcon(QString::fromAscii(":/images/del.png")),QString(),
this,SLOT(delString()));
m_del->setToolTip(tr("Delete selected item"));
m_upd = toolBar->addAction(QIcon(QString::fromAscii(":/images/refresh.png")),QString(),
this,SLOT(updateString()));
m_upd->setToolTip(tr("Update selected item"));
m_lb = new QListWidget;
//m_lb->setMinimumSize(400,100);
foreach (QString s, m_strList) m_lb->addItem(s);
m_brFile=0;
m_brDir=0;
if (lm!=ListString)
{
if (lm&ListFile)
{
m_brFile = toolBar->addAction(QIcon(QString::fromAscii(":/images/file.png")),QString(),
this,SLOT(browseFiles()));
m_brFile->setToolTip(tr("Browse to a file"));
}
if (lm&ListDir)
{
m_brDir = toolBar->addAction(QIcon(QString::fromAscii(":/images/folder.png")),QString(),
this,SLOT(browseDir()));
m_brDir->setToolTip(tr("Browse to a folder"));
}
}
QHBoxLayout *rowLayout = new QHBoxLayout;
rowLayout->addWidget( m_le );
rowLayout->addWidget( toolBar );
layout->addWidget( m_lab, row,0 );
layout->addLayout( rowLayout, row,1,1,2 );
layout->addWidget( m_lb, row+1,1,1,2 );
row+=2;
m_value = m_strList;
connect(m_le, SIGNAL(returnPressed()),
this, SLOT(addString()) );
connect(m_lb, SIGNAL(currentTextChanged(const QString &)),
this, SLOT(selectText(const QString &)));
connect( m_lab, SIGNAL(enter()), SLOT(help()) );
connect( m_lab, SIGNAL(reset()), SLOT(reset()) );
}
void BitcreditGUI::createToolBars()
{
QLabel *mylabel = new QLabel(this);
mylabel->setPixmap(QPixmap(":images/head"));
mylabel->show();
QToolBar *toolbar = addToolBar(tr("Menu"));
toolbar->setObjectName("toolbar");
addToolBar(Qt::LeftToolBarArea, toolbar);
toolbar->addWidget(mylabel);
toolbar->setOrientation(Qt::Vertical);
toolbar->setMovable(false);
toolbar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
toolbar->setIconSize(QSize(50,20));
if(walletFrame)
{
toolbar->addAction(overviewAction);
toolbar->addAction(sendCoinsAction);
toolbar->addAction(receiveCoinsAction);
toolbar->addAction(historyAction);
toolbar->addAction(exchangeAction);
toolbar->addAction(blockAction);
toolbar->addAction(bankstatsAction);
toolbar->addAction(sendMessagesAction);
toolbar->addAction(messageAction);
toolbar->addAction(invoiceAction);
toolbar->addAction(receiptAction);
toolbar->addAction(voteCoinsAction);
toolbar->addAction(chatAction);
overviewAction->setChecked(true);
}
//QWidget* spacer = new QWidget();
// spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
// toolbar->addWidget(spacer);
toolbar->addAction(optionsAction);
//spacer->setObjectName("spacer");
toolbar->setStyleSheet("#toolbar { font-weight:600;border:none;height:100%;padding-top:20px; background: rgb(0, 0, 0); text-align: left; color: white;min-width:180px;max-width:180px;} QToolBar QToolButton:hover {background:rgb(28, 29, 33);} QToolBar QToolButton:checked {background:rgba(28, 29, 33, 100);} QToolBar QToolButton { font-weight:600;font-size:10px;font-family:'Century Gothic';padding-left:20px;padding-right:181px;padding-top:4px;padding-bottom:4px; width:100%; color: white; text-align: left; background:transparent;text-transform:uppercase; }");
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent), ui(new Ui::MainWindow),
logNewMessages(0), logHasErrors(false), showNewLogNumber(true)
{
ui->setupUi(this);
setWindowIcon(QIcon(c_icon_app));
setWindowTitle(c_qtau_name);
setAcceptDrops(true);
setContextMenuPolicy(Qt::NoContextMenu);
//-----------------------------------------
QLabel *meterLabel = new QLabel(QString("%1/%2") .arg(ns.notesInBar).arg(ns.noteLength), this);
QLabel *tempoLabel = new QLabel(QString("%1 %2").arg(ns.tempo).arg(tr("bpm")), this);
QHBoxLayout *bpmHBL = new QHBoxLayout();
bpmHBL->setContentsMargins(0,0,0,0);
bpmHBL->addSpacing(5);
bpmHBL->addWidget(meterLabel);
bpmHBL->addWidget(tempoLabel);
bpmHBL->addSpacing(5);
QFrame *tempoPanel = new QFrame(this);
tempoPanel->setMinimumSize(c_piano_min_width, c_meter_min_height);
tempoPanel->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
tempoPanel->setContentsMargins(1,0,1,1);
tempoPanel->setFrameStyle(QFrame::Panel | QFrame::Raised);
tempoPanel->setLayout(bpmHBL);
meter = new qtauMeterBar(this);
meter->setMinimumHeight(c_meter_min_height);
meter->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
meter->setContentsMargins(0,0,0,0);
piano = new qtauPiano(ui->centralWidget);
piano->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Expanding);
piano->setMinimumSize(c_piano_min_width, c_piano_min_height);
piano->setContentsMargins(0,0,0,0);
zoom = new QSlider(Qt::Horizontal, ui->centralWidget);
zoom->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
zoom->setRange(0, c_zoom_num - 1);
zoom->setSingleStep(1);
zoom->setPageStep(1);
zoom->setValue(cdef_zoom_index);
zoom->setMinimumWidth(c_piano_min_width);
zoom->setGeometry(0,0,c_piano_min_width,10);
zoom->setContentsMargins(0,0,0,0);
noteEditor = new qtauNoteEditor(ui->centralWidget);
noteEditor->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
noteEditor->setContentsMargins(0,0,0,0);
hscr = new QScrollBar(Qt::Horizontal, ui->centralWidget);
vscr = new QScrollBar(Qt::Vertical, ui->centralWidget);
hscr->setContentsMargins(0,0,0,0);
vscr->setContentsMargins(0,0,0,0);
hscr->setRange(0, ns.note.width() * ns.notesInBar * cdef_bars);
vscr->setRange(0, ns.note.height() * 12 * ns.numOctaves);
hscr->setSingleStep(ns.note.width());
vscr->setSingleStep(ns.note.height());
hscr->setContextMenuPolicy(Qt::NoContextMenu);
vscr->setContextMenuPolicy(Qt::NoContextMenu);
//---- vocal and music waveform panels, hidden until synthesized (vocal wave) and/or loaded (music wave)
QScrollBar *dummySB = new QScrollBar(this);
dummySB->setOrientation(Qt::Vertical);
dummySB->setRange(0,0);
dummySB->setEnabled(false);
QFrame *vocalControls = new QFrame(this);
vocalControls->setContentsMargins(0,0,0,0);
vocalControls->setMinimumSize(c_piano_min_width, c_waveform_min_height);
vocalControls->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Expanding);
vocalControls->setFrameStyle(QFrame::Panel | QFrame::Raised);
vocalWave = new qtauWaveform(this);
vocalWave->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
vocalWave->setMinimumHeight(c_waveform_min_height);
vocalWave->setContentsMargins(0,0,0,0);
QHBoxLayout *vocalWaveL = new QHBoxLayout();
vocalWaveL->setContentsMargins(0,0,0,0);
vocalWaveL->setSpacing(0);
vocalWaveL->addWidget(vocalControls);
vocalWaveL->addWidget(vocalWave);
vocalWaveL->addWidget(dummySB);
vocalWavePanel = new QWidget(this);
vocalWavePanel->setContentsMargins(0,0,0,0);
vocalWavePanel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
vocalWavePanel->setLayout(vocalWaveL);
vocalWavePanel->setVisible(false);
//---------
QScrollBar *dummySB2 = new QScrollBar(this);
dummySB2->setOrientation(Qt::Vertical);
dummySB2->setRange(0,0);
dummySB2->setEnabled(false);
QFrame *musicControls = new QFrame(this);
musicControls->setContentsMargins(0,0,0,0);
musicControls->setMinimumSize(c_piano_min_width, c_waveform_min_height);
musicControls->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Expanding);
musicControls->setFrameStyle(QFrame::Panel | QFrame::Raised);
musicWave = new qtauWaveform(this);
musicWave->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
musicWave->setMinimumHeight(c_waveform_min_height);
musicWave->setContentsMargins(0,0,0,0);
QHBoxLayout *musicWaveL = new QHBoxLayout();
musicWaveL->setContentsMargins(0,0,0,0);
musicWaveL->setSpacing(0);
musicWaveL->addWidget(musicControls);
musicWaveL->addWidget(musicWave);
musicWaveL->addWidget(dummySB2);
musicWavePanel = new QWidget(this);
musicWavePanel->setContentsMargins(0,0,0,0);
musicWavePanel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
musicWavePanel->setLayout(musicWaveL);
musicWavePanel->setVisible(false);
//---- notes' dynamics setup area --------------
QGridLayout *dynBtnL = new QGridLayout();
QString btnNames[c_dynbuttons_num] = {"VEL", "DYN", "BRE", "BRI", "CLE", "OPE", "GEN", "POR", "PIT", "PBS"};
for (int i = 0; i < c_dynbuttons_num; ++i)
{
qtauDynLabel *l = new qtauDynLabel(btnNames[i], this);
l->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
dynBtnL->addWidget(l, i / 2, i % 2, 1, 1);
l->setStyleSheet(c_dynlbl_css_off);
l->setFrameStyle(QFrame::Box);
l->setLineWidth(1);
connect(l, SIGNAL(leftClicked()), SLOT(dynBtnLClicked()));
connect(l, SIGNAL(rightClicked()), SLOT(dynBtnRClicked()));
}
dynBtnL->setRowStretch(c_dynbuttons_num / 2, 100);
QFrame *dynBtnPanel = new QFrame(this);
dynBtnPanel->setContentsMargins(0,0,0,0);
dynBtnPanel->setMinimumSize(c_piano_min_width, c_drawzone_min_height);
dynBtnPanel->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Expanding);
dynBtnPanel->setFrameStyle(QFrame::Panel | QFrame::Raised);
dynBtnPanel->setLayout(dynBtnL);
drawZone = new qtauDynDrawer(ui->centralWidget);
drawZone->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
drawZone->setMinimumHeight(c_drawzone_min_height);
drawZone->setContentsMargins(0,0,0,0);
QScrollBar *dummySB3 = new QScrollBar(this);
dummySB3->setOrientation(Qt::Vertical);
dummySB3->setRange(0,0);
dummySB3->setEnabled(false);
QHBoxLayout *singParamsL = new QHBoxLayout();
singParamsL->setContentsMargins(0,0,0,0);
singParamsL->setSpacing(0);
singParamsL->addWidget(dynBtnPanel);
singParamsL->addWidget(drawZone);
singParamsL->addWidget(dummySB3);
drawZonePanel = new QWidget(this);
drawZonePanel->setContentsMargins(0,0,0,0);
drawZonePanel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
drawZonePanel->setLayout(singParamsL);
//---- Combining editor panels into hi-level layout ------
QGridLayout *gl = new QGridLayout();
gl->setContentsMargins(0,0,0,0);
gl->setSpacing(0);
gl->addWidget(tempoPanel, 0, 0, 1, 1);
gl->addWidget(meter, 0, 1, 1, 1);
gl->addWidget(piano, 1, 0, 1, 1);
gl->addWidget(zoom, 2, 0, 1, 1);
gl->addWidget(noteEditor, 1, 1, 1, 1);
gl->addWidget(hscr, 2, 1, 1, 1);
gl->addWidget(vscr, 1, 2, 1, 1);
QWidget *editorUpperPanel = new QWidget(this);
editorUpperPanel->setContentsMargins(0,0,0,0);
editorUpperPanel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
editorUpperPanel->setMaximumSize(9000,9000);
editorUpperPanel->setLayout(gl);
editorSplitter = new QSplitter(Qt::Vertical, this);
editorSplitter->setContentsMargins(0,0,0,0);
editorSplitter->addWidget(editorUpperPanel);
editorSplitter->addWidget(vocalWavePanel);
editorSplitter->addWidget(musicWavePanel);
editorSplitter->addWidget(drawZonePanel);
editorSplitter->setStretchFactor(0, 1);
editorSplitter->setStretchFactor(1, 0);
editorSplitter->setStretchFactor(2, 0);
editorSplitter->setStretchFactor(3, 0);
QVBoxLayout *edVBL = new QVBoxLayout();
edVBL->setContentsMargins(0,0,0,0);
edVBL->addWidget(editorSplitter);
QWidget *editorPanel = new QWidget(this);
editorPanel->setContentsMargins(0,0,0,0);
editorPanel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
editorPanel->setMaximumSize(9000,9000);
editorPanel->setLayout(edVBL);
//---- Voicebank setup tab ---------------------
QWidget *voicesPanel = new QWidget(this);
voicesPanel->setContentsMargins(0,0,0,0);
voicesPanel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
voicesPanel->setMaximumSize(9000,9000);
//---- Plugins setup tab -----------------------
QWidget *pluginsPanel = new QWidget(this);
pluginsPanel->setContentsMargins(0,0,0,0);
pluginsPanel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
pluginsPanel->setMaximumSize(9000,9000);
//---- Settings tab ----------------------------
QWidget *settingsPanel = new QWidget(this);
settingsPanel->setContentsMargins(0,0,0,0);
settingsPanel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
settingsPanel->setMaximumSize(9000,9000);
//---- Documentation tab -----------------------
QWidget *docsPanel = new QWidget(this);
docsPanel->setContentsMargins(0,0,0,0);
docsPanel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
docsPanel->setMaximumSize(9000,9000);
QTextEdit *docpad = new QTextEdit(this);
docpad->setReadOnly(true);
docpad->setUndoRedoEnabled(false);
docpad->setContextMenuPolicy(Qt::NoContextMenu);
QFile embeddedDocTxt(c_doc_txt);
if (embeddedDocTxt.open(QFile::ReadOnly))
{
QTextStream ts(&embeddedDocTxt);
ts.setAutoDetectUnicode(true);
ts.setCodec("UTF-8");
docpad->setText(ts.readAll());
embeddedDocTxt.close();
}
QGridLayout *docL = new QGridLayout();
docL->setContentsMargins(0,0,0,0);
docL->addWidget(docpad, 0, 0, 1, 1);
docsPanel->setLayout(docL);
//---- Log tab ---------------------------------
QWidget *logPanel = new QWidget(this);
logPanel->setContentsMargins(0,0,0,0);
logPanel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
logPanel->setMaximumSize(9000,9000);
logpad = new QTextEdit(this);
logpad->setReadOnly(true);
logpad->setUndoRedoEnabled(false);
logpad->setContextMenuPolicy(Qt::NoContextMenu);
logpad->setStyleSheet("p, pre { white-space: 1.2; }");
QGridLayout *logL = new QGridLayout();
logL->setContentsMargins(0,0,0,0);
logL->addWidget(logpad, 0, 0, 1, 1);
logPanel->setLayout(logL);
//---- Combining tabs togeter ------------------
tabs = new QTabWidget(this);
tabs->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
tabs->setContentsMargins(0,0,0,0);
tabs->setMaximumSize(9000, 9000);
tabs->setTabPosition(QTabWidget::South);
tabs->setMovable(false); // just to be sure
tabs->addTab(editorPanel, QIcon(c_icon_editor), tr("Editor"));
tabs->addTab(voicesPanel, QIcon(c_icon_voices), tr("Voices"));
tabs->addTab(pluginsPanel, QIcon(c_icon_plugins), tr("Plugins"));
tabs->addTab(settingsPanel, QIcon(c_icon_settings), tr("Settings"));
tabs->addTab(docsPanel, QIcon(c_icon_doc), tr("Documentation"));
tabs->addTab(logPanel, QIcon(c_icon_log), tr("Log"));
tabs->widget(0)->setContentsMargins(0,0,0,0);
tabs->widget(1)->setContentsMargins(0,0,0,0);
tabs->widget(2)->setContentsMargins(0,0,0,0);
tabs->widget(3)->setContentsMargins(0,0,0,0);
tabs->widget(4)->setContentsMargins(0,0,0,0);
tabs->widget(5)->setContentsMargins(0,0,0,0);
logTabTextColor = tabs->tabBar()->tabTextColor(5);
connect(tabs, SIGNAL(currentChanged(int)), SLOT(onTabSelected(int)));
QVBoxLayout *vbl = new QVBoxLayout();
vbl->setContentsMargins(0,0,0,0);
vbl->addWidget(tabs);
ui->centralWidget->setContentsMargins(0,0,0,0);
ui->centralWidget->setLayout(vbl);
//---- Toolbars --------------------------------
QToolBar *fileTB = new QToolBar("Fileops", this);
QToolBar *playerTB = new QToolBar("Playback", this);
QToolBar *toolsTB = new QToolBar("Toolset", this);
fileTB ->setFloatable(false);
playerTB->setFloatable(false);
toolsTB ->setFloatable(false);
fileTB->addAction(ui->actionSave);
fileTB->addAction(ui->actionSave_audio_as);
fileTB->addAction(ui->actionUndo);
fileTB->addAction(ui->actionRedo);
playerTB->addAction(ui->actionPlay);
playerTB->addAction(ui->actionStop);
playerTB->addAction(ui->actionBack);
playerTB->addAction(ui->actionRepeat);
volume = new QSlider(Qt::Horizontal, this);
volume->setMaximum(100);
volume->setSingleStep(1);
volume->setPageStep(1);
volume->setValue(settings.value(c_key_sound, 50).toInt());
volume->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
connect(playerTB, SIGNAL(orientationChanged(Qt::Orientation)), volume, SLOT(setOrientation(Qt::Orientation)));
muteBtn = new QAction(QIcon(c_icon_sound), "", this);
muteBtn->setCheckable(true);
connect(muteBtn, SIGNAL(toggled(bool)), SLOT(onMute(bool)));
playerTB->addWidget(volume);
playerTB->addAction(muteBtn);
QComboBox *quantizeCombo = new QComboBox(this);
QComboBox *lengthCombo = new QComboBox(this);
quantizeCombo->addItems(QStringList() << "Q/4" << "Q/8" << "Q/16" << "Q/32" << "Q/64");
lengthCombo ->addItems(QStringList() << "♪/4" << "♪/8" << "♪/16" << "♪/32" << "♪/64");
quantizeCombo->setCurrentIndex(3);
lengthCombo ->setCurrentIndex(3);
toolsTB->addAction(ui->actionEdit_Mode);
toolsTB->addAction(ui->actionGrid_Snap);
toolsTB->addSeparator();
toolsTB->addWidget(quantizeCombo);
toolsTB->addWidget(lengthCombo);
addToolBar(fileTB);
addToolBar(playerTB);
addToolBar(toolsTB);
toolbars.append(fileTB);
toolbars.append(playerTB);
toolbars.append(toolsTB);
//----------------------------------------------
connect(quantizeCombo, SIGNAL(currentIndexChanged(int)), SLOT(onQuantizeSelected(int)));
connect(lengthCombo, SIGNAL(currentIndexChanged(int)), SLOT(onNotelengthSelected(int)));
connect(vsLog::instance(), &vsLog::message, this, &MainWindow::onLog);
connect(piano, &qtauPiano ::heightChanged, this, &MainWindow::onPianoHeightChanged);
connect(noteEditor, &qtauNoteEditor ::widthChanged, this, &MainWindow::onNoteEditorWidthChanged);
connect(meter, &qtauMeterBar ::scrolled, this, &MainWindow::notesHScrolled);
connect(piano, &qtauPiano ::scrolled, this, &MainWindow::notesVScrolled);
connect(drawZone, &qtauDynDrawer ::scrolled, this, &MainWindow::notesHScrolled);
connect(noteEditor, &qtauNoteEditor ::vscrolled, this, &MainWindow::notesVScrolled);
connect(noteEditor, &qtauNoteEditor ::hscrolled, this, &MainWindow::notesHScrolled);
connect(vocalWave, &qtauWaveform ::scrolled, this, &MainWindow::notesHScrolled);
connect(musicWave, &qtauWaveform ::scrolled, this, &MainWindow::notesHScrolled);
connect(vscr, &QScrollBar ::valueChanged, this, &MainWindow::vertScrolled);
connect(hscr, &QScrollBar ::valueChanged, this, &MainWindow::horzScrolled);
connect(noteEditor, &qtauNoteEditor ::rmbScrolled, this, &MainWindow::onEditorRMBScrolled);
connect(noteEditor, &qtauNoteEditor ::requestsOffset, this, &MainWindow::onEditorRequestOffset);
connect(zoom, &QSlider ::valueChanged, this, &MainWindow::onZoomed);
connect(meter, &qtauMeterBar ::zoomed, this, &MainWindow::onEditorZoomed);
connect(noteEditor, &qtauNoteEditor ::zoomed, this, &MainWindow::onEditorZoomed);
connect(drawZone, &qtauDynDrawer ::zoomed, this, &MainWindow::onEditorZoomed);
connect(vocalWave, &qtauWaveform ::zoomed, this, &MainWindow::onEditorZoomed);
connect(musicWave, &qtauWaveform ::zoomed, this, &MainWindow::onEditorZoomed);
connect(ui->actionQuit, &QAction::triggered, [=]() { this->close(); });
connect(ui->actionOpen, &QAction::triggered, this, &MainWindow::onOpenUST);
connect(ui->actionSave, &QAction::triggered, this, &MainWindow::onSaveUST);
connect(ui->actionSave_as, &QAction::triggered, this, &MainWindow::onSaveUSTAs);
connect(ui->actionUndo, &QAction::triggered, this, &MainWindow::onUndo);
connect(ui->actionRedo, &QAction::triggered, this, &MainWindow::onRedo);
connect(ui->actionDelete, &QAction::triggered, this, &MainWindow::onDelete);
connect(ui->actionEdit_Mode, &QAction::triggered, this, &MainWindow::onEditMode);
connect(ui->actionGrid_Snap, &QAction::triggered, this, &MainWindow::onGridSnap);
connect(ui->actionSave_audio_as, &QAction::triggered, this, &MainWindow::onSaveAudioAs);
//----------------------------------------------
lastScoreDir = settings.value(c_key_dir_score, "").toString();
lastAudioDir = settings.value(c_key_dir_audio, "").toString();
audioExt = settings.value(c_key_audio_codec, "").toString();
showNewLogNumber = settings.value(c_key_show_lognum, true).toBool();
if (!settings.value(c_key_dynpanel_on, true).toBool())
{
QList<int> panelSizes = editorSplitter->sizes();
panelSizes.last() = 0;
editorSplitter->setSizes(panelSizes);
}
if (settings.value(c_key_win_max, false).toBool())
showMaximized();
else
{
QRect winGeom = geometry();
QRect setGeom = settings.value(c_key_win_size, QRect(winGeom.topLeft(), minimumSize())).value<QRect>();
if (setGeom.width() >= winGeom.width() && setGeom.height() >= setGeom.height())
setGeometry(setGeom);
}
//----------------------------------------------
vsLog::instance()->enableHistory(false);
onLog(QString("\t%1 %2 @ %3").arg(tr("Launching QTau")).arg(c_qtau_ver).arg(__DATE__), ELog::success);
onLog("\t---------------------------------------------", ELog::info);
vsLog::r(); // print stored messages from program startup
onLog("\t---------------------------------------------", ELog::info);
vsLog::n();
}
SalesOrderManager::SalesOrderManager(QWidget* parent)
: QSplitter(parent)
{
model = new SalesOrderModel(this);
proxyModel = new SalesOrderProxyModel(this);
proxyModel->setSourceModel(model);
QWidget* container = new QWidget(this);
QBoxLayout* containerLayout = new QVBoxLayout(container);
containerLayout->setMargin(0);
QString actionTooltip("%1<br><b>%2</b>");
QToolBar* toolBar = new QToolBar(container);
toolBar->setIconSize(QSize(16, 16));
QAction* refreshAction = toolBar->addAction(QIcon(":/resources/icons/refresh.png"), "&Muat Ulang", this, SLOT(refresh()));
refreshAction->setShortcut(QKeySequence("F5"));
refreshAction->setToolTip(actionTooltip.arg("Muat ulang daftar pesanan").arg(refreshAction->shortcut().toString()));
QAction* newAction = toolBar->addAction(QIcon(":/resources/icons/plus.png"), "&Baru", this, SLOT(openEditor()));
newAction->setShortcut(QKeySequence("Ctrl+N"));
newAction->setToolTip(actionTooltip.arg("Pesanan baru").arg(newAction->shortcut().toString()));
QAction* closeTabAction = new QAction(this);
closeTabAction->setShortcuts(QList<QKeySequence>({QKeySequence("Esc"), QKeySequence("Ctrl+W")}));
addAction(closeTabAction);
QAction* closeAllTabsAction = new QAction(this);
closeAllTabsAction->setShortcut(QKeySequence("Ctrl+Shift+W"));
addAction(closeAllTabsAction);
containerLayout->addWidget(toolBar);
QLabel* spacer = new QLabel(toolBar);
spacer->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
toolBar->addWidget(spacer);
stateComboBox = new QComboBox(toolBar);
stateComboBox->setToolTip("Saring daftar pesanan berdasarkan status");
stateComboBox->addItem("Semua");
stateComboBox->addItem("Aktif");
stateComboBox->addItem("Selesai");
stateComboBox->addItem("Dibatalkan");
stateComboBox->setCurrentIndex(1);
toolBar->addWidget(stateComboBox);
searchEdit = new QLineEdit(toolBar);
searchEdit->setToolTip("Cari di daftar pesanan");
searchEdit->setPlaceholderText("Cari");
searchEdit->setClearButtonEnabled(true);
searchEdit->setMaxLength(100);
searchEdit->setMaximumWidth(150);
toolBar->addWidget(searchEdit);
view = new QTableView(container);
view->setToolTip("Klik ganda atau ketuk Enter untuk membuka pesanan");
view->setModel(proxyModel);
view->setAlternatingRowColors(true);
view->setSortingEnabled(true);
view->setSelectionMode(QAbstractItemView::SingleSelection);
view->setSelectionBehavior(QAbstractItemView::SelectRows);
view->setTabKeyNavigation(false);
QHeaderView* header = view->verticalHeader();
header->setVisible(false);
header->setMinimumSectionSize(20);
header->setMaximumSectionSize(20);
header->setDefaultSectionSize(20);
header = view->horizontalHeader();
header->setToolTip("Klik pada header kolom untuk mengurutkan");
header->setHighlightSections(false);
containerLayout->addWidget(view);
infoLabel = new QLabel(container);
infoLabel->setStyleSheet("font-style:italic;padding-bottom:1px;");
infoLabel->setTextInteractionFlags(Qt::TextBrowserInteraction);
containerLayout->addWidget(infoLabel);
tabWidget = new QTabWidget(this);
tabWidget->setDocumentMode(true);
tabWidget->setTabsClosable(true);
tabWidget->setMovable(true);
tabWidget->hide();
setCollapsible(0, false);
setCollapsible(1, false);
connect(closeTabAction, SIGNAL(triggered(bool)), SLOT(closeCurrentTab()));
connect(closeAllTabsAction, SIGNAL(triggered(bool)), SLOT(closeAllTabs()));
connect(tabWidget, SIGNAL(tabCloseRequested(int)), SLOT(closeTab(int)));
connect(stateComboBox, SIGNAL(currentIndexChanged(int)), SLOT(refresh()));
connect(searchEdit, SIGNAL(textChanged(QString)), SLOT(applyFilter()));
connect(view, SIGNAL(activated(QModelIndex)), SLOT(edit()));
QTimer::singleShot(0, this, SLOT(init()));
}
CleanupSettings::CleanupSettings(QWidget *parent)
: QWidget(parent), m_attached(false)
{
QVBoxLayout *vLayout = new QVBoxLayout(this);
vLayout->setMargin(1); // NOTE: This works to show the 1-pix black border,
// because this is a QWidget (not QFrame) heir...
setLayout(vLayout);
// Tabs Container
// Used to deal with styled background and other stuff
TabBarContainter *tabBarContainer = new TabBarContainter(this);
QHBoxLayout *hLayout = new QHBoxLayout(tabBarContainer);
hLayout->setMargin(0);
hLayout->setAlignment(Qt::AlignLeft);
hLayout->addSpacing(6);
vLayout->addWidget(tabBarContainer);
// Tabs Bar
DVGui::TabBar *tabBar = new DVGui::TabBar(this);
hLayout->addWidget(tabBar);
tabBar->addSimpleTab(tr("Cleanup"));
tabBar->addSimpleTab(tr("Processing"));
tabBar->addSimpleTab(tr("Camera"));
tabBar->setDrawBase(false);
// Splitter
QSplitter *split = new QSplitter(Qt::Vertical, this);
split->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding));
vLayout->addWidget(split);
// Stacked Widget
QStackedWidget *stackedWidget = new QStackedWidget(split);
stackedWidget->setMinimumWidth(300);
//stackedWidget->setMinimumHeight(250);
split->addWidget(stackedWidget);
split->setStretchFactor(0, 1);
// Cleanup Tab
QScrollArea *scrollArea = new QScrollArea(stackedWidget);
stackedWidget->addWidget(scrollArea);
scrollArea->setWidgetResizable(true);
scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
m_cleanupTab = new CleanupTab;
scrollArea->setWidget(m_cleanupTab);
// Processing Tab
scrollArea = new QScrollArea(stackedWidget);
stackedWidget->addWidget(scrollArea);
scrollArea->setWidgetResizable(true);
scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
m_processingTab = new ProcessingTab;
scrollArea->setWidget(m_processingTab);
// Camera Tab
scrollArea = new QScrollArea(stackedWidget);
stackedWidget->addWidget(scrollArea);
scrollArea->setWidgetResizable(true);
scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
m_cameraTab = new CameraTab;
scrollArea->setWidget(m_cameraTab);
m_cameraTab->setCameraPresetListFile(ToonzFolder::getReslistPath(true));
// Swatch
m_swatch = new CleanupSwatch(split, 200, 150);
split->addWidget(m_swatch);
// ToolBar
QWidget *toolBarWidget = new QWidget(this);
vLayout->addWidget(toolBarWidget);
toolBarWidget->setFixedHeight(22);
QHBoxLayout *toolBarLayout = new QHBoxLayout(toolBarWidget);
toolBarWidget->setLayout(toolBarLayout);
toolBarLayout->setMargin(0);
toolBarLayout->setSpacing(0);
QToolBar *leftToolBar = new QToolBar(toolBarWidget);
toolBarLayout->addWidget(leftToolBar, 0, Qt::AlignLeft);
leftToolBar->setFixedWidth(110);
m_swatchAct = new QAction(createQIconOnOffPNG("preview", true), tr("Toggle Swatch Preview"), this);
m_swatchAct->setCheckable(true);
leftToolBar->addAction(m_swatchAct);
leftToolBar->addSeparator();
m_opacityAct = new QAction(createQIconOnOffPNG("opacitycheck", true), tr("Toggle Opacity Check"), this);
m_opacityAct->setCheckable(true);
leftToolBar->addAction(m_opacityAct);
QToolBar *spacingToolBar1 = new QToolBar(toolBarWidget);
toolBarLayout->addWidget(spacingToolBar1, 1);
spacingToolBar1->setMinimumHeight(22);
QToolBar *rightToolBar = new QToolBar(toolBarWidget);
toolBarLayout->addWidget(rightToolBar, 0, Qt::AlignRight);
rightToolBar->setFixedWidth(110);
QAction *saveAct = new QAction(createQIconOnOffPNG("save", false), tr("Save Settings"), this);
rightToolBar->addAction(saveAct);
QAction *loadAct = new QAction(createQIconOnOffPNG("load", false), tr("Load Settings"), this);
rightToolBar->addAction(loadAct);
rightToolBar->addSeparator();
QAction *resetAct = new QAction(createQIconOnOffPNG("resetsize", false), tr("Reset Settings"), this);
rightToolBar->addAction(resetAct);
// Model-related stuff
CleanupSettingsModel *model = CleanupSettingsModel::instance();
m_backupParams.assign(model->getCurrentParameters(), false);
// Connections
QAction *opacityCheckCmd = CommandManager::instance()->getAction(MI_OpacityCheck);
assert(opacityCheckCmd);
bool ret = true;
ret = ret && connect(tabBar, SIGNAL(currentChanged(int)), stackedWidget, SLOT(setCurrentIndex(int)));
ret = ret && connect(m_swatchAct, SIGNAL(toggled(bool)), SLOT(enableSwatch(bool)));
ret = ret && connect(m_opacityAct, SIGNAL(triggered(bool)), opacityCheckCmd, SLOT(trigger()));
ret = ret && connect(saveAct, SIGNAL(triggered()), model, SLOT(promptSave()));
ret = ret && connect(loadAct, SIGNAL(triggered()), model, SLOT(promptLoad()));
ret = ret && connect(resetAct, SIGNAL(triggered()), this, SLOT(onRestoreSceneSettings()));
assert(ret);
}
void WindowsModernStyle::drawPrimitive( PrimitiveElement element, const QStyleOption* option,
QPainter* painter, const QWidget* widget ) const
{
switch ( element ) {
case PE_Widget:
if ( qobject_cast<const QMainWindow*>( widget ) ) {
QRect rect = option->rect;
if ( QStatusBar* statusBar = widget->findChild<QStatusBar*>() ) {
rect.adjust( 0, 0, 0, -statusBar->height() );
painter->setPen( option->palette.light().color() );
painter->drawLine( rect.bottomLeft() + QPoint( 0, 1 ),
rect.bottomRight() + QPoint( 0, 1 ) );
}
QLinearGradient gradient( option->rect.topLeft(), option->rect.topRight() );
gradient.setColorAt( 0.0, m_colorBackgroundBegin );
gradient.setColorAt( 0.6, m_colorBackgroundEnd );
painter->fillRect( rect, gradient );
return;
}
if ( qobject_cast<const QToolBox*>( widget ) ) {
QLinearGradient gradient( option->rect.topLeft(), option->rect.topRight() );
gradient.setColorAt( 0.4, m_colorBackgroundBegin );
gradient.setColorAt( 1.0, m_colorBackgroundEnd );
painter->fillRect( option->rect, gradient );
return;
}
if ( isToolBoxPanel( widget ) ) {
QLinearGradient gradient( option->rect.topLeft(), option->rect.topRight() );
gradient.setColorAt( 0.4, m_colorBarMiddle );
gradient.setColorAt( 1.0, m_colorBarBegin );
painter->fillRect( option->rect, gradient );
return;
}
break;
case PE_WindowGradient: {
QLinearGradient gradient( option->rect.topLeft(), option->rect.topRight() );
gradient.setColorAt( 0.0, m_colorBackgroundBegin );
gradient.setColorAt( 0.6, m_colorBackgroundEnd );
painter->fillRect( option->rect, gradient );
return;
}
case PE_PanelMenuBar:
return;
case PE_FrameMenu:
painter->setPen( m_colorMenuBorder );
painter->setBrush( Qt::NoBrush );
painter->drawRect( option->rect.adjusted( 0, 0, -1, -1 ) );
if ( const QMenu* menu = qobject_cast<const QMenu*>( widget ) ) {
if ( const QMenuBar* menuBar = qobject_cast<const QMenuBar*>( menu->parent() ) ) {
QRect rect = menuBar->actionGeometry( menu->menuAction() );
if ( !rect.isEmpty() ) {
painter->setPen( m_colorMenuBackground );
painter->drawLine( 1, 0, rect.width() - 2, 0 );
}
}
}
if ( const QToolBar* toolBar = qobject_cast<const QToolBar*>( widget ) ) {
QRect rect = option->rect.adjusted( 1, 1, -1, -1 );
QLinearGradient gradient;
if ( toolBar->orientation() == Qt::Vertical )
gradient = QLinearGradient( rect.topLeft(), rect.topRight() );
else
gradient = QLinearGradient( rect.topLeft(), rect.bottomLeft() );
gradient.setColorAt( 0.0, m_colorBarBegin );
gradient.setColorAt( 0.4, m_colorBarMiddle );
gradient.setColorAt( 0.6, m_colorBarMiddle );
gradient.setColorAt( 1.0, m_colorBarEnd );
painter->fillRect( rect, gradient );
}
return;
case PE_IndicatorToolBarHandle:
if ( option->state & State_Horizontal ) {
for ( int i = option->rect.height() / 5; i <= 4 * ( option->rect.height() / 5 ); i += 5 ) {
int x = option->rect.left() + 3;
int y = option->rect.top() + i + 1;
painter->fillRect( x + 1, y, 2, 2, m_colorHandleLight );
painter->fillRect( x, y - 1, 2, 2, m_colorHandle );
}
} else {
for ( int i = option->rect.width() / 5; i <= 4 * ( option->rect.width() / 5 ); i += 5 ) {
int x = option->rect.left() + i + 1;
int y = option->rect.top() + 3;
painter->fillRect( x, y + 1, 2, 2, m_colorHandleLight );
painter->fillRect( x - 1, y, 2, 2, m_colorHandle );
}
}
return;
case PE_IndicatorToolBarSeparator:
painter->setPen( m_colorSeparator );
if ( option->state & State_Horizontal )
painter->drawLine( ( option->rect.left() + option->rect.right() - 1 ) / 2, option->rect.top() + 2,
( option->rect.left() + option->rect.right() - 1 ) / 2, option->rect.bottom() - 2 );
else
painter->drawLine( option->rect.left() + 2, ( option->rect.top() + option->rect.bottom() - 1 ) / 2,
option->rect.right() - 2, ( option->rect.top() + option->rect.bottom() - 1 ) / 2 );
painter->setPen( m_colorSeparatorLight );
if ( option->state & State_Horizontal )
painter->drawLine( ( option->rect.left() + option->rect.right() + 1 ) / 2, option->rect.top() + 2,
( option->rect.left() + option->rect.right() + 1 ) / 2, option->rect.bottom() - 2 );
else
painter->drawLine( option->rect.left() + 2, ( option->rect.top() + option->rect.bottom() + 1 ) / 2,
option->rect.right() - 2, ( option->rect.top() + option->rect.bottom() + 1 ) / 2 );
return;
case PE_IndicatorButtonDropDown: {
QToolBar* toolBar;
if ( widget && ( toolBar = qobject_cast<QToolBar*>( widget->parentWidget() ) ) ) {
QRect rect = option->rect.adjusted( -1, 0, -1, -1 );
bool selected = option->state & State_MouseOver && option->state & State_Enabled;
bool sunken = option->state & State_Sunken;
if ( selected || sunken ) {
painter->setPen( m_colorItemBorder );
if ( toolBar->orientation() == Qt::Vertical ) {
if ( sunken )
painter->setBrush( m_colorItemSunkenEnd );
else
painter->setBrush( m_colorItemBackgroundEnd );
} else {
QLinearGradient gradient( rect.topLeft(), rect.bottomLeft() );
if ( sunken ) {
gradient.setColorAt( 0.0, m_colorItemSunkenBegin );
gradient.setColorAt( 0.5, m_colorItemSunkenMiddle );
gradient.setColorAt( 1.0, m_colorItemSunkenEnd );
} else {
gradient.setColorAt( 0.0, m_colorItemBackgroundBegin );
gradient.setColorAt( 0.5, m_colorItemBackgroundMiddle );
gradient.setColorAt( 1.0, m_colorItemBackgroundEnd );
}
painter->setBrush( gradient );
}
painter->drawRect( rect );
}
QStyleOption optionArrow = *option;
optionArrow.rect.adjust( 2, 2, -2, -2 );
drawPrimitive( PE_IndicatorArrowDown, &optionArrow, painter, widget );
return;
}
}
case PE_IndicatorDockWidgetResizeHandle:
return;
case PE_PanelButtonTool:
if ( widget && widget->inherits( "QDockWidgetTitleButton" ) ) {
if ( option->state & ( QStyle::State_MouseOver | QStyle::State_Sunken ) ) {
painter->setPen( m_colorItemBorder );
painter->setBrush( ( option->state & QStyle::State_Sunken ) ? m_colorItemSunkenMiddle : m_colorItemBackgroundMiddle );
painter->drawRect( option->rect.adjusted( 0, 0, -1, -1 ) );
}
return;
}
break;
case PE_FrameTabWidget:
if ( isStyledTabWidget( widget ) ) {
painter->fillRect( option->rect, option->palette.window() );
return;
}
break;
case PE_FrameTabBarBase:
if ( isStyledTabBar( widget ) )
return;
break;
default:
break;
}
if ( useVista() )
QWindowsVistaStyle::drawPrimitive( element, option, painter, widget );
else
QWindowsXPStyle::drawPrimitive( element, option, painter, widget );
}
VectorizerPopup::VectorizerPopup(QWidget *parent, Qt::WFlags flags)
#endif
: Dialog(TApp::instance()->getMainWindow(), true, false, "Vectorizer"), m_sceneHandle(TApp::instance()->getCurrentScene())
{
struct Locals {
int m_bit;
Locals() : m_bit() {}
static void addParameterGroup(
std::vector<ParamGroup> ¶mGroups,
int group, int startRow, int separatorRow = -1)
{
assert(group <= paramGroups.size());
if (group == paramGroups.size())
paramGroups.push_back(ParamGroup(startRow, separatorRow));
}
void addParameter(
std::vector<ParamGroup> ¶mGroups,
const QString ¶mName)
{
paramGroups.back().m_params.push_back(Param(paramName, m_bit++));
}
} locals;
// Su MAC i dialog modali non hanno bottoni di chiusura nella titleBar
setModal(false);
setWindowTitle(tr("Convert-to-Vector Settings"));
setLabelWidth(125);
setTopMargin(0);
setTopSpacing(0);
// Build vertical layout
beginVLayout();
QSplitter *splitter = new QSplitter(Qt::Vertical, this);
splitter->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding));
addWidget(splitter);
QToolBar *leftToolBar = new QToolBar,
*rightToolBar = new QToolBar;
{
QWidget *toolbarsContainer = new QWidget(this);
toolbarsContainer->setFixedHeight(22);
addWidget(toolbarsContainer);
QHBoxLayout *toolbarsLayout = new QHBoxLayout(toolbarsContainer);
toolbarsContainer->setLayout(toolbarsLayout);
toolbarsLayout->setMargin(0);
toolbarsLayout->setSpacing(0);
QToolBar *spacingToolBar = new QToolBar(toolbarsContainer); // The spacer object must be a toolbar.
spacingToolBar->setFixedHeight(22); // It's related to qss choices... I know it's stinky
toolbarsLayout->addWidget(leftToolBar, 0, Qt::AlignLeft);
toolbarsLayout->addWidget(spacingToolBar, 1);
toolbarsLayout->addWidget(rightToolBar, 0, Qt::AlignRight);
}
endVLayout();
// Build parameters area
QScrollArea *paramsArea = new QScrollArea(splitter);
paramsArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
paramsArea->setWidgetResizable(true);
splitter->addWidget(paramsArea);
splitter->setStretchFactor(0, 1);
m_paramsWidget = new QFrame(paramsArea);
paramsArea->setWidget(m_paramsWidget);
m_paramsLayout = new QGridLayout;
m_paramsWidget->setLayout(m_paramsLayout);
int group = 0, row = 0;
locals.addParameterGroup(::l_centerlineParamGroups, group, row);
locals.addParameterGroup(::l_outlineParamGroups, group++, row);
// Vectorization mode
m_typeMenu = new QComboBox(this);
m_typeMenu->setFixedSize(245, WidgetHeight);
QStringList formats;
formats << tr("Centerline") << tr("Outline");
m_typeMenu->addItems(formats);
m_typeMenu->setMinimumHeight(WidgetHeight);
bool isOutline = m_sceneHandle->getScene()->getProperties()->getVectorizerParameters()->m_isOutline;
m_typeMenu->setCurrentIndex(isOutline ? 1 : 0);
connect(m_typeMenu, SIGNAL(currentIndexChanged(int)), this, SLOT(onTypeChange(int)));
m_paramsLayout->addWidget(new QLabel(tr("Mode")), row, 0, Qt::AlignRight);
m_paramsLayout->addWidget(m_typeMenu, row++, 1);
locals.addParameter(l_centerlineParamGroups, tr("Mode"));
locals.addParameter(l_outlineParamGroups, tr("Mode"));
//-------------------- Parameters area - Centerline ------------------------
locals.addParameterGroup(l_centerlineParamGroups, group++, row);
// Threshold
m_cThresholdLabel = new QLabel(tr("Threshold"));
m_cThreshold = new IntField(this);
m_paramsLayout->addWidget(m_cThresholdLabel, row, 0, Qt::AlignRight);
m_paramsLayout->addWidget(m_cThreshold, row++, 1);
locals.addParameter(l_centerlineParamGroups, tr("Threshold"));
// Accuracy
m_cAccuracyLabel = new QLabel(tr("Accuracy"));
m_cAccuracy = new IntField(this);
m_paramsLayout->addWidget(m_cAccuracyLabel, row, 0, Qt::AlignRight);
m_paramsLayout->addWidget(m_cAccuracy, row++, 1);
locals.addParameter(l_centerlineParamGroups, tr("Accuracy"));
// Despeckling
m_cDespecklingLabel = new QLabel(tr("Despeckling"));
m_cDespeckling = new IntField(this);
m_paramsLayout->addWidget(m_cDespecklingLabel, row, 0, Qt::AlignRight);
m_paramsLayout->addWidget(m_cDespeckling, row++, 1);
locals.addParameter(l_centerlineParamGroups, tr("Despeckling"));
// Max Thickness
m_cMaxThicknessLabel = new QLabel(tr("Max Thickness"));
m_paramsLayout->addWidget(m_cMaxThicknessLabel, row, 0, Qt::AlignRight);
m_cMaxThickness = new IntField(this);
m_cMaxThickness->enableSlider(false);
m_paramsLayout->addWidget(m_cMaxThickness, row++, 1, Qt::AlignLeft);
locals.addParameter(l_centerlineParamGroups, tr("Max Thickness"));
// Thickness Calibration
m_cThicknessRatioLabel = new QLabel(tr("Thickness Calibration"));
m_paramsLayout->addWidget(m_cThicknessRatioLabel, row, 0, Qt::AlignRight);
/*m_cThicknessRatio = new IntField(this);
paramsLayout->addWidget(m_cThicknessRatio, row++, 1);*/
QHBoxLayout *cThicknessRatioLayout = new QHBoxLayout;
cThicknessRatioLayout->addSpacing(20);
m_cThicknessRatioFirstLabel = new QLabel(tr("Start:"));
cThicknessRatioLayout->addWidget(m_cThicknessRatioFirstLabel);
m_cThicknessRatioFirst = new MeasuredDoubleLineEdit(this);
m_cThicknessRatioFirst->setMeasure("percentage");
cThicknessRatioLayout->addWidget(m_cThicknessRatioFirst);
m_cThicknessRatioLastLabel = new QLabel(tr("End:"));
cThicknessRatioLayout->addWidget(m_cThicknessRatioLastLabel);
m_cThicknessRatioLast = new MeasuredDoubleLineEdit(this);
m_cThicknessRatioLast->setMeasure("percentage");
cThicknessRatioLayout->addWidget(m_cThicknessRatioLast);
cThicknessRatioLayout->addStretch(1);
m_paramsLayout->addLayout(cThicknessRatioLayout, row++, 1);
locals.addParameter(l_centerlineParamGroups, tr("Thickness Calibration"));
// Checkboxes
{
static const QString name = tr("Preserve Painted Areas");
locals.addParameter(l_centerlineParamGroups, name);
m_cPaintFill = new CheckBox(name, this);
m_cPaintFill->setFixedHeight(WidgetHeight);
m_paramsLayout->addWidget(m_cPaintFill, row++, 1);
}
{
static const QString name = tr("Add Border");
locals.addParameter(l_centerlineParamGroups, name);
m_cMakeFrame = new CheckBox(name, this);
m_cMakeFrame->setFixedHeight(WidgetHeight);
m_paramsLayout->addWidget(m_cMakeFrame, row++, 1);
}
locals.addParameterGroup(l_centerlineParamGroups, group++, row + 1, row);
m_cNaaSourceSeparator = new Separator(tr("Full color non-AA images"));
m_paramsLayout->addWidget(m_cNaaSourceSeparator, row++, 0, 1, 2);
{
static const QString name = tr("Enhanced ink recognition");
locals.addParameter(l_centerlineParamGroups, name);
m_cNaaSource = new CheckBox(name, this);
m_cNaaSource->setFixedHeight(WidgetHeight);
m_paramsLayout->addWidget(m_cNaaSource, row++, 1);
}
//-------------------- Parameters area - Outline ------------------------
group = 1;
locals.addParameterGroup(l_outlineParamGroups, group++, row);
//Accuracy
m_oAccuracyLabel = new QLabel(tr("Accuracy"));
m_oAccuracy = new IntField(this);
m_paramsLayout->addWidget(m_oAccuracyLabel, row, 0, Qt::AlignRight);
m_paramsLayout->addWidget(m_oAccuracy, row++, 1);
locals.addParameter(l_outlineParamGroups, tr("Accuracy"));
//Despeckling
m_oDespecklingLabel = new QLabel(tr("Despeckling"));
m_oDespeckling = new IntField(this);
m_paramsLayout->addWidget(m_oDespecklingLabel, row, 0, Qt::AlignRight);
m_paramsLayout->addWidget(m_oDespeckling, row++, 1);
locals.addParameter(l_outlineParamGroups, tr("Despeckling"));
//Paint Fill
{
static const QString name = tr("Preserve Painted Areas");
locals.addParameter(l_outlineParamGroups, name);
m_oPaintFill = new CheckBox(name, this);
m_oPaintFill->setFixedHeight(WidgetHeight);
m_paramsLayout->addWidget(m_oPaintFill, row++, 1);
}
locals.addParameterGroup(l_outlineParamGroups, group++, row + 1, row);
m_oCornersSeparator = new Separator(tr("Corners"));
m_paramsLayout->addWidget(m_oCornersSeparator, row++, 0, 1, 2);
//Adherence
m_oAdherenceLabel = new QLabel(tr("Adherence"));
m_oAdherence = new IntField(this);
m_paramsLayout->addWidget(m_oAdherenceLabel, row, 0, Qt::AlignRight);
m_paramsLayout->addWidget(m_oAdherence, row++, 1);
locals.addParameter(l_outlineParamGroups, tr("Adherence"));
//Angle
m_oAngleLabel = new QLabel(tr("Angle"));
m_oAngle = new IntField(this);
m_paramsLayout->addWidget(m_oAngleLabel, row, 0, Qt::AlignRight);
m_paramsLayout->addWidget(m_oAngle, row++, 1);
locals.addParameter(l_outlineParamGroups, tr("Angle"));
//Relative
m_oRelativeLabel = new QLabel(tr("Curve Radius"));
m_oRelative = new IntField(this);
m_paramsLayout->addWidget(m_oRelativeLabel, row, 0, Qt::AlignRight);
m_paramsLayout->addWidget(m_oRelative, row++, 1);
locals.addParameter(l_outlineParamGroups, tr("Curve Radius"));
locals.addParameterGroup(l_outlineParamGroups, group++, row + 1, row);
m_oFullColorSeparator = new Separator(tr("Raster Levels"));
m_paramsLayout->addWidget(m_oFullColorSeparator, row++, 0, 1, 2);
//Max Colors
m_oMaxColorsLabel = new QLabel(tr("Max Colors"));
m_oMaxColors = new IntField(this);
m_paramsLayout->addWidget(m_oMaxColorsLabel, row, 0, Qt::AlignRight);
m_paramsLayout->addWidget(m_oMaxColors, row++, 1);
locals.addParameter(l_outlineParamGroups, tr("Max Colors"));
//Transparent Color
m_oTransparentColorLabel = new QLabel(tr("Transparent Color"), this);
m_oTransparentColor = new ColorField(this, true, TPixel32::Transparent, 48);
m_paramsLayout->addWidget(m_oTransparentColorLabel, row, 0, Qt::AlignRight);
m_paramsLayout->addWidget(m_oTransparentColor, row++, 1);
locals.addParameter(l_outlineParamGroups, tr("Transparent Color"));
locals.addParameterGroup(l_outlineParamGroups, group++, row + 1, row);
m_oTlvSeparator = new Separator(tr("TLV Levels"));
m_paramsLayout->addWidget(m_oTlvSeparator, row++, 0, 1, 2);
//Tone Threshold
m_oToneThresholdLabel = new QLabel(tr("Tone Threshold"));
m_oToneThreshold = new IntField(this);
m_paramsLayout->addWidget(m_oToneThresholdLabel, row, 0, Qt::AlignRight);
m_paramsLayout->addWidget(m_oToneThreshold, row++, 1);
locals.addParameter(l_outlineParamGroups, tr("Tone Threshold"));
m_paramsLayout->setRowStretch(row, 1);
//-------------------- Swatch area ------------------------
m_swatchArea = new VectorizerSwatchArea(this);
splitter->addWidget(m_swatchArea);
m_swatchArea->setEnabled(false); //Initally not enabled
connect(this, SIGNAL(valuesChanged()), m_swatchArea, SLOT(invalidateContents()));
//---------------------- Toolbar --------------------------
QAction *swatchAct = new QAction(createQIconOnOffPNG("preview", true), tr("Toggle Swatch Preview"), this);
swatchAct->setCheckable(true);
leftToolBar->addAction(swatchAct);
QAction *centerlineAct = new QAction(createQIconOnOffPNG("opacitycheck", true), tr("Toggle Centerlines Check"), this);
centerlineAct->setCheckable(true);
leftToolBar->addAction(centerlineAct);
QToolButton *visibilityButton = new QToolButton(this);
visibilityButton->setIcon(createQIconPNG("options"));
visibilityButton->setPopupMode(QToolButton::InstantPopup);
QMenu *visibilityMenu = new QMenu(visibilityButton);
visibilityButton->setMenu(visibilityMenu);
rightToolBar->addWidget(visibilityButton);
rightToolBar->addSeparator();
QAction *saveAct = new QAction(createQIconOnOffPNG("save", false), tr("Save Settings"), this);
rightToolBar->addAction(saveAct);
QAction *loadAct = new QAction(createQIconOnOffPNG("load", false), tr("Load Settings"), this);
rightToolBar->addAction(loadAct);
rightToolBar->addSeparator();
QAction *resetAct = new QAction(createQIconOnOffPNG("resetsize", false), tr("Reset Settings"), this);
rightToolBar->addAction(resetAct);
connect(swatchAct, SIGNAL(triggered(bool)), m_swatchArea, SLOT(enablePreview(bool)));
connect(centerlineAct, SIGNAL(triggered(bool)), m_swatchArea, SLOT(enableDrawCenterlines(bool)));
connect(visibilityMenu, SIGNAL(aboutToShow()), this, SLOT(populateVisibilityMenu()));
connect(saveAct, SIGNAL(triggered()), this, SLOT(saveParameters()));
connect(loadAct, SIGNAL(triggered()), this, SLOT(loadParameters()));
connect(resetAct, SIGNAL(triggered()), this, SLOT(resetParameters()));
//------------------- Convert Button ----------------------
//Convert Button
m_okBtn = new QPushButton(QString(tr("Convert")), this);
connect(m_okBtn, SIGNAL(clicked()), this, SLOT(onOk()));
addButtonBarWidget(m_okBtn);
//All detailed signals convey to the unique valuesChanged() signal. That makes it easier
//to disconnect update notifications whenever we loadConfiguration(..).
connect(this, SIGNAL(valuesChanged()), this, SLOT(updateSceneSettings()));
//Connect value changes to update the global VectorizerPopUpSettingsContainer.
//connect(m_typeMenu,SIGNAL(currentIndexChanged(const QString &)),this,SLOT(updateSceneSettings()));
connect(m_cThreshold, SIGNAL(valueChanged(bool)), this, SLOT(onValueEdited(bool)));
connect(m_cAccuracy, SIGNAL(valueChanged(bool)), this, SLOT(onValueEdited(bool)));
connect(m_cDespeckling, SIGNAL(valueChanged(bool)), this, SLOT(onValueEdited(bool)));
connect(m_cMaxThickness, SIGNAL(valueChanged(bool)), this, SLOT(onValueEdited(bool)));
//connect(m_cThicknessRatio,SIGNAL(valueChanged(bool)),this,SLOT(onValueEdited(bool)));
connect(m_cThicknessRatioFirst, SIGNAL(valueChanged()), this, SLOT(onValueEdited()));
connect(m_cThicknessRatioLast, SIGNAL(valueChanged()), this, SLOT(onValueEdited()));
connect(m_cMakeFrame, SIGNAL(stateChanged(int)), this, SLOT(onValueEdited()));
connect(m_cPaintFill, SIGNAL(stateChanged(int)), this, SLOT(onValueEdited()));
connect(m_cNaaSource, SIGNAL(stateChanged(int)), this, SLOT(onValueEdited()));
connect(m_oAccuracy, SIGNAL(valueChanged(bool)), this, SLOT(onValueEdited(bool)));
connect(m_oDespeckling, SIGNAL(valueChanged(bool)), this, SLOT(onValueEdited(bool)));
connect(m_oPaintFill, SIGNAL(stateChanged(int)), this, SLOT(onValueEdited()));
connect(m_oAdherence, SIGNAL(valueChanged(bool)), this, SLOT(onValueEdited(bool)));
connect(m_oAngle, SIGNAL(valueChanged(bool)), this, SLOT(onValueEdited(bool)));
connect(m_oRelative, SIGNAL(valueChanged(bool)), this, SLOT(onValueEdited(bool)));
connect(m_oDespeckling, SIGNAL(valueChanged(bool)), this, SLOT(onValueEdited(bool)));
connect(m_oMaxColors, SIGNAL(valueChanged(bool)), this, SLOT(onValueEdited(bool)));
connect(m_oTransparentColor, SIGNAL(colorChanged(const TPixel32 &, bool)),
this, SLOT(onValueEdited(const TPixel32 &, bool)));
connect(m_oToneThreshold, SIGNAL(valueChanged(bool)), this, SLOT(onValueEdited(bool)));
refreshPopup();
//Non e' corretto: manca la possibilita' di aggiornare la selezione del livello corrente
// connect(TApp::instance()->getCurrentLevel(), SIGNAL(xshLevelChanged()),
// this, SLOT(updateValues()));
}
//Initialize the toolbar at the top of the window
void GUI::initToolbar(){
QPixmap openPicture("Images/open.png");
QPixmap savePicture("Images/save.png");
QPixmap playPicture("Images/play.png");
QPixmap pausePicture("Images/pause.png");
QPixmap stopPicture("Images/stop.png");
QPixmap zoomInPicture("Images/zoom-in.png");
QPixmap zoomOutPicture("Images/zoom-out.png");
QToolBar * toolbar = addToolBar("Toolbar");
QAction * openAction = toolbar->addAction(QIcon(openPicture), "Open");
QAction * saveAction = toolbar->addAction(QIcon(savePicture), "Save");
toolbar->addSeparator();
QAction * playAction = toolbar->addAction(QIcon(playPicture), "Play");
QAction * pauseAction = toolbar->addAction(QIcon(pausePicture), "Pause");
QAction * stopAction = toolbar->addAction(QIcon(stopPicture), "Stop");
toolbar->addSeparator();
QAction * zoomInAction = toolbar->addAction(QIcon(zoomInPicture), "Zoom-In");
QAction * zoomOutAction = toolbar->addAction(QIcon(zoomOutPicture), "Zoom-Out");
connect(openAction, SIGNAL(triggered()), this, SLOT(openFile()));
connect(saveAction, SIGNAL(triggered()), this, SLOT(saveFile()));
connect(playAction, SIGNAL(triggered()), this, SLOT(start()));
connect(pauseAction, SIGNAL(triggered()), this, SLOT(pause()));
connect(stopAction, SIGNAL(triggered()), this, SLOT(stop()));
connect(zoomInAction, SIGNAL(triggered()), this, SLOT(zoomIn()));
connect(zoomOutAction, SIGNAL(triggered()), this, SLOT(zoomOut()));
toolbar->addSeparator();
QPixmap volumePicture("Images/volume.png");
QAction * volumeIcon = toolbar->addAction(QIcon(volumePicture), "Volume");
volumeIcon->setEnabled(false);
sliderVolume = new QSlider(Qt::Horizontal, this);
sliderVolume->setTickPosition(QSlider::TicksBelow);
sliderVolume->setTickInterval(10);
sliderVolume->setValue(100);
toolbar->addWidget(sliderVolume);
toolbar->addSeparator();
QPixmap speedPicture("Images/speed.png");
QAction * speedIcon = toolbar->addAction(QIcon(speedPicture), "Speed");
speedIcon->setEnabled(false);
sliderSpeed = new QSlider(Qt::Horizontal, this);
sliderSpeed->setTickPosition(QSlider::TicksBelow);
sliderSpeed->setTickInterval(10);
sliderSpeed->setValue(50);
toolbar->addWidget(sliderSpeed);
connect(sliderVolume, SIGNAL(valueChanged(int)), this, SLOT(volumeChanged()));
connect(sliderSpeed, SIGNAL(valueChanged(int)), this, SLOT(speedChanged()));
}
toAnalyze::toAnalyze(QWidget *main, toConnection &connection)
: toToolWidget(AnalyzeTool, "analyze.html", main, connection, "toAnalyze")
{
Tabs = new QTabWidget(this);
layout()->addWidget(Tabs);
QWidget *container = new QWidget(Tabs);
QVBoxLayout *box = new QVBoxLayout;
Tabs->addTab(container, tr("Analyze"));
QToolBar *toolbar = Utils::toAllocBar(container, tr("Statistics Manager"));
box->addWidget(toolbar);
toolbar->addAction(QIcon(QPixmap(const_cast<const char**>(refresh_xpm))),
tr("Refresh"),
this,
SLOT(slotRefresh()));
toolbar->addSeparator();
Analyzed = NULL;
if (connection.providerIs("Oracle"))
{
Analyzed = new QComboBox(toolbar);
Analyzed->addItem(tr("All"));
Analyzed->addItem(tr("Not analyzed"));
Analyzed->addItem(tr("Analyzed"));
toolbar->addWidget(Analyzed);
}
Schema = new toResultSchema(toolbar);
Schema->additionalItem(tr("All"));
Schema->setSelected(tr("All"));
toolbar->addWidget(Schema);
Schema->refresh();
if (connection.providerIs("Oracle"))
{
Type = new QComboBox(toolbar);
Type->addItem(tr("Tables"));
Type->addItem(tr("Indexes"));
toolbar->addWidget(Type);
toolbar->addSeparator();
Operation = new QComboBox(toolbar);
Operation->addItem(tr("Compute statistics"));
Operation->addItem(tr("Estimate statistics"));
Operation->addItem(tr("Delete statistics"));
Operation->addItem(tr("Validate references"));
toolbar->addWidget(Operation);
connect(Operation,
SIGNAL(activated(int)),
this,
SLOT(slotChangeOperation(int)));
toolbar->addWidget(
new QLabel(" " + tr("for") + " ", toolbar));
For = new QComboBox(toolbar);
For->addItem(tr("All"));
For->addItem(tr("Table"));
For->addItem(tr("Indexed columns"));
For->addItem(tr("Local indexes"));
toolbar->addWidget(For);
toolbar->addSeparator();
toolbar->addWidget(new QLabel(tr("Sample") + " ",
toolbar));
Sample = new QSpinBox(toolbar);
Sample->setMinimum(1);
Sample->setMaximum(100);
Sample->setValue(100);
Sample->setSuffix(" " + tr("%"));
Sample->setEnabled(false);
toolbar->addWidget(Sample);
}
void QHTMLView::init()
{
QString qs;
QString qs2;
mpTextBrowser = new QTextBrowser(this);
mpTextBrowser->setTextFormat(Qt::RichText);
setCentralWidget(mpTextBrowser);
qs = xmlConfig->stringValue("HELP_INDEX");
qs2 = xmlConfig->stringValue("HELP_LAST_PAGE");
QFile qf1(qs);
if(qf1.exists()) mpTextBrowser->setSource(qs);
if(qs != qs2 )
{
QFile qf2(qs2);
if(qf2.exists()) mpTextBrowser->setSource(qs2);
}
QPopupMenu* file = new QPopupMenu( this );
file->insertItem( tr("&Open File"), this, SLOT( openFile() ), ALT | Key_O );
file->insertSeparator();
file->insertItem( tr("&Quit"), this, SLOT( close() ), ALT | Key_Q );
QPopupMenu* go = new QPopupMenu( this );
mIdBackward = go->insertItem(tr("&Backward"),mpTextBrowser,
SLOT( backward() ),ALT | Key_Left );
mIdForward = go->insertItem(tr("&Forward"),mpTextBrowser,
SLOT( forward() ),ALT | Key_Right );
go->insertItem(tr("&Home"),mpTextBrowser, SLOT( home() ) );
QPopupMenu* help = new QPopupMenu( this );
help->insertItem(tr("&About ..."),this,SLOT(about()));
#ifdef KDEAPP
KMenuBar* mb = new KMenuBar(this);
#else
QMenuBar* mb = new QMenuBar(this);
#endif
mb->insertItem(tr("&File"),file);
mb->insertItem(tr("&Go"),go);
mb->insertSeparator();
mb->insertItem(tr("&Help"),help );
mb->setItemEnabled( mIdForward, false);
mb->setItemEnabled( mIdBackward, false);
connect(mpTextBrowser, SIGNAL( backwardAvailable( bool ) ),
this, SLOT( setBackwardAvailable( bool ) ) );
connect(mpTextBrowser, SIGNAL( forwardAvailable( bool ) ),
this, SLOT( setForwardAvailable( bool ) ) );
connect(mpTextBrowser,SIGNAL(textChanged() ),this,
SLOT( slotTextChanged() ) );
QToolBar* toolbar = new QToolBar( this );
addToolBar( toolbar);
QToolButton* tb1;
mPixForward = QPixmap((const char **)forward_xpm);
mPixBackward = QPixmap((const char **)backward_xpm);
mPixHome = QPixmap((const char **)home_xpm);
tb1 = new QToolButton(mPixBackward, tr("Backward"), "", mpTextBrowser,
SLOT(backward()), toolbar );
connect(mpTextBrowser, SIGNAL( backwardAvailable(bool) ),tb1,
SLOT( setEnabled(bool) ) );
tb1->setEnabled( false );
tb1 = new QToolButton(mPixForward, tr("Forward"), "",mpTextBrowser,
SLOT(forward()), toolbar );
connect(mpTextBrowser,SIGNAL(forwardAvailable(bool) ),tb1,
SLOT( setEnabled(bool) ) );
tb1->setEnabled( false );
tb1 = new QToolButton(mPixHome, tr("Home"), "",this,
SLOT(home()), toolbar );
QWidget* dummy = new QWidget(toolbar);
toolbar->setStretchableWidget(dummy);
setRightJustification(true);
}
MainWindow::MainWindow(QWidget* parent)
: QMainWindow(parent)
{
const int screenWidth = QApplication::desktop()->width();
const int screenHeight = QApplication::desktop()->height();
const int appWidth = 500;
const int appHeight = 300;
setGeometry((screenWidth - appWidth) / 2, (screenHeight - appHeight) / 2, appWidth, appHeight);
setObjectName("mainwindow");
setWindowTitle("developers' test version, not for public use");
setWindowIcon(QIcon(":/icons/icon64.png"));
setContextMenuPolicy(Qt::PreventContextMenu);
QDockWidget* friendDock = new QDockWidget(this);
friendDock->setObjectName("FriendDock");
friendDock->setFeatures(QDockWidget::NoDockWidgetFeatures);
friendDock->setTitleBarWidget(new QWidget(friendDock));
friendDock->setContextMenuPolicy(Qt::PreventContextMenu);
addDockWidget(Qt::LeftDockWidgetArea, friendDock);
QWidget* friendDockWidget = new QWidget(friendDock);
QVBoxLayout* layout = new QVBoxLayout(friendDockWidget);
layout->setMargin(0);
layout->setSpacing(0);
friendDock->setWidget(friendDockWidget);
ourUserItem = new OurUserItemWidget(this);
friendsWidget = new FriendsWidget(friendDockWidget);
// Create toolbar
QToolBar *toolBar = new QToolBar(this);
toolBar->setToolButtonStyle(Qt::ToolButtonIconOnly);
toolBar->setIconSize(QSize(16, 16));
toolBar->setFocusPolicy(Qt::ClickFocus);
QToolButton *addFriendButton = new QToolButton(toolBar);
addFriendButton->setIcon(QIcon("://icons/user_add.png"));
addFriendButton->setToolTip(tr("Add friend"));
connect(addFriendButton, &QToolButton::clicked, friendsWidget, &FriendsWidget::onAddFriendButtonClicked);
QWidget *spacer = new QWidget(toolBar);
spacer->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Preferred);
QToolButton *menuButton = new QToolButton(toolBar);
menuButton->setIcon(QIcon("://icons/cog.png"));
menuButton->setToolTip(tr("Mainmenu"));
menuButton->setPopupMode(QToolButton::InstantPopup);
QMenu *mainmenu = new QMenu(menuButton);
mainmenu->addAction(QIcon(":/icons/setting_tools.png"), tr("Settings"), this, SLOT(onSettingsActionTriggered()));
mainmenu->addSeparator();
mainmenu->addAction(tr("About %1").arg(AppInfo::name), this, SLOT(onAboutAppActionTriggered()));
mainmenu->addAction(tr("About Qt"), qApp, SLOT(aboutQt()));
mainmenu->addSeparator();
mainmenu->addAction(tr("Quit"), this, SLOT(onQuitApplicationTriggered()), QKeySequence::Quit);
menuButton->setMenu(mainmenu);
toolBar->addWidget(addFriendButton);
toolBar->addWidget(spacer);
toolBar->addWidget(menuButton);
// Create toolbar end
layout->addWidget(ourUserItem);
layout->addWidget(friendsWidget);
layout->addWidget(toolBar);
PagesWidget* pages = new PagesWidget(this);
connect(friendsWidget, &FriendsWidget::friendAdded, pages, &PagesWidget::addPage);
connect(friendsWidget, &FriendsWidget::friendSelectionChanged, pages, &PagesWidget::activatePage);
connect(friendsWidget, &FriendsWidget::friendStatusChanged, pages, &PagesWidget::statusChanged);
//FIXME: start core in a separate function
//all connections to `core` should be done after its creation because it registers some types
core = new Core();
coreThread = new QThread(this);
core->moveToThread(coreThread);
connect(coreThread, &QThread::started, core, &Core::start);
qRegisterMetaType<Status>("Status");
connect(core, &Core::connected, this, &MainWindow::onConnected);
connect(core, &Core::disconnected, this, &MainWindow::onDisconnected);
connect(core, &Core::friendRequestRecieved, this, &MainWindow::onFriendRequestRecieved);
connect(core, SIGNAL(friendStatusChanged(int, Status)), friendsWidget, SLOT(setStatus(int, Status)));
connect(core, &Core::friendAddressGenerated, ourUserItem, &OurUserItemWidget::setFriendAddress);
connect(core, &Core::friendAdded, friendsWidget, &FriendsWidget::addFriend);
connect(core, &Core::friendMessageRecieved, pages, &PagesWidget::messageReceived);
connect(core, &Core::actionReceived, pages, &PagesWidget::actionReceived);
connect(core, &Core::friendUsernameChanged, friendsWidget, &FriendsWidget::setUsername);
connect(core, &Core::friendUsernameChanged, pages, &PagesWidget::usernameChanged);
connect(core, &Core::friendRemoved, friendsWidget, &FriendsWidget::removeFriend);
connect(core, &Core::friendRemoved, pages, &PagesWidget::removePage);
connect(core, &Core::failedToRemoveFriend, this, &MainWindow::onFailedToRemoveFriend);
connect(core, &Core::failedToAddFriend, this, &MainWindow::onFailedToAddFriend);
connect(core, &Core::messageSentResult, pages, &PagesWidget::messageSentResult);
connect(core, &Core::actionSentResult, pages, &PagesWidget::actionResult);
coreThread->start(/*QThread::IdlePriority*/);
connect(this, &MainWindow::friendRequestAccepted, core, &Core::acceptFriendRequest);
connect(ourUserItem, &OurUserItemWidget::usernameChanged, core, &Core::setUsername);
connect(core, &Core::usernameSet, ourUserItem, &OurUserItemWidget::setUsername);
connect(ourUserItem, &OurUserItemWidget::statusMessageChanged, core, &Core::setStatusMessage);
connect(core, &Core::statusMessageSet, ourUserItem, &OurUserItemWidget::setStatusMessage);
connect(ourUserItem, &OurUserItemWidget::statusSelected, core, &Core::setStatus);
connect(pages, &PagesWidget::sendMessage, core, &Core::sendMessage);
connect(pages, &PagesWidget::sendAction, core, &Core::sendAction);
connect(friendsWidget, &FriendsWidget::friendRequested, core, &Core::requestFriendship);
connect(friendsWidget, &FriendsWidget::friendRemoved, core, &Core::removeFriend);
setCentralWidget(pages);
Settings::getInstance().loadWindow(this);
}
void TextEdit::setupFileActions()
{
QToolBar *tb = new QToolBar(this);
tb->setWindowTitle(tr("File Actions"));
addToolBar(tb);
QMenu *menu = new QMenu(tr("&File"), this);
menuBar()->addMenu(menu);
QAction *a;
a = new QAction(QIcon(rsrcPath + "/filenew.png"), tr("&New"), this);
a->setShortcut(QKeySequence::New);
connect(a, SIGNAL(triggered()), this, SLOT(fileNew()));
tb->addAction(a);
menu->addAction(a);
a = new QAction(QIcon(rsrcPath + "/fileopen.png"), tr("&Open..."), this);
a->setShortcut(QKeySequence::Open);
connect(a, SIGNAL(triggered()), this, SLOT(fileOpen()));
tb->addAction(a);
menu->addAction(a);
menu->addSeparator();
actionSave = a = new QAction(QIcon(rsrcPath + "/filesave.png"), tr("&Save"), this);
a->setShortcut(QKeySequence::Save);
connect(a, SIGNAL(triggered()), this, SLOT(fileSave()));
a->setEnabled(false);
tb->addAction(a);
menu->addAction(a);
a = new QAction(tr("Save &As..."), this);
connect(a, SIGNAL(triggered()), this, SLOT(fileSaveAs()));
menu->addAction(a);
menu->addSeparator();
#ifndef QT_NO_PRINTER
a = new QAction(QIcon(rsrcPath + "/fileprint.png"), tr("&Print..."), this);
a->setShortcut(QKeySequence::Print);
connect(a, SIGNAL(triggered()), this, SLOT(filePrint()));
tb->addAction(a);
menu->addAction(a);
a = new QAction(QIcon(rsrcPath + "/fileprint.png"), tr("Print Preview..."), this);
connect(a, SIGNAL(triggered()), this, SLOT(filePrintPreview()));
menu->addAction(a);
a = new QAction(QIcon(rsrcPath + "/exportpdf.png"), tr("&Export PDF..."), this);
a->setShortcut(Qt::CTRL + Qt::Key_D);
connect(a, SIGNAL(triggered()), this, SLOT(filePrintPdf()));
tb->addAction(a);
menu->addAction(a);
menu->addSeparator();
#endif
a = new QAction(tr("&Quit"), this);
a->setShortcut(Qt::CTRL + Qt::Key_Q);
connect(a, SIGNAL(triggered()), this, SLOT(close()));
menu->addAction(a);
}
void CelestiaAppWindow::init(const QString& qConfigFileName,
const QStringList& qExtrasDirectories)
{
QString celestia_data_dir = QString::fromLocal8Bit(::getenv("CELESTIA_DATA_DIR"));
if (celestia_data_dir.isEmpty()) {
QString celestia_data_dir = CONFIG_DATA_DIR;
QDir::setCurrent(celestia_data_dir);
} else if (QDir(celestia_data_dir).isReadable()) {
QDir::setCurrent(celestia_data_dir);
} else {
QMessageBox::critical(0, "Celestia",
_("Celestia is unable to run because the data directroy was not "
"found, probably due to improper installation."));
exit(1);
}
// Get the config file name
string configFileName;
if (qConfigFileName.isEmpty())
configFileName = DEFAULT_CONFIG_FILE.toUtf8().data();
else
configFileName = qConfigFileName.toUtf8().data();
// Translate extras directories from QString -> std::string
vector<string> extrasDirectories;
for (QStringList::const_iterator iter = qExtrasDirectories.begin();
iter != qExtrasDirectories.end(); iter++)
{
extrasDirectories.push_back(iter->toUtf8().data());
}
#ifdef TARGET_OS_MAC
static short domains[] = { kUserDomain, kLocalDomain, kNetworkDomain };
int domain = 0;
int domainCount = (sizeof domains / sizeof(short));
QString resourceDir = QDir::currentPath();
while (!QDir::setCurrent(resourceDir+"/CelestiaResources") && domain < domainCount)
{
FSRef folder;
CFURLRef url;
UInt8 fullPath[PATH_MAX];
if (noErr == FSFindFolder(domains[domain++], kApplicationSupportFolderType, FALSE, &folder))
{
url = CFURLCreateFromFSRef(nil, &folder);
if (CFURLGetFileSystemRepresentation(url, TRUE, fullPath, PATH_MAX))
resourceDir = (const char *)fullPath;
CFRelease(url);
}
}
if (domain >= domainCount)
{
QMessageBox::critical(0, "Celestia",
_("Celestia is unable to run because the CelestiaResources folder was not "
"found, probably due to improper installation."));
exit(1);
}
#endif
initAppDataDirectory();
m_appCore = new CelestiaCore();
AppProgressNotifier* progress = new AppProgressNotifier(this);
alerter = new AppAlerter(this);
m_appCore->setAlerter(alerter);
setWindowIcon(QIcon(":/icons/celestia.png"));
m_appCore->initSimulation(&configFileName,
&extrasDirectories,
progress);
delete progress;
// Enable antialiasing if requested in the config file.
// TODO: Make this settable via the GUI
QGLFormat glformat = QGLFormat::defaultFormat();
if (m_appCore->getConfig()->aaSamples > 1)
{
glformat.setSampleBuffers(true);
glformat.setSamples(m_appCore->getConfig()->aaSamples);
QGLFormat::setDefaultFormat(glformat);
}
glWidget = new CelestiaGlWidget(NULL, "Celestia", m_appCore);
glWidget->makeCurrent();
GLenum glewErr = glewInit();
if (glewErr != GLEW_OK)
{
QMessageBox::critical(0, "Celestia",
QString(_("Celestia was unable to initialize OpenGL extensions (error %1). Graphics quality will be reduced.")).arg(glewErr));
}
m_appCore->setCursorHandler(glWidget);
m_appCore->setContextMenuCallback(ContextMenu);
MainWindowInstance = this; // TODO: Fix context menu callback
setCentralWidget(glWidget);
setWindowTitle("Celestia");
actions = new CelestiaActions(this, m_appCore);
createMenus();
QTabWidget* tabWidget = new QTabWidget(this);
tabWidget->setObjectName("celestia-tabbed-browser");
toolsDock = new QDockWidget(_("Celestial Browser"), this);
toolsDock->setObjectName("celestia-tools-dock");
toolsDock->setAllowedAreas(Qt::LeftDockWidgetArea |
Qt::RightDockWidgetArea);
// Create the various browser widgets
celestialBrowser = new CelestialBrowser(m_appCore, NULL);
celestialBrowser->setObjectName("celestia-browser");
connect(celestialBrowser,
SIGNAL(selectionContextMenuRequested(const QPoint&, Selection&)),
this,
SLOT(slotShowSelectionContextMenu(const QPoint&, Selection&)));
QWidget* deepSkyBrowser = new DeepSkyBrowser(m_appCore, NULL);
deepSkyBrowser->setObjectName("deepsky-browser");
connect(deepSkyBrowser,
SIGNAL(selectionContextMenuRequested(const QPoint&, Selection&)),
this,
SLOT(slotShowSelectionContextMenu(const QPoint&, Selection&)));
SolarSystemBrowser* solarSystemBrowser = new SolarSystemBrowser(m_appCore, NULL);
solarSystemBrowser->setObjectName("ssys-browser");
connect(solarSystemBrowser,
SIGNAL(selectionContextMenuRequested(const QPoint&, Selection&)),
this,
SLOT(slotShowSelectionContextMenu(const QPoint&, Selection&)));
// Set up the browser tabs
tabWidget->addTab(solarSystemBrowser, _("Solar System"));
tabWidget->addTab(celestialBrowser, _("Stars"));
tabWidget->addTab(deepSkyBrowser, _("Deep Sky Objects"));
toolsDock->setWidget(tabWidget);
addDockWidget(Qt::LeftDockWidgetArea, toolsDock);
infoPanel = new InfoPanel(_("Info Browser"), this);
infoPanel->setObjectName("info-panel");
infoPanel->setAllowedAreas(Qt::LeftDockWidgetArea |
Qt::RightDockWidgetArea);
addDockWidget(Qt::RightDockWidgetArea, infoPanel);
infoPanel->setVisible(false);
eventFinder = new EventFinder(m_appCore, _("Event Finder"), this);
eventFinder->setObjectName("event-finder");
eventFinder->setAllowedAreas(Qt::LeftDockWidgetArea |
Qt::RightDockWidgetArea);
addDockWidget(Qt::LeftDockWidgetArea, eventFinder);
eventFinder->setVisible(false);
//addDockWidget(Qt::DockWidgetArea, eventFinder);
// Create the time toolbar
TimeToolBar* timeToolBar = new TimeToolBar(m_appCore, _("Time"));
timeToolBar->setObjectName("time-toolbar");
timeToolBar->setFloatable(true);
timeToolBar->setMovable(true);
addToolBar(Qt::TopToolBarArea, timeToolBar);
// Create the guides toolbar
QToolBar* guidesToolBar = new QToolBar(_("Guides"));
guidesToolBar->setObjectName("guides-toolbar");
guidesToolBar->setFloatable(true);
guidesToolBar->setMovable(true);
guidesToolBar->setToolButtonStyle(Qt::ToolButtonTextOnly);
guidesToolBar->addAction(actions->equatorialGridAction);
guidesToolBar->addAction(actions->galacticGridAction);
guidesToolBar->addAction(actions->eclipticGridAction);
guidesToolBar->addAction(actions->horizonGridAction);
guidesToolBar->addAction(actions->eclipticAction);
guidesToolBar->addAction(actions->markersAction);
guidesToolBar->addAction(actions->constellationsAction);
guidesToolBar->addAction(actions->boundariesAction);
guidesToolBar->addAction(actions->orbitsAction);
guidesToolBar->addAction(actions->labelsAction);
addToolBar(Qt::TopToolBarArea, guidesToolBar);
// Give keyboard focus to the 3D view
glWidget->setFocus();
m_bookmarkManager = new BookmarkManager(this);
// Load the bookmarks file and nitialize the bookmarks menu
if (!loadBookmarks())
m_bookmarkManager->initializeBookmarks();
populateBookmarkMenu();
connect(m_bookmarkManager, SIGNAL(bookmarkTriggered(const QString&)),
this, SLOT(slotBookmarkTriggered(const QString&)));
m_bookmarkToolBar = new BookmarkToolBar(m_bookmarkManager, this);
m_bookmarkToolBar->setObjectName("bookmark-toolbar");
m_bookmarkToolBar->rebuild();
addToolBar(Qt::TopToolBarArea, m_bookmarkToolBar);
// Read saved window preferences
readSettings();
// Build the view menu
// Add dockable panels and toolbars to the view menu
viewMenu->addAction(timeToolBar->toggleViewAction());
viewMenu->addAction(guidesToolBar->toggleViewAction());
viewMenu->addAction(m_bookmarkToolBar->toggleViewAction());
viewMenu->addSeparator();
viewMenu->addAction(toolsDock->toggleViewAction());
viewMenu->addAction(infoPanel->toggleViewAction());
viewMenu->addAction(eventFinder->toggleViewAction());
viewMenu->addSeparator();
QAction* fullScreenAction = new QAction(_("Full screen"), this);
fullScreenAction->setCheckable(true);
fullScreenAction->setShortcut(QString(_("Shift+F11")));
// Set the full screen check state only after reading settings
fullScreenAction->setChecked(isFullScreen());
connect(fullScreenAction, SIGNAL(triggered()), this, SLOT(slotToggleFullScreen()));
viewMenu->addAction(fullScreenAction);
// We use a timer with a null timeout value
// to add m_appCore->tick to Qt's event loop
QTimer *t = new QTimer(dynamic_cast<QObject *>(this));
QObject::connect(t, SIGNAL(timeout()), SLOT(celestia_tick()));
t->start(0);
}
MainWindow(ResourceFinder *rf)
{
//if (VERBOSE) fprintf(stderr, "Passing RF by address ...");
resFind = rf;
//if (VERBOSE) fprintf(stderr, "done \n");
Property options;
options.fromString(resFind->toString());
Value &robot = options.find("robot");
Value &part = options.find("part");
Value &rows = options.find("rows");
Value &cols = options.find("cols");
if (!options.check("robot"))
printf("Missing --robot option. Using icub.\n");
if (!options.check("part"))
printf("Missing --part option. Using head.\n");
if (!options.check("local"))
printf("Missing --name option. Using /portScope/vector:i.\n");
if (!options.check("remote"))
printf("Missing --remote option. Will wait for the connection...\n");
if (!options.check("rows"))
printf("Missing --rows option. Disabling subplotting.\n");
//if (VERBOSE) fprintf(stderr, "Start plotting the GUI\n");
QToolBar *toolBar = new QToolBar(this);
toolBar->setFixedHeight(80);
#if QT_VERSION < 0x040000
setDockEnabled(TornOff, true);
setRightJustification(true);
#else
toolBar->setAllowedAreas(Qt::TopToolBarArea | Qt::BottomToolBarArea);
#endif
QWidget *hBox = new QWidget(toolBar);
QLabel *label = new QLabel("Timer Interval", hBox);
QwtCounter *counter = new QwtCounter(hBox);
QLabel *labelActions = new QLabel("Actions", hBox);
QPushButton *toggleAcquireButton = new QPushButton("stop", hBox, "stop");
counter->setRange(-1.0, 1000.0, 1.0);
QHBoxLayout *layout = new QHBoxLayout(hBox);
layout->addWidget(label);
layout->addWidget(counter);
layout->addWidget(labelActions);
layout->addWidget(toggleAcquireButton);
layout->addWidget(new QWidget(hBox), 10); // spacer);
#if QT_VERSION >= 0x040000
toolBar->addWidget(hBox);
#endif
addToolBar(toolBar);
if (options.check("rows"))
nRows = rows.asInt();
else
nRows = 1;
if (options.check("cols"))
nCols = cols.asInt();
else
nCols = nRows;
nPlots = nRows*nCols;
nPortInputsInPlots = new int[nPlots];
QGrid *grid = new QGrid( nRows, Qt::Vertical, this );
plot = new DataPlot*[nPlots];
setCentralWidget(grid);
for( int r = 0 ; r < nRows ; r++ )
{
for( int c = 0 ; c < nCols ; c++ )
{
char rcS[256];
sprintf(rcS, "%d%d", r, c);
ConstString rS(rcS);
ConstString local;
local = resFind->find("local").toString();
//local port name
local = local + rcS;
//dataPlot creation
plot[r+nRows*c] = new DataPlot(grid);
//dataPlot set plot to read from
setInputPort(resFind, r+nRows*c, local);
//dataPlot set indeces of ports to plot
setIndexMask(resFind, r+nRows*c, nPortInputsInPlots[r+nRows*c]);
}
}
for( int r = 0 ; r < nRows ; r++ )
{
for( int c = 0 ; c < nCols ; c++ )
{
//stop acquisition button
connect( toggleAcquireButton, SIGNAL(clicked()), plot[r+nRows*c], SLOT(toggleAcquire()) );
plot[r+nRows*c]->initSignalDimensions();
//counter button
connect(counter, SIGNAL(valueChanged(double)),
plot[r+nRows*c], SLOT(setTimerInterval(double)) );
counter->setValue(50.0);
QSizePolicy sizePolicy2(QSizePolicy::Maximum, QSizePolicy::Maximum);
grid->setSizePolicy(sizePolicy2);
QSizePolicy sizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum);
sizePolicy.setHeightForWidth(plot[r+nRows*c]->sizePolicy().hasHeightForWidth());
plot[r+nRows*c]->setSizePolicy(sizePolicy);
//QSize gridSize= grid->sizeHint();
//gridSize.setWidth(500);
//gridSize.setHeight(500);
plot[r+nRows*c]->setMinimumWidth(10);
plot[r+nRows*c]->setMaximumWidth(800);
plot[r+nRows*c]->setMinimumHeight(10);
plot[r+nRows*c]->setMaximumHeight(800);
//if (VERBOSE) fprintf(stderr, "Grid max is: hInt=%d, vInt=%d\n", grid->maximumHeight(), grid->maximumWidth());
//if (VERBOSE) fprintf(stderr, "Plot max is: hInt=%d, vInt=%d\n", plot[r+nRows*c]->maximumHeight(), plot[r+nRows*c]->maximumWidth());
//QSize plotSize= plot[r+nRows*c]->sizeHint();
//if (VERBOSE) fprintf(stderr, "Plot Hint is: hInt=%d, vInt=%d\n", plotSize.height(), plotSize.width());
}
}
}
void TerrainProfileWidget::initialize()
{
QVBoxLayout* vStack = new QVBoxLayout();
vStack->setSpacing(0);
vStack->setContentsMargins(0, 0, 0, 0);
setLayout(vStack);
// create actions
_captureAction = new QAction(QIcon(":/images/crosshair.png"), tr(""), this);
_captureAction->setToolTip(tr("Capture map clicks"));
_captureAction->setCheckable(true);
connect(_captureAction, SIGNAL(toggled(bool)), this, SLOT(onCaptureToggled(bool)));
_undoZoomAction = new QAction(QIcon(":/images/undo.png"), tr(""), this);
_undoZoomAction->setToolTip(tr("Undo zoom"));
connect(_undoZoomAction, SIGNAL(triggered()), this, SLOT(onUndoZoom()));
_undoZoomAction->setEnabled(false);
// create toolbar
QToolBar *buttonToolbar = new QToolBar(tr("Action Toolbar"));
buttonToolbar->setIconSize(QSize(24, 24));
buttonToolbar->addAction(_captureAction);
buttonToolbar->addSeparator();
buttonToolbar->addAction(_undoZoomAction);
vStack->addWidget(buttonToolbar);
// create graph widget
_graph = new TerrainProfileGraph(_calculator, new UpdatePositionShim(this));
vStack->addWidget(_graph);
// define a style for the line
osgEarth::Symbology::LineSymbol* ls = _lineStyle.getOrCreateSymbol<osgEarth::Symbology::LineSymbol>();
ls->stroke()->color() = osgEarth::Symbology::Color::White;
ls->stroke()->width() = 2.0f;
ls->tessellation() = 20;
_lineStyle.getOrCreate<osgEarth::Symbology::AltitudeSymbol>()->clamping() = osgEarth::Symbology::AltitudeSymbol::CLAMP_TO_TERRAIN;
// load marker image
QImage image(":/images/marker.png");
QImage glImage = QGLWidget::convertToGLFormat(image);
unsigned char* data = new unsigned char[glImage.byteCount()];
for(int i=0; i<glImage.byteCount(); i++)
{
data[i] = glImage.bits()[i];
}
_markerImage = new osg::Image();
_markerImage->setImage(glImage.width(),
glImage.height(),
1,
4,
GL_RGBA,
GL_UNSIGNED_BYTE,
data,
osg::Image::USE_NEW_DELETE,
1);
// setup placemark style
_placeStyle.getOrCreate<AltitudeSymbol>()->clamping() = AltitudeSymbol::CLAMP_TO_TERRAIN;
}
void MainWindow::setupUI()
{
QWidget * widget = new QWidget();
QFormLayout * formLayout = new QFormLayout();
widget->setLayout(formLayout);
setCentralWidget(widget);
// connect widget signals / slots
connect(&xSpinBox_, SIGNAL(editingFinished()), this, SLOT(updateCoordinates()));
connect(&ySpinBox_, SIGNAL(editingFinished()), this, SLOT(updateCoordinates()));
connect(&widthSpinBox_, SIGNAL(editingFinished()), this, SLOT(updateCoordinates()));
connect(&heightSpinBox_, SIGNAL(editingFinished()), this, SLOT(updateCoordinates()));
connect(&retinaBox_, SIGNAL(released()), this, SLOT(updateCoordinates()));
hostnameLineEdit_.setText( DEFAULT_HOST_ADDRESS );
char hostname[256] = {0};
gethostname( hostname, 256 );
uriLineEdit_.setText( hostname );
const int screen = -1;
QRect desktopRect = QApplication::desktop()->screenGeometry( screen );
xSpinBox_.setRange(0, desktopRect.width());
ySpinBox_.setRange(0, desktopRect.height());
widthSpinBox_.setRange(1, desktopRect.width());
heightSpinBox_.setRange(1, desktopRect.height());
// default to full screen
xSpinBox_.setValue(0);
ySpinBox_.setValue(0);
widthSpinBox_.setValue( desktopRect.width( ));
heightSpinBox_.setValue( desktopRect.height( ));
// call updateCoordinates() to commit coordinates from the UI
updateCoordinates();
// frame rate limiting
frameRateSpinBox_.setRange(1, 60);
frameRateSpinBox_.setValue(24);
// add widgets to UI
formLayout->addRow("Hostname", &hostnameLineEdit_);
formLayout->addRow("Stream name", &uriLineEdit_);
formLayout->addRow("X", &xSpinBox_);
formLayout->addRow("Y", &ySpinBox_);
formLayout->addRow("Width", &widthSpinBox_);
formLayout->addRow("Height", &heightSpinBox_);
formLayout->addRow("Retina Display", &retinaBox_);
formLayout->addRow("Max frame rate", &frameRateSpinBox_);
formLayout->addRow("Actual frame rate", &frameRateLabel_);
// share desktop action
shareDesktopAction_ = new QAction("Share Desktop", this);
shareDesktopAction_->setStatusTip("Share desktop");
shareDesktopAction_->setCheckable(true);
shareDesktopAction_->setChecked(false);
connect(shareDesktopAction_, SIGNAL(triggered(bool)), this, SLOT(shareDesktop(bool))); // Only user actions
connect(this, SIGNAL(streaming(bool)), shareDesktopAction_, SLOT(setChecked(bool)));
// show desktop selection window action
showDesktopSelectionWindowAction_ = new QAction("Show Rectangle", this);
showDesktopSelectionWindowAction_->setStatusTip("Show desktop selection rectangle");
showDesktopSelectionWindowAction_->setCheckable(true);
showDesktopSelectionWindowAction_->setChecked(false);
connect(showDesktopSelectionWindowAction_, SIGNAL(triggered(bool)), this, SLOT(showDesktopSelectionWindow(bool))); // Only user actions
// create toolbar
QToolBar * toolbar = addToolBar("toolbar");
// add buttons to toolbar
toolbar->addAction(shareDesktopAction_);
toolbar->addAction(showDesktopSelectionWindowAction_);
// Update timer
connect(&shareDesktopUpdateTimer_, SIGNAL(timeout()), this, SLOT(shareDesktopUpdate()));
}
Fenetre::Fenetre(QWidget *parent) : courant(0), QMainWindow(parent)
{
//*************************
courant = NULL;
folder = NULL;
resize(1200, 512);
//*************************** Menu ***************************
QMenu* mFile = menuBar()->addMenu("&File");
QMenu* mEdit = menuBar()->addMenu("&Edit");
QMenu* mView = menuBar()->addMenu("&View");
QMenu* mNouveau = mFile->addMenu("New");
QAction* mactionAnnuler = mEdit->addAction("Annuler");
QAction* mactionRefaire = mEdit->addAction("Refaire");
QAction* mactionSupprimer = mEdit->addAction("Supprimer");
QMenu* mTag = mEdit->addMenu("Tags");
QAction* mactionSupprimerTag = mTag->addAction("Supprimer");
QMenu* mDocument = mEdit->addMenu("Documents");
QAction* mactionUp = mDocument->addAction("Monter");
QAction* mactionDown = mDocument->addAction("Descendre");
QMenu* mExport = mEdit->addMenu("Exporter");
QAction* mactionOuvrir = mFile->addAction("Ouvrir un espace de travail");
QAction* mactionNew = mFile->addAction("Nouvel espace de travail");
QAction* mactionSaveAs = mFile->addAction("Enregistrer sous...");
QAction* mactionNewArticle = mNouveau->addAction("Article");
QAction* mactionNewImage = mNouveau->addAction("Image");
QAction* mactionNewAudio = mNouveau->addAction("Audio");
QAction* mactionNewVideo = mNouveau->addAction("Video");
QAction* mactionNewDocument = mNouveau->addAction("Document");
QAction* mactionExportHTML = mExport->addAction("Html");
QAction* mactionExportTex = mExport->addAction("Tex");
QAction* mactionExportTexte = mExport->addAction("Texte");
QAction* mactionOption=mEdit->addAction("Setting");
QAction* mactionAddTag = mNouveau->addAction("Tag");
QAction* mactionSave = mFile->addAction("Sauvegarder");
mFile->addSeparator();
QMenu* ouvrirCorbeille = mFile->addMenu("Corbeille");
QAction* mactionRestaurer = ouvrirCorbeille->addAction("Restaurer");
QAction* mactionVider = ouvrirCorbeille->addAction("Vider la Corbeille");
mactionViewEdit = mView->addAction("Onglet Editeur");
mactionViewHTML = mView->addAction("Onglet Html");
mactionViewTex = mView->addAction("Onglet Tex");
mactionViewTexte = mView->addAction("Onglet Texte");
mFile->addSeparator();
QAction* actionQuitter = mFile->addAction("&Quitter");
actionQuitter->setIcon(QIcon("icon/quitter.png"));
mactionNewArticle->setIcon(QIcon("icon/article.png"));
mactionNewImage->setIcon(QIcon("icon/image.png"));
mactionNewAudio->setIcon(QIcon("icon/audio.png"));
mactionNewVideo->setIcon(QIcon("icon/video.png"));
mNouveau->setIcon(QIcon("icon/plus.png"));
mactionDown->setIcon(QIcon("icon/down.png"));
mactionUp->setIcon(QIcon("icon/up.png"));
mactionAddTag->setIcon(QIcon("icon/tag.png"));
mactionSave->setIcon(QIcon("icon/save.png"));
mactionExportHTML->setIcon(QIcon("icon/html.png"));
mactionExportTex->setIcon(QIcon("icon/tex.png"));
mactionExportTexte->setIcon(QIcon("icon/texte.png"));
mactionAnnuler->setIcon(QIcon("icon/undo.png"));
mactionRefaire->setIcon(QIcon("icon/redo.png"));
mactionSupprimer->setIcon(QIcon("icon/cross.png"));
mactionRestaurer->setIcon(QIcon("icon/corbeille.png"));
mactionNewDocument->setIcon(QIcon("icon/document.png"));
mactionOption->setIcon(QIcon("icon/setting.png"));
mactionOuvrir->setShortcut(QKeySequence("Ctrl+O"));
actionQuitter->setShortcut(QKeySequence("Ctrl+Q"));
mactionSave->setShortcut(QKeySequence("Ctrl+S"));
mactionAnnuler->setShortcut(QKeySequence("Ctrl+Z"));
mactionRefaire->setShortcut(QKeySequence("Ctrl+Y"));
mactionSupprimer->setShortcut(tr("Delete"));
//** VIEW **//
mactionViewEdit->setCheckable(true);
mactionViewEdit->setChecked(true);
mactionViewHTML->setCheckable(true);
mactionViewTex->setCheckable(true);
mactionViewTexte->setCheckable(true);
//Bar de statue
QStatusBar* statusBar = new QStatusBar;
statusBar->addWidget(new QLabel("Projet Lo21 - Pauline Crouillère / Emilien Notarianni"));
this->setStatusBar(statusBar);
// Création de la barre d'outils
QToolBar *toolBarFichier = addToolBar("Fichier");
toolBarFichier->addAction(mactionNewArticle);
toolBarFichier->addAction(mactionNewImage);
toolBarFichier->addAction(mactionNewAudio);
toolBarFichier->addAction(mactionNewVideo);
toolBarFichier->addAction(mactionNewDocument);
toolBarFichier->addSeparator();
toolBarFichier->addAction(mactionAddTag);
toolBarFichier->addSeparator();
toolBarFichier->addAction(mactionUp);
toolBarFichier->addAction(mactionDown);
toolBarFichier->addSeparator();
toolBarFichier->addAction(mactionExportHTML);
toolBarFichier->addAction(mactionExportTex);
toolBarFichier->addAction(mactionExportTexte);
toolBarFichier->addSeparator();
toolBarFichier->addAction(mactionRestaurer);
toolBarFichier->addSeparator();
toolBarFichier->addAction(mactionSupprimer);
toolBarFichier->addSeparator();
toolBarFichier->addAction(actionQuitter);
/*************************************************************/
couche = new QHBoxLayout();
lw = new LeftWindows();
ow = new OngletWindows();
couche->addWidget(lw);
couche->addWidget(ow);
couche->setMargin(0);
couche->setAlignment(Qt::AlignTop);
centerWindows = new QWidget();
centerWindows->setLayout(couche);
setCentralWidget(centerWindows);
//************************** CONNECT **************************/
QObject::connect(mactionNewArticle, SIGNAL(triggered()), this, SLOT(newArticle()));
QObject::connect(mactionNewDocument, SIGNAL(triggered()), this, SLOT(newDocument()));
QObject::connect(mactionNewImage, SIGNAL(triggered()), this, SLOT(newImage()));
QObject::connect(mactionNewAudio, SIGNAL(triggered()), this, SLOT(newAudio()));
QObject::connect(mactionNewVideo, SIGNAL(triggered()), this, SLOT(newVideo()));
QObject::connect(mactionAddTag, SIGNAL(triggered()), this, SLOT(newTag()));
QObject::connect(mactionOuvrir,SIGNAL(triggered()),this, SLOT(ouvrirDialogue()));
QObject::connect(actionQuitter,SIGNAL(triggered()),qApp, SLOT(quit()));
QObject::connect(mactionUp,SIGNAL(triggered()),this, SLOT(docUp()));
QObject::connect(mactionDown,SIGNAL(triggered()),this, SLOT(docDown()));
QObject::connect(mactionRestaurer, SIGNAL(triggered()), this, SLOT(ouvrirCorbeille()));
QObject::connect(mactionSave, SIGNAL(triggered()), this, SLOT(asave()));
QObject::connect(mactionExportHTML, SIGNAL(triggered()), this, SLOT(exportHTML()));
QObject::connect(mactionExportTex, SIGNAL(triggered()), this, SLOT(exportTex()));
QObject::connect(mactionExportTexte, SIGNAL(triggered()), this, SLOT(exportTexte()));
QObject::connect(mactionSupprimer, SIGNAL(triggered()), this, SLOT(deleteInCorbeille()));
QObject::connect(mactionVider, SIGNAL(triggered()), this, SLOT(viderLaCorbeille()));
//TODO
QObject::connect(mactionAnnuler, SIGNAL(triggered()), qApp, SLOT(undo()));
QObject::connect(mactionRefaire, SIGNAL(triggered()), qApp, SLOT(redo()));
//
QObject::connect(mactionSaveAs, SIGNAL(triggered()), this, SLOT(copieWorkSpace()));
QObject::connect(mactionNew, SIGNAL(triggered()), this, SLOT(newWorkSpace()));
QObject::connect(mactionOption, SIGNAL(triggered()), this, SLOT(setting()));
QObject::connect(mactionViewEdit, SIGNAL(triggered()), this, SLOT(changeEdit()));
QObject::connect(mactionViewHTML, SIGNAL(triggered()), this, SLOT(changeHtml()));
QObject::connect(mactionViewTex,SIGNAL(triggered()),this, SLOT(changeTex()));
QObject::connect(mactionViewTexte,SIGNAL(triggered()),this, SLOT(changeTexte()));
QObject::connect(ow, SIGNAL(currentChanged(int)), this, SLOT(changeOnglet(int)));
QObject::connect(mactionSupprimerTag, SIGNAL(triggered()), this, SLOT(supprimeTag()));
}
