MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent)
{
QMenu *file;
QMenu *edit;
QMenu *effect;
QMenu *tools;
QMenu *help;
QAction *newa = new QAction(tr("&New"), this);
QAction *open = new QAction(tr("&Open"), this);
QAction *save = new QAction(tr("&Save"), this);
QAction *saveas = new QAction(tr("&Save as"), this);
QAction *import = new QAction(tr("&Import sample"), this);
QAction *quit = new QAction(tr("&Quit"), this);
QAction *play = new QAction(tr("&Play"), this);
QAction *stop = new QAction(tr("&Stop"), this);
QAction *pause = new QAction(tr("&Pause"), this);
QAction *record= new QAction(tr("&Record"), this);
QAction *zoomin = new QAction(tr("Zoom in"), this);
QAction *zoomout = new QAction(tr("Zoom out"), this);
QAction *settings = new QAction(tr("&Settings"), this);
QToolBar *toolbar = addToolBar("Main ToolBar");
QLCDNumber *lcd = new QLCDNumber();
QLabel * play_v = new QLabel(), * rec_v = new QLabel();
QSlider * play_slider = new QSlider(Qt::Horizontal), * rec_slider = new QSlider(Qt::Horizontal);
wave = new Wave();
fileName = "";
changed = false;
newa->setIcon(QIcon::fromTheme("document-new"));
newa->setShortcut(tr("CTRL+N"));
open->setIcon(QIcon::fromTheme("document-open"));
open->setShortcut(tr("CTRL+O"));
save->setIcon(QIcon::fromTheme("document-save"));
save->setShortcut(tr("CTRL+S"));
saveas->setIcon(QIcon::fromTheme("document-save-as"));
import->setIcon(QIcon::fromTheme("audio-x-generic"));
zoomin->setIcon(QIcon::fromTheme("zoom-in"));
zoomin->setShortcut(tr("CTRL+Up"));
zoomout->setIcon(QIcon::fromTheme("zoom-out"));
zoomout->setShortcut(tr("CTRL+Down"));
play->setIcon(QIcon::fromTheme("media-playback-start"));
play->setShortcut(tr("Space"));
play->setCheckable(true);
stop->setIcon(QIcon::fromTheme("media-playback-stop"));
pause->setIcon(QIcon::fromTheme("media-playback-pause"));
record->setIcon(QIcon::fromTheme("media-record"));
record->setShortcut(tr("Ctrl+Space"));
record->setCheckable(true);
quit->setIcon(QIcon::fromTheme("application-exit"));
quit->setShortcut(tr("CTRL+Q"));
lcd->setDigitCount(8);
lcd->display("00:00:00");
lcd->setStyleSheet("background: black; color: #00FF00");
lcd->setFixedSize(100, 30);
play_v->setText(tr("Playback volume:"));
rec_v->setText(tr("Record volume:"));
play_slider->setMaximumWidth(50);
play_slider->setRange(0, 100);
rec_slider->setMaximumWidth(50);
rec_slider->setRange(0, 100);
file = menuBar()->addMenu(tr("&File"));
file->addAction(newa);
file->addAction(open);
file->addAction(save);
file->addAction(saveas);
file->addSeparator();
file->addAction(import);
file->addSeparator();
file->addAction(quit);
edit = menuBar()->addMenu(tr("&Edit"));
effect = menuBar()->addMenu(tr("&Effects"));
tools = menuBar()->addMenu(tr("&Tools"));
settings->setIcon(QIcon::fromTheme("multimedia-volume-control"));
tools->addAction(settings);
help = menuBar()->addMenu(tr("&Help"));
toolbar->addAction(newa);
toolbar->addAction(open);
toolbar->addAction(save);
toolbar->addSeparator();
toolbar->addAction(import);
toolbar->addAction(zoomin);
toolbar->addAction(zoomout);
toolbar->addSeparator();
toolbar->addAction(stop);
toolbar->addAction(pause);
toolbar->addAction(play);
toolbar->addAction(record);
toolbar->addSeparator();
toolbar->addWidget(play_v);
toolbar->addWidget(play_slider);
toolbar->addWidget(rec_v);
toolbar->addWidget(rec_slider);
toolbar->addWidget(lcd);
connect(newa, SIGNAL(triggered()), this, SLOT(newFile()));
connect(open, SIGNAL(triggered()), this, SLOT(openFile()));
connect(save, SIGNAL(triggered()), this, SLOT(saveFile()));
connect(saveas, SIGNAL(triggered()), this, SLOT(saveFileAs()));
connect(quit, SIGNAL(triggered()), qApp, SLOT(quit()));
connect(zoomin, SIGNAL(triggered()), this, SLOT(zoomIn()));
connect(zoomout, SIGNAL(triggered()), this, SLOT(zoomOut()));
connect(settings, SIGNAL(triggered()), this, SLOT(settings()));
setCentralWidget(wave);
float * buffer;
buffer = (float*)malloc(44100*sizeof(float));
for (unsigned int i=0; i<44100; i++)
{
buffer[i]=sin(1*(2*M_PI)*i/44100);
}
wave->setSampleRate(44100);
wave->setBytesPerSecond(1000);
wave->setBuffer(buffer, 44100);
}
void CQTOpenGLLuaMainWindow::CreateEditActions() {
QIcon cEditUndoIcon;
cEditUndoIcon.addPixmap(QPixmap(m_pcMainWindow->GetIconDir() + "/undo.png"));
m_pcEditUndoAction = new QAction(cEditUndoIcon, tr("&Undo"), this);
m_pcEditUndoAction->setToolTip(tr("Undo last operation"));
m_pcEditUndoAction->setStatusTip(tr("Undo last operation"));
m_pcEditUndoAction->setShortcut(QKeySequence::Undo);
connect(m_pcEditUndoAction, SIGNAL(triggered()),
m_pcCodeEditor, SLOT(undo()));
QIcon cEditRedoIcon;
cEditRedoIcon.addPixmap(QPixmap(m_pcMainWindow->GetIconDir() + "/redo.png"));
m_pcEditRedoAction = new QAction(cEditRedoIcon, tr("&Redo"), this);
m_pcEditRedoAction->setToolTip(tr("Redo last operation"));
m_pcEditRedoAction->setStatusTip(tr("Redo last operation"));
m_pcEditRedoAction->setShortcut(QKeySequence::Redo);
connect(m_pcEditRedoAction, SIGNAL(triggered()),
m_pcCodeEditor, SLOT(redo()));
QIcon cEditCopyIcon;
cEditCopyIcon.addPixmap(QPixmap(m_pcMainWindow->GetIconDir() + "/copy.png"));
m_pcEditCopyAction = new QAction(cEditCopyIcon, tr("&Copy"), this);
m_pcEditCopyAction->setToolTip(tr("Copy selected text into clipboard"));
m_pcEditCopyAction->setStatusTip(tr("Copy selected text into clipboard"));
m_pcEditCopyAction->setShortcut(QKeySequence::Copy);
connect(m_pcEditCopyAction, SIGNAL(triggered()),
m_pcCodeEditor, SLOT(copy()));
QIcon cEditCutIcon;
cEditCutIcon.addPixmap(QPixmap(m_pcMainWindow->GetIconDir() + "/cut.png"));
m_pcEditCutAction = new QAction(cEditCutIcon, tr("&Cut"), this);
m_pcEditCutAction->setToolTip(tr("Move selected text into clipboard"));
m_pcEditCutAction->setStatusTip(tr("Move selected text into clipboard"));
m_pcEditCutAction->setShortcut(QKeySequence::Cut);
connect(m_pcEditCutAction, SIGNAL(triggered()),
m_pcCodeEditor, SLOT(cut()));
QIcon cEditPasteIcon;
cEditPasteIcon.addPixmap(QPixmap(m_pcMainWindow->GetIconDir() + "/paste.png"));
m_pcEditPasteAction = new QAction(cEditPasteIcon, tr("&Paste"), this);
m_pcEditPasteAction->setToolTip(tr("Paste text from clipboard"));
m_pcEditPasteAction->setStatusTip(tr("Paste text from clipboard"));
m_pcEditPasteAction->setShortcut(QKeySequence::Paste);
connect(m_pcEditPasteAction, SIGNAL(triggered()),
m_pcCodeEditor, SLOT(paste()));
// QIcon cEditFindIcon;
// cEditFindIcon.addPixmap(QPixmap(m_pcMainWindow->GetIconDir() + "/find.png"));
// m_pcEditFindAction = new QAction(cEditFindIcon, tr("&Find/Replace"), this);
// m_pcEditFindAction->setToolTip(tr("Find/replace text"));
// m_pcEditFindAction->setStatusTip(tr("Find/replace text"));
// m_pcEditFindAction->setShortcut(QKeySequence::Find);
// connect(m_pcEditFindAction, SIGNAL(triggered()),
// this, SLOT(Find()));
QMenu* pcMenu = menuBar()->addMenu(tr("&Edit"));
pcMenu->addAction(m_pcEditUndoAction);
pcMenu->addAction(m_pcEditRedoAction);
pcMenu->addSeparator();
pcMenu->addAction(m_pcEditCopyAction);
pcMenu->addAction(m_pcEditCutAction);
pcMenu->addAction(m_pcEditPasteAction);
// pcMenu->addSeparator();
// pcMenu->addAction(m_pcEditFindAction);
QToolBar* pcToolBar = addToolBar(tr("Edit"));
pcToolBar->setObjectName("EditToolBar");
pcToolBar->setIconSize(QSize(32,32));
pcToolBar->addAction(m_pcEditUndoAction);
pcToolBar->addAction(m_pcEditRedoAction);
pcToolBar->addSeparator();
pcToolBar->addAction(m_pcEditCopyAction);
pcToolBar->addAction(m_pcEditCutAction);
pcToolBar->addAction(m_pcEditPasteAction);
// pcToolBar->addAction(m_pcEditFindAction);
}
Reviews::Reviews( QWidget * parent, Okular::Document * document )
: QWidget( parent ), m_document( document )
{
// create widgets and layout them vertically
QVBoxLayout * vLayout = new QVBoxLayout( this );
vLayout->setMargin( 0 );
vLayout->setSpacing( 6 );
m_view = new TreeView( m_document, this );
m_view->setAlternatingRowColors( true );
m_view->setSelectionMode( QAbstractItemView::ExtendedSelection );
m_view->header()->hide();
QToolBar *toolBar = new QToolBar( this );
toolBar->setObjectName( QLatin1String( "reviewOptsBar" ) );
QSizePolicy sp = toolBar->sizePolicy();
sp.setVerticalPolicy( QSizePolicy::Minimum );
toolBar->setSizePolicy( sp );
m_model = new AnnotationModel( m_document, m_view );
m_filterProxy = new PageFilterProxyModel( m_view );
m_groupProxy = new PageGroupProxyModel( m_view );
m_authorProxy = new AuthorGroupProxyModel( m_view );
m_filterProxy->setSourceModel( m_model );
m_groupProxy->setSourceModel( m_filterProxy );
m_authorProxy->setSourceModel( m_groupProxy );
m_view->setModel( m_authorProxy );
m_searchLine = new KTreeViewSearchLine( this, m_view );
m_searchLine->setCaseSensitivity( Okular::Settings::self()->reviewsSearchCaseSensitive() ? Qt::CaseSensitive : Qt::CaseInsensitive );
m_searchLine->setRegularExpression( Okular::Settings::self()->reviewsSearchRegularExpression() );
connect( m_searchLine, SIGNAL(searchOptionsChanged()), this, SLOT(saveSearchOptions()) );
vLayout->addWidget( m_searchLine );
vLayout->addWidget( m_view );
vLayout->addWidget( toolBar );
toolBar->setIconSize( QSize( 16, 16 ) );
toolBar->setMovable( false );
// - add Page button
QAction * groupByPageAction = toolBar->addAction( KIcon( "text-x-generic" ), i18n( "Group by Page" ) );
groupByPageAction->setCheckable( true );
connect( groupByPageAction, SIGNAL(toggled(bool)), this, SLOT(slotPageEnabled(bool)) );
groupByPageAction->setChecked( Okular::Settings::groupByPage() );
// - add Author button
QAction * groupByAuthorAction = toolBar->addAction( KIcon( "user-identity" ), i18n( "Group by Author" ) );
groupByAuthorAction->setCheckable( true );
connect( groupByAuthorAction, SIGNAL(toggled(bool)), this, SLOT(slotAuthorEnabled(bool)) );
groupByAuthorAction->setChecked( Okular::Settings::groupByAuthor() );
// - add separator
toolBar->addSeparator();
// - add Current Page Only button
QAction * curPageOnlyAction = toolBar->addAction( KIcon( "arrow-down" ), i18n( "Show reviews for current page only" ) );
curPageOnlyAction->setCheckable( true );
connect( curPageOnlyAction, SIGNAL(toggled(bool)), this, SLOT(slotCurrentPageOnly(bool)) );
curPageOnlyAction->setChecked( Okular::Settings::currentPageOnly() );
connect( m_view, SIGNAL(activated(QModelIndex)),
this, SLOT(activated(QModelIndex)) );
m_view->setContextMenuPolicy( Qt::CustomContextMenu );
connect( m_view, SIGNAL(customContextMenuRequested(QPoint)),
this, SLOT(contextMenuRequested(QPoint)) );
}
waveWaterfall::waveWaterfall (NV_INT32 *argc, NV_CHAR **argv, QWidget * parent):
QMainWindow (parent, 0)
{
extern char *optarg;
filError = NULL;
lock_track = NVFalse;
QResource::registerResource ("/icons.rcc");
// Have to set the focus policy or keypress events don't work properly at first in Focus Follows Mouse mode
setFocusPolicy (Qt::WheelFocus);
wave_type = PMT;
kill_switch = ANCILLARY_FORCE_EXIT;
NV_INT32 option_index = 0;
while (NVTrue)
{
static struct option long_options[] = {{"shared_memory_key", required_argument, 0, 0},
{"kill_switch", required_argument, 0, 0},
{0, no_argument, 0, 0}};
NV_CHAR c = (NV_CHAR) getopt_long (*argc, argv, "ap", long_options, &option_index);
if (c == -1) break;
switch (c)
{
case 0:
switch (option_index)
{
case 0:
sscanf (optarg, "%d", &key);
break;
case 1:
sscanf (optarg, "%d", &kill_switch);
break;
}
break;
case 'a':
wave_type = APD;
break;
case 'p':
wave_type = PMT;
break;
}
}
if (!key)
{
fprintf (stderr, "\n\n--shared_memory_key argument not present on command line. Terminating!\n\n");
exit (-1);
}
// This is the "tools" toolbar. We have to do this here so that we can restore the toolbar location(s).
QToolBar *tools = addToolBar (tr ("Tools"));
tools->setObjectName (tr ("waveWaterfall main toolbar"));
QString cap;
if (wave_type == APD)
{
// Set the main icon
setWindowIcon (QIcon (":/icons/wave_waterfall_apd.png"));
cap.sprintf ("waveWaterfall (APD) : %s", VERSION);
}
else
{
// Set the main icon
setWindowIcon (QIcon (":/icons/wave_waterfall_pmt.png"));
cap.sprintf ("waveWaterfall (PMT) : %s", VERSION);
}
setWindowTitle (cap);
/******************************************* IMPORTANT NOTE ABOUT SHARED MEMORY **************************************** \
This is a little note about the use of shared memory within the Area-Based Editor (ABE) programs. If you read
the Qt documentation (or anyone else's documentation) about the use of shared memory they will say "Dear [insert
name of omnipotent being of your choice here], whatever you do, always lock shared memory when you use it!".
The reason they say this is that access to shared memory is not atomic. That is, reading shared memory and then
writing to it is not a single operation. An example of why this might be important - two programs are running,
the first checks a value in shared memory, sees that it is a zero. The second program checks the same location
and sees that it is a zero. These two programs have different actions they must perform depending on the value
of that particular location in shared memory. Now the first program writes a one to that location which was
supposed to tell the second program to do something but the second program thinks it's a zero. The second program
doesn't do what it's supposed to do and it writes a two to that location. The two will tell the first program
to do something. Obviously this could be a problem. In real life, this almost never occurs. Also, if you write
your program properly you can make sure this doesn't happen. In ABE we almost never lock shared memory because
something much worse than two programs getting out of sync can occur. If we start a program and it locks shared
memory and then dies, all the other programs will be locked up. When you look through the ABE code you'll see
that we very rarely lock shared memory, and then only for very short periods of time. This is by design.
\******************************************* IMPORTANT NOTE ABOUT SHARED MEMORY ****************************************/
// Get the shared memory area. If it doesn't exist, quit. It should have already been created
// by pfmView or geoSwath.
QString skey;
skey.sprintf ("%d_abe", key);
abeShare = new QSharedMemory (skey);
if (!abeShare->attach (QSharedMemory::ReadWrite))
{
fprintf (stderr, "\n\nError retrieving shared memory segment in %s.\n\n", argv[0]);
exit (-1);
}
abe_share = (ABE_SHARE *) abeShare->data ();
num_pfms = abe_share->pfm_count;
for (NV_INT32 pfm = 0 ; pfm < num_pfms ; pfm++)
{
open_args[pfm] = abe_share->open_args[pfm];
if ((pfm_handle[pfm] = open_existing_pfm_file (&open_args[pfm])) < 0)
{
QMessageBox::warning (this, tr ("Open PFM Structure"),
tr ("The file ") + QDir::toNativeSeparators (QString (abe_share->open_args[pfm].list_path)) +
tr (" is not a PFM handle or list file or there was an error reading the file.") +
tr (" The error message returned was:\n\n") +
QString (pfm_error_str (pfm_error)));
}
}
// Get the user's defaults
envin ();
// Set the window size and location from the defaults
if (wave_type == APD)
{
this->resize (apd_width, apd_height);
this->move (apd_window_x, apd_window_y);
width = apd_width;
height = apd_height;
}
else
{
this->resize (pmt_width, pmt_height);
this->move (pmt_window_x, pmt_window_y);
width = pmt_width;
height = pmt_height;
}
adjusted_width = width - MAX_STACK_POINTS * WAVE_OFFSET;
// Set the map values from the defaults
mapdef.projection = NO_PROJECTION;
mapdef.draw_width = width;
mapdef.draw_height = height;
mapdef.overlap_percent = 5;
mapdef.grid_inc_x = 0.0;
mapdef.grid_inc_y = 0.0;
mapdef.coasts = NVFalse;
mapdef.landmask = NVFalse;
mapdef.border = 0;
mapdef.coast_color = Qt::white;
mapdef.grid_color = Qt::white;
mapdef.background_color = backgroundColor;
mapdef.initial_bounds.min_x = 0;
mapdef.initial_bounds.min_y = 0;
mapdef.initial_bounds.max_x = 500;
mapdef.initial_bounds.max_y = 2048;
QFrame *frame = new QFrame (this, 0);
setCentralWidget (frame);
// Make the map.
map = new nvMap (this, &mapdef);
map->setWhatsThis (mapText);
// Connect to the signals from the map class.
connect (map, SIGNAL (mousePressSignal (QMouseEvent *, NV_FLOAT64, NV_FLOAT64)), this,
SLOT (slotMousePress (QMouseEvent *, NV_FLOAT64, NV_FLOAT64)));
connect (map, SIGNAL (mouseMoveSignal (QMouseEvent *, NV_FLOAT64, NV_FLOAT64)), this,
SLOT (slotMouseMove (QMouseEvent *, NV_FLOAT64, NV_FLOAT64)));
connect (map, SIGNAL (resizeSignal (QResizeEvent *)), this, SLOT (slotResize (QResizeEvent *)));
connect (map, SIGNAL (postRedrawSignal (NVMAP_DEF)), this, SLOT (slotPlotWaves (NVMAP_DEF)));
// Layouts, what fun!
QVBoxLayout *vBox = new QVBoxLayout (frame);
vBox->addWidget (map);
for (NV_INT32 i = 0 ; i < MAX_STACK_POINTS ; i++)
{
statusBar[i] = new QStatusBar (frame);
statusBar[i]->setSizeGripEnabled (FALSE);
statusBar[i]->show ();
vBox->addWidget (statusBar[i]);
dateLabel[i] = new QLabel ("0000-00-00 (000) 00:00:00.00", this);
dateLabel[i]->setAlignment (Qt::AlignCenter);
dateLabel[i]->setMinimumSize (dateLabel[i]->sizeHint ());
dateLabel[i]->setWhatsThis (dateLabelText);
dateLabel[i]->setToolTip (tr ("Date and time"));
dateLabel[i]->setAutoFillBackground (TRUE);
dateLabelPalette[i] = dateLabel[i]->palette ();
lineLabel[i] = new QLabel ("Line 000-0", this);
lineLabel[i]->setAlignment (Qt::AlignCenter);
lineLabel[i]->setMinimumSize (lineLabel[i]->sizeHint ());
lineLabel[i]->setWhatsThis (lineLabelText);
lineLabel[i]->setToolTip (tr ("Line number"));
lineLabel[i]->setAutoFillBackground (TRUE);
lineLabelPalette[i] = lineLabel[i]->palette ();
distLabel[i] = new QLabel ("000.00", this);
distLabel[i]->setAlignment (Qt::AlignCenter);
distLabel[i]->setMinimumSize (distLabel[i]->sizeHint ());
distLabel[i]->setWhatsThis (distLabelText);
distLabel[i]->setToolTip (tr ("Distance in meters from selected points"));
distLabel[i]->setAutoFillBackground (TRUE);
distLabelPalette[i] = distLabel[i]->palette ();
statusBar[i]->addWidget (dateLabel[i], 1);
statusBar[i]->addWidget (lineLabel[i]);
statusBar[i]->addWidget (distLabel[i]);
}
// Button, button, who's got the buttons?
bQuit = new QToolButton (this);
bQuit->setIcon (QIcon (":/icons/quit.xpm"));
bQuit->setToolTip (tr ("Quit"));
bQuit->setWhatsThis (quitText);
connect (bQuit, SIGNAL (clicked ()), this, SLOT (slotQuit ()));
tools->addWidget (bQuit);
bMode = new QToolButton (this);
if (wave_line_mode)
{
bMode->setIcon (QIcon (":/icons/mode_line.xpm"));
}
else
{
bMode->setIcon (QIcon (":/icons/mode_dot.xpm"));
}
bMode->setToolTip (tr ("Wave drawing mode toggle"));
bMode->setWhatsThis (modeText);
bMode->setCheckable (TRUE);
bMode->setChecked (wave_line_mode);
connect (bMode, SIGNAL (toggled (bool)), this, SLOT (slotMode (bool)));
tools->addWidget (bMode);
bPrefs = new QToolButton (this);
bPrefs->setIcon (QIcon (":/icons/prefs.xpm"));
bPrefs->setToolTip (tr ("Change application preferences"));
bPrefs->setWhatsThis (prefsText);
connect (bPrefs, SIGNAL (clicked ()), this, SLOT (slotPrefs ()));
tools->addWidget (bPrefs);
tools->addSeparator ();
tools->addSeparator ();
QAction *bHelp = QWhatsThis::createAction (this);
bHelp->setIcon (QIcon (":/icons/contextHelp.xpm"));
tools->addAction (bHelp);
// Setup the file menu.
QAction *fileQuitAction = new QAction (tr ("&Quit"), this);
fileQuitAction->setShortcut (tr ("Ctrl+Q"));
fileQuitAction->setStatusTip (tr ("Exit from application"));
connect (fileQuitAction, SIGNAL (triggered ()), this, SLOT (slotQuit ()));
QMenu *fileMenu = menuBar ()->addMenu (tr ("&File"));
fileMenu->addAction (fileQuitAction);
// Setup the help menu.
QAction *aboutAct = new QAction (tr ("&About"), this);
aboutAct->setShortcut (tr ("Ctrl+A"));
aboutAct->setStatusTip (tr ("Information about waveWaterfall"));
connect (aboutAct, SIGNAL (triggered ()), this, SLOT (about ()));
QAction *acknowledgements = new QAction (tr ("A&cknowledgements"), this);
acknowledgements->setShortcut (tr ("Ctrl+c"));
acknowledgements->setStatusTip (tr ("Information about supporting libraries"));
connect (acknowledgements, SIGNAL (triggered ()), this, SLOT (slotAcknowledgements ()));
QAction *aboutQtAct = new QAction (tr ("About&Qt"), this);
aboutQtAct->setShortcut (tr ("Ctrl+Q"));
aboutQtAct->setStatusTip (tr ("Information about Qt"));
connect (aboutQtAct, SIGNAL (triggered ()), this, SLOT (aboutQt ()));
QMenu *helpMenu = menuBar ()->addMenu (tr ("&Help"));
helpMenu->addAction (aboutAct);
helpMenu->addSeparator ();
helpMenu->addAction (acknowledgements);
helpMenu->addAction (aboutQtAct);
map->setCursor (Qt::ArrowCursor);
map->enableSignals ();
QTimer *track = new QTimer (this);
connect (track, SIGNAL (timeout ()), this, SLOT (trackCursor ()));
track->start (10);
}
FenPrincipale::FenPrincipale()
{
showMaximized();
//showNormal();
QMenu *menuFichier = menuBar()->addMenu("&Fichier");
QAction *actionLoadImage = menuFichier->addAction("&Load Image");
actionLoadImage->setIcon(QIcon("Icons/fileopen.png"));
menuFichier->addAction(actionLoadImage);
QAction *actionExit = menuFichier->addAction("&Quitter");
actionExit->setIcon(QIcon("Icons/fileclose.png"));
menuFichier->addAction(actionExit);
//QMenu *menuTools = menuBar()->addMenu("&Tools");
QMenu *menuComm = menuBar()->addMenu("&Communication");
QAction *actionSend = menuComm->addAction("&Send to server");
actionSend->setIcon(QIcon("Icons/ok.png"));
// Création de la barre d'outils
QToolBar *toolBarFichier = addToolBar("Fichier");
toolBarFichier->addAction(actionLoadImage);
toolBarFichier->addAction(actionExit);
toolBarFichier->addSeparator();
toolBarFichier->addAction(actionSend);
QObject::connect(actionLoadImage, SIGNAL(triggered()), this, SLOT(LoadImageW()));
QObject::connect(actionExit, SIGNAL(triggered()), this, SLOT(close()));
QObject::connect(actionSend, SIGNAL(triggered()), this, SLOT(SendServer()));
QObject::connect(actionSend, SIGNAL(triggered()), this, SLOT(ShowResults()));
//
// Création des docks
//
// dock IMAGE
dockImage = new QDockWidget("Image", this);
setCentralWidget(dockImage);
ImageWidget = new QWidget;
dockImage->setWidget(ImageWidget);
// dock SERVEUR
dockServeur = new QDockWidget("Serveur", this);
addDockWidget(Qt::LeftDockWidgetArea, dockServeur);
QWidget *paramDock = new QWidget;
dockServeur->setWidget(paramDock);
QSize s(220,20);
adressServer1 = new QLineEdit(QString("138.195.102.25"));
adressServer1->setMaximumSize(s);
QHBoxLayout *adressLayout = new QHBoxLayout;
adressLayout->addWidget(adressServer1);
QWidget *adressWidget = new QWidget;
adressWidget->setLayout(adressLayout);
portAdressServer = new QLineEdit(QString("6006"));
portAdressServer->setMaximumSize(s);
QHBoxLayout *portLayout = new QHBoxLayout;
portLayout->addWidget(portAdressServer);
QWidget *portAdressWidget = new QWidget;
portAdressWidget->setLayout(portLayout);
QLabel *adressLabel = new QLabel("Adresse IP",paramDock);
QLabel *portLabel = new QLabel("Port",paramDock);
QPushButton *okServer = new QPushButton("Send");
QObject::connect(okServer, SIGNAL(clicked()),this,SLOT(SendServer()));
QObject::connect(okServer, SIGNAL(clicked()),this,SLOT(ShowResults()));
QVBoxLayout *paramLayout = new QVBoxLayout(paramDock);
paramLayout->addWidget(adressLabel);
paramLayout->addWidget(adressWidget);
paramLayout->addWidget(portLabel);
paramLayout->addWidget(portAdressWidget);
paramLayout->addWidget(okServer);
paramLayout->setAlignment(Qt::AlignLeft);
paramDock->setLayout(paramLayout);
//dockServeur->setGeometry(QRect(100,200,200,250));
dockServeur->setMaximumSize(250,200);
// dock RESULTATS
dockResults = new QDockWidget("Resultats",this);
addDockWidget(Qt::RightDockWidgetArea, dockResults);
dockResults->setMaximumWidth(250);
WidgetResults = new QWidget;
scrollArea = new QScrollArea;
dockResults->setWidget(scrollArea);
QPixmap *mini = new QPixmap(QString("test.jpg"));
Result R(mini,98,"t");
QPixmap *mini2 = new QPixmap(QString("9143.gif.jpg"));
Result R2(mini2,95,"v");
QPixmap *mini3 = new QPixmap(QString("test.jpg"));
Result R3(mini3,92,"t");
QPixmap *mini4 = new QPixmap(QString("test.jpg"));
Result R4(mini4,90,"t");
QPixmap *mini5 = new QPixmap(QString("test.jpg"));
Result R5(mini5,88,"t");
QPixmap *mini6 = new QPixmap(QString("test.jpg"));
Result R6(mini6,86,"t");
QPixmap *mini7 = new QPixmap(QString("test.jpg"));
Result R7(mini7,84,"t");
QPixmap *mini8 = new QPixmap(QString("test.jpg"));
Result R8(mini8,82,"t");
QPixmap *mini9 = new QPixmap(QString("test.jpg"));
Result R9(mini9,81,"t");
QPixmap *mini10 = new QPixmap(QString("test.jpg"));
Result R10(mini10,79,"t");
QPixmap *mini11 = new QPixmap(QString("test.jpg"));
Result R11(mini11,78,"t");
QPixmap *mini12 = new QPixmap(QString("test.jpg"));
Result R12(mini12,77,"t");
QPixmap *mini13 = new QPixmap(QString("test.jpg"));
Result R13(mini13,76,"t");
QPixmap *mini14 = new QPixmap(QString("test.jpg"));
Result R14(mini14,75,"t");
T.push_back(R);
T.push_back(R2);
T.push_back(R3);
T.push_back(R4);
T.push_back(R5);
T.push_back(R6);
T.push_back(R7);
T.push_back(R8);
T.push_back(R9);
T.push_back(R10);
T.push_back(R11);
T.push_back(R12);
T.push_back(R13);
T.push_back(R14);
}
//---------------------------------------------------------------
void SkewTWindow::createToolBar ()
{
QToolBar *toolBar = addToolBar (tr("skewt"));
toolBar->setFloatable(false);
toolBar->setMovable(false);
//------------------------------------
acExit = new QAction (this);
acExit->setToolTip (tr("Close the window"));
acExit->setIcon(QIcon(Util::pathImg("exit.png")));
connect(acExit, SIGNAL(triggered()), this, SLOT(actionsCommonSlot()));
toolBar->addAction (acExit);
acPrint = new QAction (this);
acPrint->setToolTip (tr("Print the diagram"));
acPrint->setIcon(QIcon(Util::pathImg("printer.png")));
connect(acPrint, SIGNAL(triggered()), this, SLOT(actionsCommonSlot()));
toolBar->addAction (acPrint);
acSaveImage = new QAction (this);
acSaveImage->setToolTip (tr("Save current image"));
acSaveImage->setIcon(QIcon(Util::pathImg("media-floppy.png")));
connect(acSaveImage, SIGNAL(triggered()), this, SLOT(actionsCommonSlot()));
toolBar->addAction (acSaveImage);
acExportData = new QAction (this);
acExportData->setToolTip (tr("Export data (spreadsheet file)"));
acExportData->setIcon(QIcon(Util::pathImg("spreadsheet.png")));
connect(acExportData, SIGNAL(triggered()), this, SLOT(actionsCommonSlot()));
toolBar->addAction (acExportData);
toolBar->addSeparator();
//------------------------------------
toolBar->addWidget (new QLabel (tr("T max: ")));
cbTempMax = new QComboBox (this);
for (int t=-40; t<=80; t+=5)
cbTempMax->addItem (QString("%1 °C").arg(t), t);
cbTempMax->setMaxVisibleItems (50);
connect(cbTempMax, SIGNAL(activated(int)), this, SLOT(actionsCommonSlot()));
double tmax = Util::getSetting ("skewt_tempCMax", 40).toDouble();
cbTempMax->setCurrentIndex (cbTempMax->findData (tmax));
toolBar->addWidget (cbTempMax);
//------------------------------------
toolBar->addWidget (new QLabel (tr("P min: ")));
cbHpaMin = new QComboBox (this);
for (int p=100; p<=700; p+=100)
cbHpaMin->addItem (QString("%1 hPa").arg(p), p-5);
connect(cbHpaMin, SIGNAL(activated(int)), this, SLOT(actionsCommonSlot()));
double pmin = Util::getSetting ("skewt_hpaMin", 190).toDouble();
cbHpaMin->setCurrentIndex (cbHpaMin->findData (pmin));
toolBar->addWidget (cbHpaMin);
//------------------------------------
double sz;
toolBar->addWidget (new QLabel (tr("Size: ")));
cbSizeW = new QComboBox (this);
for (double s=600; s<=2000; s+=200)
cbSizeW->addItem (QString("%1").arg(s), s);
connect(cbSizeW, SIGNAL(activated(int)), this, SLOT(actionsCommonSlot()));
sz = Util::getSetting ("skewt_sizeW", 800).toDouble();
cbSizeW->setCurrentIndex (cbSizeW->findData (sz));
toolBar->addWidget (cbSizeW);
cbSizeH = new QComboBox (this);
for (double s=600; s<=2000; s+=200)
cbSizeH->addItem (QString("%1").arg(s), s);
connect(cbSizeH, SIGNAL(activated(int)), this, SLOT(actionsCommonSlot()));
sz = Util::getSetting ("skewt_sizeH", 800).toDouble();
cbSizeH->setCurrentIndex (cbSizeH->findData (sz));
toolBar->addWidget (cbSizeH);
toolBar->addSeparator();
//------------------------------------
chkShowConv = new QCheckBox (tr("Base: "),this);
chkShowConv->setChecked (Util::getSetting ("skewt_showConvectiveCurves",true).toBool());
connect(chkShowConv, SIGNAL(stateChanged(int)), this, SLOT(actionsCommonSlot()));
toolBar->addWidget (chkShowConv);
cbConvBase = new QComboBox (this);
if (skewt->hasSurfaceData) {
cbConvBase->addItem ( ("Surface"), "surface");
cbConvBase->addItem ( ("Avg Surface-10 hPa"), "surface-10");
cbConvBase->addItem ( ("Avg Surface-20 hPa"), "surface-20");
cbConvBase->addItem ( ("Avg Surface-50 hPa"), "surface-50");
cbConvBase->addItem ( ("Avg Surface-100 hPa"), "surface-100");
}
cbConvBase->addItem ("1000 hPa", "1000-1000");
cbConvBase->addItem ("975 hPa", "975-975");
cbConvBase->addItem ("950 hPa", "950-950");
cbConvBase->addItem ("925 hPa", "925-925");
cbConvBase->addItem ("900 hPa", "900-900");
cbConvBase->addItem ("850 hPa", "850-850");
cbConvBase->addItem ("800 hPa", "800-800");
cbConvBase->addItem ("750 hPa", "750-750");
cbConvBase->addItem ("700 hPa", "700-700");
cbConvBase->addItem ("650 hPa", "650-650");
cbConvBase->addItem ("Avg 1000-975 hPa", "1000-975");
cbConvBase->addItem ("Avg 1000-950 hPa", "1000-950");
cbConvBase->addItem ("Avg 1000-925 hPa", "1000-925");
cbConvBase->addItem ("Avg 1000-900 hPa", "1000-900");
cbConvBase->addItem ("Avg 1000-850 hPa", "1000-850");
cbConvBase->addItem ("Avg 1000-800 hPa", "1000-800");
cbConvBase->setMaxVisibleItems (50);
connect(cbConvBase, SIGNAL(activated(int)), this, SLOT(actionsCommonSlot()));
QString sbase = Util::getSetting ("skewt_convectiveBase", "1000-1000").toString();
cbConvBase->setCurrentIndex (cbConvBase->findData (sbase));
cbConvBase->setEnabled (chkShowConv->isChecked());
toolBar->addWidget (cbConvBase);
}
/*! MyWindow constructor
* \param w - window width
* \param h - window hight
*/
MyWindow::MyWindow(int w, int h) : num_of_colors(18)
{
myBar = new QTabWidget(this);
setCentralWidget(myBar);
m_width = w;
m_height = h;
tab_number = 0;
number_of_tabs = 0;
testlayer = new Qt_layer( myBar );
colors_flag = true;
statusBar();
m_scailing_factor = 2;
// Traits Group
QActionGroup *traitsGroup = new QActionGroup( this ); // Connected later
traitsGroup->setExclusive( TRUE );
setSegmentTraits = new QAction("Segment Traits",
QPixmap( (const char**)line_xpm ),
"&Segment Traits", 0 ,traitsGroup,
"Segment Traits" );
setSegmentTraits->setToggleAction( TRUE );
setPolylineTraits = new QAction("Polyline Traits",
QPixmap( (const char**)polyline_xpm ),
"&Polyline Traits", 0 , traitsGroup,
"Polyline Traits" );
setPolylineTraits->setToggleAction( TRUE );
#ifdef CGAL_USE_CORE
setConicTraits = new QAction("Conic Traits",
QPixmap( (const char**)conic_xpm ),
"&Conic Traits", 0 , traitsGroup,
"Conic Traits" );
setConicTraits->setToggleAction( TRUE );
#endif
// Snap Mode Group
setSnapMode = new QAction("Snap Mode", QPixmap( (const char**)snapvertex_xpm ),
"&Snap Mode", 0 , this, "Snap Mode" );
setSnapMode->setToggleAction( TRUE );
setGridSnapMode = new QAction("Grid Snap Mode",
QPixmap( (const char**)snapgrid_xpm ),
"&Grid Snap Mode", 0 , this,
"Grid Snap Mode" );
setGridSnapMode->setToggleAction( TRUE );
// insert - delete - point_location Mode Group
QActionGroup *modeGroup = new QActionGroup( this ); // Connected later
modeGroup->setExclusive( TRUE );
insertMode = new QAction("Insert", QPixmap( (const char**)insert_xpm ),
"&Insert", 0 , modeGroup, "Insert" );
insertMode->setToggleAction( TRUE );
deleteMode = new QAction("Delete", QPixmap( (const char**)delete_xpm ),
"&Delete", 0 , modeGroup, "Delete" );
deleteMode->setToggleAction( TRUE );
pointLocationMode = new QAction("PointLocation",
QPixmap( (const char**)pointlocation_xpm ),
"&Point Location", 0 , modeGroup,
"Point Location" );
pointLocationMode->setToggleAction( TRUE );
rayShootingUpMode = new QAction("RayShootingUp",
QPixmap( (const char**)demo_rayshoot_up_xpm ),
"&Ray Shooting Up", 0 , modeGroup,
"Ray Shooting Up" );
rayShootingUpMode->setToggleAction( TRUE );
rayShootingDownMode = new QAction("RayShootingDown",
QPixmap( (const char**)demo_rayshoot_down_xpm ),
"&Ray Shooting Down", 0 , modeGroup,
"Ray Shooting Down" );
rayShootingDownMode->setToggleAction( TRUE );
dragMode = new QAction("Drag", QPixmap( (const char**)hand_xpm ),
"&Drag", 0 , modeGroup, "Drag" );
dragMode->setToggleAction( TRUE );
mergeMode = new QAction("Merge", QPixmap( (const char**)merge_xpm ),
"&Merge", 0 , modeGroup, "Merge" );
mergeMode->setToggleAction( TRUE );
splitMode = new QAction("Split", QPixmap( (const char**)split_xpm ),
"&Split", 0 , modeGroup, "Split" );
splitMode->setToggleAction( TRUE );
fillfaceMode = new QAction("Fill", QPixmap( (const char**)demo_fill_xpm ),
"&Fill", 0 , modeGroup, "Fill" );
fillfaceMode->setToggleAction( TRUE );
// zoom in
zoominBt = new QAction("Zoom in", QPixmap( (const char**)zoomin_xpm ),
"&Zoom in", 0 , this, "Zoom in" );
// zoom out
zoomoutBt = new QAction("Zoom out", QPixmap( (const char**)zoomout_xpm ),
"&Zoom out", 0 , this, "Zoom out" );
// color dialog
color_dialog_bt = new QAction("Choose color", QPixmap( (const char**)demo_colors_xpm ),
"&choose color", 0 , this, "choose color" );
lower_env_dialog_bt = new QAction("Lower envelope", QPixmap( (const char**)lower_env_xpm ),
"&lower envelope", 0, this, "Lower envelop" );
lower_env_dialog_bt->setToggleAction( TRUE );
upper_env_dialog_bt = new QAction("Upper envelope", QPixmap( (const char**)upper_env_xpm ),
"&upper envelope", 0, this, "Upper envelop" );
upper_env_dialog_bt->setToggleAction( TRUE );
#ifdef CGAL_USE_CORE
// Conic Type Group
QActionGroup *conicTypeGroup = new QActionGroup( this ); // Connected later
conicTypeGroup->setExclusive( TRUE );
setCircle = new QAction("Circle",
QPixmap( (const char**)demo_conic_circle_xpm ),
"&Circle", 0 ,conicTypeGroup,
"Circle" );
setCircle->setToggleAction( TRUE );
setSegment = new QAction("Segment",
QPixmap( (const char**)demo_conic_segment_xpm ),
"&Segment", 0 ,conicTypeGroup,
"Segment" );
setSegment->setToggleAction( TRUE );
setEllipse = new QAction("Ellipse",
QPixmap( (const char**)demo_conic_ellipse_xpm ),
"&Ellipse", 0 ,conicTypeGroup,
"Ellipse" );
setEllipse->setToggleAction( TRUE );
setParabola = new QAction("3 Points Arc",
QPixmap( (const char**)demo_conic_3points_xpm ),
"&3 Points Arc", 0 ,conicTypeGroup,
"3 Points Arc" );
setParabola->setToggleAction( TRUE );
setHyperbola = new QAction("5 Points Arc",
QPixmap( (const char**)demo_conic_5points_xpm ),
"&5 Points Arc", 0 ,conicTypeGroup,
"5 Points Arc" );
setHyperbola->setToggleAction( TRUE );
#endif
//create a timer for checking if somthing changed
QTimer *timer = new QTimer( this );
connect( timer, SIGNAL(timeout()),
this, SLOT(timer_done()) );
timer->start( 200, FALSE );
// file menu
QPopupMenu * file = new QPopupMenu( this );
menuBar()->insertItem( "&File", file );
file->insertItem("&Open Segment File...", this, SLOT(fileOpenSegment()));
file->insertItem("&Open Polyline File...", this, SLOT(fileOpenPolyline()));\
#ifdef CGAL_USE_CORE
file->insertItem("&Open Conic File...", this, SLOT(fileOpenConic()));
#endif
file->insertItem("&Open Segment Arr File...", this, SLOT(fileOpenSegmentPm()));
file->insertItem("&Open Polyline Arr File...", this, SLOT(fileOpenPolylinePm()));
//file->insertItem("&Open Conic Pm File", this, SLOT(fileOpenConicPm()));
file->insertItem("&Save...", this, SLOT(fileSave()));
file->insertItem("&Save As...", this, SLOT(fileSaveAs()));
//file->insertItem("&Save to ps...", this, SLOT(fileSave_ps()));
file->insertSeparator();
file->insertItem("&Print...", this , SLOT(print()));
file->insertSeparator();
file->insertItem( "&Close", this, SLOT(close()), CTRL+Key_X );
file->insertItem( "&Quit", qApp, SLOT( closeAllWindows() ), CTRL+Key_Q );
menuBar()->insertSeparator();
// tab menu
QPopupMenu * tab = new QPopupMenu( this );
menuBar()->insertItem( "&Tab", tab );
tab->insertItem("Add &Segment Tab", this, SLOT(add_segment_tab()));
tab->insertItem("Add &Polyline Tab", this, SLOT(add_polyline_tab()));
#ifdef CGAL_USE_CORE
tab->insertItem("Add &Conic Tab", this, SLOT(add_conic_tab()));
tab->insertSeparator();
#endif
tab->insertItem("Remove &Tab", this, SLOT(remove_tab()));
menuBar()->insertSeparator();
// mode menu
QPopupMenu * mode = new QPopupMenu( this );
menuBar()->insertItem( "&Mode", mode );
insertMode->addTo( mode );
deleteMode->addTo( mode );
pointLocationMode->addTo( mode );
rayShootingUpMode->addTo( mode );
rayShootingDownMode->addTo( mode );
dragMode->addTo( mode );
mergeMode->addTo( mode );
splitMode->addTo( mode );
fillfaceMode->addTo( mode );
menuBar()->insertSeparator();
// snap mode menu
QPopupMenu * snap_mode = new QPopupMenu( this );
menuBar()->insertItem( "&Snap mode", snap_mode );
setSnapMode->addTo(snap_mode);
setGridSnapMode->addTo(snap_mode);
menuBar()->insertSeparator();
// traits menu
QPopupMenu * traits = new QPopupMenu( this );
menuBar()->insertItem( "&Traits Type", traits );
setSegmentTraits->addTo(traits);
setPolylineTraits->addTo(traits);
#ifdef CGAL_USE_CORE
setConicTraits->addTo(traits);
#endif
// options menu
QPopupMenu * options = new QPopupMenu( this );
menuBar()->insertItem( "&Options", options );
options->insertSeparator();
options->insertItem("Overlay...", this, SLOT(overlay_pm()));
options->insertSeparator();
options->insertItem("Properties...", this, SLOT(properties()));
options->insertSeparator();
options->insertItem("Show Grid", this, SLOT(showGrid()));
options->insertItem("Hide Grid", this, SLOT(hideGrid()));
options->insertSeparator();
//options->insertItem("Conic Type", this, SLOT(conicType()));
//options->insertSeparator();
options->insertItem("Unbounded Face Color...", this, SLOT(backGroundColor()));
options->insertSeparator();
options->insertItem("Edge Color...", this, SLOT(changeEdgeColor()));
options->insertSeparator();
options->insertItem("Vertex Color...", this, SLOT(changeVertexColor()));
options->insertSeparator();
options->insertItem("Point-Locaiton Strategy....", this ,
SLOT(pointLocationStrategy()));
// help menu
QPopupMenu * help = new QPopupMenu( this );
menuBar()->insertItem( "&Help", help );
help->insertItem("How To...", this, SLOT(howto()), Key_F1);
help->insertSeparator();
help->insertItem("&About...", this, SLOT(about()), CTRL+Key_A );
help->insertItem("About &Qt...", this, SLOT(aboutQt()) );
QToolBar *modeTools = new QToolBar( this, "mode operations" );
modeTools->setLabel( "Mode Operations" );
insertMode->addTo( modeTools );
deleteMode->addTo( modeTools );
dragMode->addTo( modeTools );
pointLocationMode->addTo( modeTools );
rayShootingUpMode->addTo( modeTools );
rayShootingDownMode->addTo( modeTools );
mergeMode->addTo( modeTools );
splitMode->addTo( modeTools );
fillfaceMode->addTo( modeTools );
modeTools->addSeparator();
QToolBar *snapModeTools = new QToolBar( this, "snapMode operations" );
snapModeTools->setLabel( "Snap Mode Operations" );
snapModeTools->addSeparator();
setSnapMode->addTo( snapModeTools );
setGridSnapMode->addTo( snapModeTools );
snapModeTools->addSeparator();
QToolBar *traitsTool = new QToolBar( this, "traits type" );
traitsTool->setLabel( "Traits Type" );
traitsTool->addSeparator();
setSegmentTraits->addTo( traitsTool );
setPolylineTraits->addTo( traitsTool );
#ifdef CGAL_USE_CORE
setConicTraits->addTo( traitsTool );
#endif
traitsTool->addSeparator();
QToolBar *zoomTool = new QToolBar( this, "zoom" );
zoomTool->setLabel( "Zoom" );
zoomTool->addSeparator();
zoomoutBt->addTo( zoomTool );
zoominBt->addTo( zoomTool );
zoomTool->addSeparator();
QToolBar *colorTool = new QToolBar( this, "color" );
colorTool->addSeparator();
colorTool->setLabel("Choose color");
color_dialog_bt->addTo(colorTool);
colorTool->addSeparator();
QToolBar *envelopeTool = new QToolBar( this, "envelopes" );
envelopeTool->addSeparator();
envelopeTool->setLabel("Envelopes");
lower_env_dialog_bt->addTo(envelopeTool);
upper_env_dialog_bt->addTo(envelopeTool);
envelopeTool->addSeparator();
#ifdef CGAL_USE_CORE
conicTypeTool = new QToolBar( this, "conic type" );
conicTypeTool->setLabel( "Conic Type" );
conicTypeTool->addSeparator();
setSegment->addTo( conicTypeTool );
setCircle->addTo( conicTypeTool );
setEllipse->addTo( conicTypeTool );
setParabola->addTo( conicTypeTool );
setHyperbola->addTo( conicTypeTool );
#endif
connect( zoomoutBt, SIGNAL( activated () ) ,
this, SLOT( zoomout() ) );
connect( zoominBt, SIGNAL( activated () ) ,
this, SLOT( zoomin() ) );
connect (color_dialog_bt , SIGNAL( activated()) ,
this , SLOT(openColorDialog() ) );
connect (lower_env_dialog_bt, SIGNAL(toggled(bool)) ,
this, SLOT(lowerEnvelope(bool) ));
connect (upper_env_dialog_bt, SIGNAL(toggled(bool)) ,
this, SLOT(upperEnvelope(bool) ));
// connect mode group
connect( modeGroup, SIGNAL( selected(QAction*) ),
this, SLOT( updateMode(QAction*) ) );
// connect Traits Group
connect( traitsGroup, SIGNAL( selected(QAction*) ),
this, SLOT( updateTraitsType(QAction*) ) );
#ifdef CGAL_USE_CORE
// connect Conic Type Group
connect( conicTypeGroup, SIGNAL( selected(QAction*) ),
this, SLOT( updateConicType(QAction*) ) );
#endif
// connect Snap Mode
connect( setSnapMode, SIGNAL( toggled( bool ) ) ,
this, SLOT( updateSnapMode( bool ) ) );
connect( setGridSnapMode, SIGNAL( toggled( bool ) ) ,
this, SLOT( updateGridSnapMode( bool ) ) );
// connect the change of current tab
connect( myBar, SIGNAL( currentChanged(QWidget * ) ),
this, SLOT( update() ) );
colors = new QColor[num_of_colors];
colors[0] = Qt::blue;
colors[1] = Qt::gray;
colors[2] = Qt::green;
colors[3] = Qt::cyan;
colors[4] = Qt::magenta;
colors[5] = Qt::darkRed;
colors[6] = Qt::darkGreen;
colors[7] = Qt::darkBlue;
colors[8] = Qt::darkMagenta;
colors[9] = Qt::darkCyan;
colors[10] = Qt::yellow;
colors[11] = Qt::white;
colors[12] = Qt::darkGray;
colors[13] = Qt::gray;
colors[14] = Qt::red;
colors[15] = Qt::cyan;
colors[16] = Qt::darkYellow;
colors[17] = Qt::lightGray;
//state flag
old_state = 0;
add_segment_tab();
resize(m_width,m_height);
}
PianorollEditor::PianorollEditor(QWidget* parent)
: QMainWindow(parent)
{
setWindowTitle(QString("MuseScore"));
waveView = 0;
_score = 0;
staff = 0;
QWidget* mainWidget = new QWidget;
QToolBar* tb = addToolBar(tr("toolbar 1"));
tb->addAction(getAction("undo"));
tb->addAction(getAction("redo"));
tb->addSeparator();
#ifdef HAS_MIDI
tb->addAction(getAction("midi-on"));
#endif
tb->addSeparator();
tb->addAction(getAction("rewind"));
tb->addAction(getAction("play"));
tb->addSeparator();
tb->addAction(getAction("loop"));
tb->addSeparator();
tb->addAction(getAction("repeat"));
tb->addAction(getAction("follow"));
tb->addSeparator();
tb->addAction(getAction("metronome"));
showWave = new QAction(tr("Wave"), tb);
showWave->setToolTip(tr("show wave display"));
showWave->setCheckable(true);
showWave->setChecked(false);
connect(showWave, SIGNAL(toggled(bool)), SLOT(showWaveView(bool)));
tb->addAction(showWave);
//-------------
tb = addToolBar(tr("toolbar 2"));
static const char* sl3[] = { "voice-1", "voice-2", "voice-3", "voice-4" };
QActionGroup* voiceGroup = new QActionGroup(this);
for (const char* s : sl3) {
QAction* a = getAction(s);
a->setCheckable(true);
voiceGroup->addAction(a);
tb->addAction(getAction(s));
}
tb->addSeparator();
tb->addWidget(new QLabel(tr("Cursor:")));
pos = new Awl::PosLabel;
pos->setFrameStyle(QFrame::NoFrame | QFrame::Plain);
tb->addWidget(pos);
Awl::PitchLabel* pl = new Awl::PitchLabel();
pl->setFrameStyle(QFrame::NoFrame | QFrame::Plain);
tb->addWidget(pl);
tb->addSeparator();
tb->addWidget(new QLabel(tr("Velocity:")));
veloType = new QComboBox;
veloType->addItem(tr("offset"), MScore::OFFSET_VAL);
veloType->addItem(tr("user"), MScore::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);
//-------------
qreal xmag = .1;
ruler = new Ruler;
ruler->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
ruler->setFixedHeight(rulerHeight);
ruler->setMag(xmag, 1.0);
Piano* piano = new Piano;
piano->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding);
piano->setFixedWidth(pianoWidth);
gv = new PianoView;
gv->scale(xmag, 1.0);
gv->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
gv->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
hsb = new QScrollBar(Qt::Horizontal);
connect(gv->horizontalScrollBar(), SIGNAL(rangeChanged(int,int)),
SLOT(rangeChanged(int,int)));
// layout
QHBoxLayout* hbox = new QHBoxLayout;
hbox->setSpacing(0);
hbox->addWidget(piano);
hbox->addWidget(gv);
split = new QSplitter(Qt::Vertical);
split->setFrameShape(QFrame::NoFrame);
QWidget* split1 = new QWidget; // piano - pianoview
split1->setLayout(hbox);
split->addWidget(split1);
QGridLayout* layout = new QGridLayout;
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
layout->setColumnMinimumWidth(0, pianoWidth + 5);
layout->addWidget(tb, 0, 0, 1, 2);
layout->addWidget(ruler, 1, 1);
layout->addWidget(split, 2, 0, 1, 2);
layout->addWidget(hsb, 3, 1);
mainWidget->setLayout(layout);
setCentralWidget(mainWidget);
connect(gv->verticalScrollBar(), SIGNAL(valueChanged(int)), piano, SLOT(setYpos(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(hsb, SIGNAL(valueChanged(int)), SLOT(setXpos(int)));
connect(gv, SIGNAL(xposChanged(int)), SLOT(setXpos(int)));
connect(gv->horizontalScrollBar(), SIGNAL(valueChanged(int)), SLOT(setXpos(int)));
connect(ruler, SIGNAL(locatorMoved(int, const Pos&)), SLOT(moveLocator(int, const Pos&)));
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);
QAction* 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*)));
setXpos(0);
}
toSGATrace::toSGATrace(QWidget *main, toConnection &connection)
: toToolWidget(SGATraceTool, "trace.html", main, connection, "toSGATrace")
{
QToolBar *toolbar = toAllocBar(this, tr("SGA trace"));
layout()->addWidget(toolbar);
FetchAct = new QAction(QPixmap(const_cast<const char**>(refresh_xpm)),
tr("Fetch statements in SGA"), this);
FetchAct->setShortcut(QKeySequence::Refresh);
connect(FetchAct, SIGNAL(triggered()), this, SLOT(refresh(void)));
toolbar->addAction(FetchAct);
toolbar->addSeparator();
QLabel * labSchema = new QLabel(tr("Schema") + " ", toolbar);
toolbar->addWidget(labSchema);
Schema = new toResultCombo(toolbar);
Schema->additionalItem(tr("Any"));
Schema->setSelected(connection.user().toUpper());
Schema->query(toSQL::sql(toSQL::TOSQL_USERLIST));
toolbar->addWidget(Schema);
connect(Schema, SIGNAL(activated(const QString &)), this, SLOT(changeSchema(const QString &)));
toolbar->addSeparator();
QLabel * labRef = new QLabel(tr("Refresh") + " ", toolbar);
toolbar->addWidget(labRef);
connect(Refresh = toRefreshCreate(toolbar, TO_TOOLBAR_WIDGET_NAME),
SIGNAL(activated(const QString &)), this, SLOT(changeRefresh(const QString &)));
toolbar->addWidget(Refresh);
toolbar->addSeparator();
QLabel * labType = new QLabel(tr("Type") + " ", toolbar);
toolbar->addWidget(labType);
Type = new QComboBox(toolbar);
Type->addItem(tr("SGA"));
Type->addItem(tr("Long operations"));
toolbar->addWidget(Type);
toolbar->addSeparator();
QLabel * labSelect = new QLabel(tr("Selection") + " ", toolbar);
toolbar->addWidget(labSelect);
Limit = new QComboBox(toolbar);
Limit->addItem(tr("All"));
Limit->addItem(tr("Unfinished"));
Limit->addItem(tr("1 execution, 1 parse"));
Limit->addItem(tr("Top executions"));
Limit->addItem(tr("Top sorts"));
Limit->addItem(tr("Top diskreads"));
Limit->addItem(tr("Top buffergets"));
Limit->addItem(tr("Top rows"));
Limit->addItem(tr("Top sorts/exec"));
Limit->addItem(tr("Top diskreads/exec"));
Limit->addItem(tr("Top buffergets/exec"));
Limit->addItem(tr("Top rows/exec"));
Limit->addItem(tr("Top buffers/row"));
toolbar->addWidget(Limit);
toolbar->addWidget(new toSpacer());
new toChangeConnection(toolbar, TO_TOOLBAR_WIDGET_NAME);
QSplitter *splitter = new QSplitter(Qt::Vertical, this);
layout()->addWidget(splitter);
Trace = new toResultTableView(false, false, splitter);
QList<int> list;
list.append(75);
splitter->setSizes(list);
Trace->setReadAll(true);
Statement = new toSGAStatement(splitter);
connect(Trace, SIGNAL(selectionChanged()),
this, SLOT(changeItem()));
CurrentSchema = connection.user().toUpper();
updateSchemas();
try
{
connect(timer(), SIGNAL(timeout(void)), this, SLOT(refresh(void)));
toRefreshParse(timer(), toConfigurationSingle::Instance().refresh());
}
TOCATCH;
setFocusProxy(Trace);
}
void TimeLine::initUI()
{
Q_ASSERT(editor() != nullptr);
setWindowTitle(tr("Timeline"));
QWidget* timeLineContent = new QWidget(this);
mLayerList = new TimeLineCells(this, editor(), TIMELINE_CELL_TYPE::Layers);
mTracks = new TimeLineCells(this, editor(), TIMELINE_CELL_TYPE::Tracks);
mHScrollbar = new QScrollBar(Qt::Horizontal);
mVScrollbar = new QScrollBar(Qt::Vertical);
mVScrollbar->setMinimum(0);
mVScrollbar->setMaximum(1);
mVScrollbar->setPageStep(1);
QWidget* leftWidget = new QWidget();
leftWidget->setMinimumWidth(120);
QWidget* rightWidget = new QWidget();
QWidget* leftToolBar = new QWidget();
leftToolBar->setFixedHeight(30);
QWidget* rightToolBar = new QWidget();
rightToolBar->setFixedHeight(30);
// --- left widget ---
// --------- layer buttons ---------
QToolBar* layerButtons = new QToolBar(this);
QLabel* layerLabel = new QLabel(tr("Layers:"));
layerLabel->setIndent(5);
QToolButton* addLayerButton = new QToolButton(this);
addLayerButton->setIcon(QIcon(":icons/add.png"));
addLayerButton->setToolTip(tr("Add Layer"));
addLayerButton->setFixedSize(24, 24);
QToolButton* removeLayerButton = new QToolButton(this);
removeLayerButton->setIcon(QIcon(":icons/remove.png"));
removeLayerButton->setToolTip(tr("Remove Layer"));
removeLayerButton->setFixedSize(24, 24);
layerButtons->addWidget(layerLabel);
layerButtons->addWidget(addLayerButton);
layerButtons->addWidget(removeLayerButton);
layerButtons->setFixedHeight(30);
QHBoxLayout* leftToolBarLayout = new QHBoxLayout();
leftToolBarLayout->setMargin(0);
leftToolBarLayout->addWidget(layerButtons);
leftToolBar->setLayout(leftToolBarLayout);
QAction* newBitmapLayerAct = new QAction(QIcon(":icons/layer-bitmap.png"), tr("New Bitmap Layer"), this);
QAction* newVectorLayerAct = new QAction(QIcon(":icons/layer-vector.png"), tr("New Vector Layer"), this);
QAction* newSoundLayerAct = new QAction(QIcon(":icons/layer-sound.png"), tr("New Sound Layer"), this);
QAction* newCameraLayerAct = new QAction(QIcon(":icons/layer-camera.png"), tr("New Camera Layer"), this);
QMenu* layerMenu = new QMenu(tr("&Layer", "Timeline add-layer menu"), this);
layerMenu->addAction(newBitmapLayerAct);
layerMenu->addAction(newVectorLayerAct);
layerMenu->addAction(newSoundLayerAct);
layerMenu->addAction(newCameraLayerAct);
addLayerButton->setMenu(layerMenu);
addLayerButton->setPopupMode(QToolButton::InstantPopup);
QGridLayout* leftLayout = new QGridLayout();
leftLayout->addWidget(leftToolBar, 0, 0);
leftLayout->addWidget(mLayerList, 1, 0);
leftLayout->setMargin(0);
leftLayout->setSpacing(0);
leftWidget->setLayout(leftLayout);
// --- right widget ---
// --------- key buttons ---------
QToolBar* timelineButtons = new QToolBar(this);
QLabel* keyLabel = new QLabel(tr("Keys:"));
keyLabel->setIndent(5);
QToolButton* addKeyButton = new QToolButton(this);
addKeyButton->setIcon(QIcon(":icons/add.png"));
addKeyButton->setToolTip(tr("Add Frame"));
addKeyButton->setFixedSize(24, 24);
QToolButton* removeKeyButton = new QToolButton(this);
removeKeyButton->setIcon(QIcon(":icons/remove.png"));
removeKeyButton->setToolTip(tr("Remove Frame"));
removeKeyButton->setFixedSize(24, 24);
QToolButton* duplicateKeyButton = new QToolButton(this);
duplicateKeyButton->setIcon(QIcon(":icons/controls/duplicate.png"));
duplicateKeyButton->setToolTip(tr("Duplicate Frame"));
duplicateKeyButton->setFixedSize(24, 24);
QLabel* zoomLabel = new QLabel(tr("Zoom:"));
zoomLabel->setIndent(5);
QSlider* zoomSlider = new QSlider(this);
zoomSlider->setRange(4, 40);
zoomSlider->setFixedWidth(74);
zoomSlider->setValue(mTracks->getFrameSize());
zoomSlider->setToolTip(tr("Adjust frame width"));
zoomSlider->setOrientation(Qt::Horizontal);
QLabel* onionLabel = new QLabel(tr("Onion skin:"));
QToolButton* onionTypeButton = new QToolButton(this);
onionTypeButton->setIcon(QIcon(":icons/onion_type.png"));
onionTypeButton->setToolTip(tr("Toggle match keyframes"));
onionTypeButton->setFixedSize(24, 24);
timelineButtons->addWidget(keyLabel);
timelineButtons->addWidget(addKeyButton);
timelineButtons->addWidget(removeKeyButton);
timelineButtons->addWidget(duplicateKeyButton);
timelineButtons->addSeparator();
timelineButtons->addWidget(zoomLabel);
timelineButtons->addWidget(zoomSlider);
timelineButtons->addSeparator();
timelineButtons->addWidget(onionLabel);
timelineButtons->addWidget(onionTypeButton);
timelineButtons->addSeparator();
timelineButtons->setFixedHeight(30);
// --------- Time controls ---------
mTimeControls = new TimeControls(this);
mTimeControls->setEditor(editor());
mTimeControls->initUI();
mTimeControls->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
updateLength();
QHBoxLayout* rightToolBarLayout = new QHBoxLayout();
rightToolBarLayout->addWidget(timelineButtons);
rightToolBarLayout->setAlignment(Qt::AlignLeft);
rightToolBarLayout->addWidget(mTimeControls);
rightToolBarLayout->setMargin(0);
rightToolBarLayout->setSpacing(0);
rightToolBar->setLayout(rightToolBarLayout);
QGridLayout* rightLayout = new QGridLayout();
rightLayout->addWidget(rightToolBar, 0, 0);
rightLayout->addWidget(mTracks, 1, 0);
rightLayout->setMargin(0);
rightLayout->setSpacing(0);
rightWidget->setLayout(rightLayout);
// --- Splitter ---
QSplitter* splitter = new QSplitter(this);
splitter->addWidget(leftWidget);
splitter->addWidget(rightWidget);
splitter->setSizes(QList<int>() << 100 << 600);
QGridLayout* lay = new QGridLayout();
lay->addWidget(splitter, 0, 0);
lay->addWidget(mVScrollbar, 0, 1);
lay->addWidget(mHScrollbar, 1, 0);
lay->setMargin(0);
lay->setSpacing(0);
timeLineContent->setLayout(lay);
setWidget(timeLineContent);
setWindowFlags(Qt::WindowStaysOnTopHint);
connect(mHScrollbar, &QScrollBar::valueChanged, mTracks, &TimeLineCells::hScrollChange);
connect(mTracks, &TimeLineCells::offsetChanged, mHScrollbar, &QScrollBar::setValue);
connect(mVScrollbar, &QScrollBar::valueChanged, mTracks, &TimeLineCells::vScrollChange);
connect(mVScrollbar, &QScrollBar::valueChanged, mLayerList, &TimeLineCells::vScrollChange);
connect(splitter, &QSplitter::splitterMoved, this, &TimeLine::updateLength);
connect(addKeyButton, &QToolButton::clicked, this, &TimeLine::addKeyClick);
connect(removeKeyButton, &QToolButton::clicked, this, &TimeLine::removeKeyClick);
connect(duplicateKeyButton, &QToolButton::clicked, this, &TimeLine::duplicateKeyClick);
connect(zoomSlider, &QSlider::valueChanged, mTracks, &TimeLineCells::setFrameSize);
connect(onionTypeButton, &QToolButton::clicked, this, &TimeLine::toogleAbsoluteOnionClick);
connect(mTimeControls, &TimeControls::soundToggled, this, &TimeLine::soundClick);
connect(mTimeControls, &TimeControls::fpsChanged, this, &TimeLine::fpsChanged);
connect(mTimeControls, &TimeControls::fpsChanged, this, &TimeLine::updateLength);
connect(mTimeControls, &TimeControls::playButtonTriggered, this, &TimeLine::playButtonTriggered);
connect(newBitmapLayerAct, &QAction::triggered, this, &TimeLine::newBitmapLayer);
connect(newVectorLayerAct, &QAction::triggered, this, &TimeLine::newVectorLayer);
connect(newSoundLayerAct, &QAction::triggered, this, &TimeLine::newSoundLayer);
connect(newCameraLayerAct, &QAction::triggered, this, &TimeLine::newCameraLayer);
connect(removeLayerButton, &QPushButton::clicked, this, &TimeLine::deleteCurrentLayer);
connect(mLayerList, &TimeLineCells::mouseMovedY, mLayerList, &TimeLineCells::setMouseMoveY);
connect(mLayerList, &TimeLineCells::mouseMovedY, mTracks, &TimeLineCells::setMouseMoveY);
connect(mTracks, &TimeLineCells::lengthChanged, this, &TimeLine::updateLength);
connect(editor(), &Editor::currentFrameChanged, this, &TimeLine::updateFrame);
LayerManager* layer = editor()->layers();
connect(layer, &LayerManager::layerCountChanged, this, &TimeLine::updateLayerNumber);
scrubbing = false;
}
CShaderEditor::CShaderEditor( CApplication& app, CAssetShader& shader ) :
QDockWidget( "Shader Editor", &app.GetMainFrame() ),
m_IconTable( (const char** ) ShaderEditor_xpm )
{
setAttribute(Qt::WA_DeleteOnClose);
UInt32 border = 4;
m_App = &app;
m_Shader = NULL;
m_Frame = new QWidget( this );
QAction* action = NULL;
QToolBar* toolBar = new QToolBar( m_Frame );
action = toolBar->addAction( m_IconTable.GetIcon( 0 ), "Open" );
connect( action, SIGNAL( triggered() ), this, SLOT( OnUIOpen() ) );
action = toolBar->addAction( m_IconTable.GetIcon( 1 ), "Save" );
connect( action, SIGNAL( triggered() ), this, SLOT( OnUISave() ) );
toolBar->addSeparator();
action = toolBar->addAction( m_IconTable.GetIcon( 2 ), "Undo" );
connect( action, SIGNAL( triggered() ), this, SLOT( OnUIUndo() ) );
action = toolBar->addAction( m_IconTable.GetIcon( 3 ), "Redo" );
connect( action, SIGNAL( triggered() ), this, SLOT( OnUIRedo() ) );
toolBar->addSeparator();
action = toolBar->addAction( m_IconTable.GetIcon( 4 ), "Compile" );
connect( action, SIGNAL( triggered() ), this, SLOT( OnUICompile() ) );
m_TextEdit[nShaderProgramType_Vertex] = new QTextEdit( m_Frame);
m_TextEdit[nShaderProgramType_Vertex]->setUndoRedoEnabled( TRUE );
m_TextEdit[nShaderProgramType_Vertex]->setTabStopWidth( QFontMetrics( m_TextEdit[nShaderProgramType_Vertex]->currentFont( ) ).width(' ') * 4 );
CShaderEditorSyntaxHighlighter* highlighterVertex = new CShaderEditorSyntaxHighlighter(m_TextEdit[nShaderProgramType_Vertex]->document());
m_TextEdit[nShaderProgramType_Pixel] = new QTextEdit( m_Frame);
m_TextEdit[nShaderProgramType_Pixel]->setUndoRedoEnabled( TRUE );
m_TextEdit[nShaderProgramType_Pixel]->setTabStopWidth( QFontMetrics( m_TextEdit[nShaderProgramType_Pixel]->currentFont( ) ).width(' ') * 4 );
CShaderEditorSyntaxHighlighter* highlighterPixel = new CShaderEditorSyntaxHighlighter(m_TextEdit[nShaderProgramType_Pixel]->document());
m_TextEdit[nShaderProgramType_Geometry] = new QTextEdit( m_Frame);
m_TextEdit[nShaderProgramType_Geometry]->setUndoRedoEnabled( TRUE );
m_TextEdit[nShaderProgramType_Geometry]->setTabStopWidth( QFontMetrics( m_TextEdit[nShaderProgramType_Geometry]->currentFont( ) ).width(' ') * 4 );
CShaderEditorSyntaxHighlighter* highlighterGeometry = new CShaderEditorSyntaxHighlighter(m_TextEdit[nShaderProgramType_Geometry]->document());
m_TabWidget = new QTabWidget( m_Frame );
m_TabWidget->addTab( m_TextEdit[nShaderProgramType_Vertex], "Vertex Program" );
m_TabWidget->addTab( m_TextEdit[nShaderProgramType_Pixel], "Pixel Program" );
m_TabWidget->addTab( m_TextEdit[nShaderProgramType_Geometry], "Geometry Program" );
m_CurrentProgramEdited = nShaderProgramType_Vertex;
connect( m_TabWidget, SIGNAL( currentChanged( int ) ), this, SLOT( OnUITabChanged( int ) ) );
m_LogWindow = new QListWidget( m_Frame );
m_LogWindow->setVerticalScrollMode( QAbstractItemView::ScrollPerPixel );
connect( m_LogWindow, SIGNAL( itemDoubleClicked ( QListWidgetItem*) ), this, SLOT( OnUISelectError( QListWidgetItem* ) ) );
QSplitter* splitter = new QSplitter( Qt::Vertical, m_Frame );
splitter->addWidget( m_TabWidget );
splitter->addWidget( m_LogWindow );
splitter->setStretchFactor( 0, 4 );
splitter->setStretchFactor( 1, 1 );
QVBoxLayout *layout = new QVBoxLayout( m_Frame );
layout->addWidget( toolBar );
layout->addWidget( splitter );
layout->setContentsMargins( 0, 0, 0, 0 );
m_Frame->setLayout( layout ); // use the sizer for layout
setWidget( m_Frame );
resize( QSize( 800, 600 ) );
SetShader( shader );
}
PQTextEditor::PQTextEditor(QWidget* parent):
QMainWindow(parent)
{
QWidget *centralWidget = new QWidget(this);
mLayout = new QGridLayout(centralWidget);
centralWidget->setLayout(mLayout);
setCentralWidget(centralWidget);
mEditor = new QTextEdit(this);
mLayout->addWidget(mEditor, 0, 0);
connect(mEditor, SIGNAL(textChanged()), SIGNAL(textChanged()));
QAction *action;
QToolBar *toolbar = addToolBar(tr("Edit Toolbar"));
addAction(toolbar, QLatin1String("undo"), QLatin1String("edit-undo"), tr("Undo"), false, QKeySequence::Undo, mEditor, SLOT(undo()));
addAction(toolbar, QLatin1String("redo"), QLatin1String("edit-redo"), tr("Redo"), false, QKeySequence::Redo, mEditor, SLOT(redo()));
addAction(toolbar, QLatin1String("cut"), QLatin1String("edit-cut"), tr("Cut"), false,QKeySequence::Cut, mEditor, SLOT(cut()));
addAction(toolbar, QLatin1String("copy"), QLatin1String("edit-copy"), tr("Copy"), false,QKeySequence::Copy, mEditor, SLOT(copy()));
addAction(toolbar, QLatin1String("paste"), QLatin1String("edit-paste"), tr("Paste"), false,QKeySequence::Paste, mEditor, SLOT(paste()));
toolbar = addToolBar(tr("Format Toolbar"));
addAction(toolbar, QLatin1String("bold"), QLatin1String("format-text-bold"), tr("Bold"), true, QKeySequence::Bold, this, SLOT(slotToggleBold()));
addAction(toolbar, QLatin1String("italic"), QLatin1String("format-text-italic"), tr("Italic"), true, QKeySequence::Italic, this, SLOT(slotToggleItalic()));
addAction(toolbar, QLatin1String("strikethrough"), QLatin1String("format-text-strikethrough"), tr("Strikethrough"), true, QKeySequence(), this, SLOT(slotToggleStrikethrough()));
addAction(toolbar, QLatin1String("underline"), QLatin1String("format-text-underline"), tr("Underline"), true, QKeySequence::Underline, this, SLOT(slotToggleUnderline()));
toolbar->addSeparator();
QActionGroup *group = new QActionGroup(this);
group->addAction(addAction(toolbar, QLatin1String("justify-left"), QLatin1String("format-justify-left"), tr("Justify Left"), true, QKeySequence(), this, SLOT(slotJustifyLeft())));
group->addAction(addAction(toolbar, QLatin1String("justify-center"), QLatin1String("format-justify-center"), tr("Justify Center"), true, QKeySequence(), this, SLOT(slotJustifyCenter())));
group->addAction(addAction(toolbar, QLatin1String("justify-fill"), QLatin1String("format-justify-fill"), tr("Justify Fill"), true, QKeySequence(), this, SLOT(slotJustifyFill())));
group->addAction(addAction(toolbar, QLatin1String("justify-right"), QLatin1String("format-justify-right"), tr("Justify Right"), true, QKeySequence(), this, SLOT(slotJustifyRight())));
toolbar->addSeparator();
addAction(toolbar, QLatin1String("unindent"), QLatin1String("format-indent-less"), tr("Unindent"), false, QKeySequence(), this, SLOT(slotUnindent()));
addAction(toolbar, QLatin1String("indent"), QLatin1String("format-indent-more"), tr("Indent"), false, QKeySequence(), this, SLOT(slotIndent()));
mStyleComboBox = new QComboBox(this);
mStyleComboBox->addItem(tr("Standard"));
mStyleComboBox->addItem(tr("Bullet List (Disc)"));
mStyleComboBox->addItem(tr("Bullet List (Circle)"));
mStyleComboBox->addItem(tr("Bullet List (Square)"));
mStyleComboBox->addItem(tr("Ordered List (Decimal)"));
mStyleComboBox->addItem(tr("Ordered List (Alpha lower)"));
mStyleComboBox->addItem(tr("Ordered List (Alpha upper)"));
mStyleComboBox->addItem(tr("Ordered List (Roman lower)"));
mStyleComboBox->addItem(tr("Ordered List (Roman upper)"));
connect(mStyleComboBox, SIGNAL(currentIndexChanged(int)), SLOT(slotChangeStyle(int)));
mFontComboBox = new QFontComboBox(this);
connect(mFontComboBox, SIGNAL(currentFontChanged(QFont)), SLOT(slotChangeFont(QFont)));
mFontSizeComboBox = new QComboBox(this);
QFontDatabase db;
Q_FOREACH (int size, db.standardSizes()) {
mFontSizeComboBox->addItem(QString::number(size));
}
/* Initialize */
mFontSizeComboBox->setCurrentIndex(mFontSizeComboBox->findText(QString::number(QApplication::font().pointSize())));
connect(mFontSizeComboBox, SIGNAL(currentIndexChanged(int)), SLOT(slotChangeFontSize(int)));
QPixmap pixmap(16, 16);
pixmap.fill(mEditor->textColor());
QAction *colorAction = new QAction(pixmap, tr("Color"), this);
connect(colorAction, SIGNAL(triggered(bool)), SLOT(slotChangeColor()));
addToolBarBreak();
toolbar = addToolBar(tr("Font Toolbar"));
toolbar->addWidget(mStyleComboBox);
toolbar->addWidget(mFontComboBox);
toolbar->addWidget(mFontSizeComboBox);
toolbar->addAction(colorAction);
}
void Mainframe::show()
{
// prevent multiple inserting of menu entries, by calls of showFullScreen(), ...
if (preferences_action_ != 0)
{
MainControl::show();
return;
}
QToolBar* tb = NULL;
if (UIOperationMode::instance().getMode() <= UIOperationMode::MODE_ADVANCED)
{
tb = new QToolBar("Main Toolbar", this);
tb->setObjectName("Main Toolbar");
tb->setIconSize(QSize(22,22));
addToolBar(Qt::TopToolBarArea, tb);
}
MainControl::show();
QMenu *menu = initPopupMenu(MainControl::WINDOWS, UIOperationMode::MODE_ADVANCED);
if (menu)
{
menu->addSeparator();
menu->addAction(tb->toggleViewAction());
}
// NOTE: this *has* to be run... a null pointer is unproblematic
if (UIOperationMode::instance().getMode() <= UIOperationMode::MODE_ADVANCED)
{
MolecularFileDialog::getInstance(0)->addToolBarEntries(tb);
DownloadPDBFile::getInstance(0)->addToolBarEntries(tb);
DownloadElectronDensity::getInstance(0)->addToolBarEntries(tb);
PubChemDialog::getInstance(0)->addToolBarEntries(tb);
UndoManagerDialog::getInstance(0)->addToolBarEntries(tb);
tb->addAction(fullscreen_action_);
Path path;
IconLoader& loader = IconLoader::instance();
qload_action_ = new QAction(loader.getIcon("actions/quickopen-file"), tr("quickload"), this);
qload_action_->setObjectName("quickload");
connect(qload_action_, SIGNAL(triggered()), this, SLOT(quickLoadConfirm()));
HelpViewer::getInstance("BALLView Docu")->registerForHelpSystem(qload_action_, "tips.html#quickload");
tb->addAction(qload_action_);
qsave_action_ = new QAction(loader.getIcon("actions/quicksave"), tr("quicksave"), this);
qsave_action_->setObjectName("quicksave");
connect(qsave_action_, SIGNAL(triggered()), this, SLOT(quickSave()));
HelpViewer::getInstance("BALLView Docu")->registerForHelpSystem(qsave_action_, "tips.html#quickload");
tb->addAction(qsave_action_);
tb->addSeparator();
DisplayProperties::getInstance(0)->addToolBarEntries(tb);
MolecularStructure::getInstance(0)->addToolBarEntries(tb);
}
scene_->addToolBarEntries(tb);
if (UIOperationMode::instance().getMode() <= UIOperationMode::MODE_ADVANCED)
{
tb->addAction(stop_simulation_action_);
tb->addAction(preferences_action_);
HelpViewer::getInstance("BALLView Docu")->addToolBarEntries(tb);
}
// we have changed the child widgets stored in the maincontrol (e.g. toolbars), so we have
// to restore the window state again!
restoreWindows();
}
void QucsHelp::setupActions()
{
QToolBar *toolbar = new QToolBar("main_toolbar",this);
this->addToolBar(toolbar);
const QKeySequence ks = QKeySequence();
QAction *quitAction = new QAction(QIcon((":/bitmaps/quit.png")),
tr("&Quit"), this);
quitAction->setShortcut((const QKeySequence&)Qt::CTRL+Qt::Key_Q);
QAction *backAction = new QAction(QIcon((":/bitmaps/back.png")),
tr("&Back"), this);
backAction->setShortcut( Qt::ALT+Qt::Key_Left);
QAction *forwardAction = new QAction(QIcon((":/bitmaps/forward.png")),
tr("&Forward"), this);
forwardAction->setShortcut(Qt::ALT+Qt::Key_Right);
QAction *homeAction = new QAction(QIcon((":/bitmaps/home.png")),
tr("&Home"),this);
homeAction->setShortcut(Qt::CTRL+Qt::Key_H);
previousAction = new QAction(QIcon((":/bitmaps/previous.png")),tr("&Previous"),
this);
previousAction->setShortcut( ks);
nextAction = new QAction(QIcon((":/bitmaps/next.png")),
tr("&Next"), this);
nextAction->setShortcut( ks);
viewBrowseDock = new QAction(tr("&Table of Contents"), this);
viewBrowseDock->setCheckable(true);
viewBrowseDock->setChecked(true);
viewBrowseDock->setStatusTip(tr("Enables/disables the table of contents"));
viewBrowseDock->setWhatsThis(tr("Table of Contents\n\nEnables/disables the table of contents"));
connect(quitAction,SIGNAL(activated()),qApp,SLOT(quit()));
connect(backAction,SIGNAL(activated()),textBrowser,SLOT(backward()));
connect(textBrowser,SIGNAL(backwardAvailable(bool)),backAction,SLOT(setEnabled(bool)));
connect(forwardAction,SIGNAL(activated()),textBrowser,SLOT(forward()));
connect(textBrowser,SIGNAL(forwardAvailable(bool)),forwardAction,SLOT(setEnabled(bool)));
connect(homeAction,SIGNAL(activated()),textBrowser,SLOT(home()));
connect(homeAction,SIGNAL(activated()),this,SLOT(gohome()));
connect(textBrowser,SIGNAL(sourceChanged(const QUrl &)),this,SLOT(slotSourceChanged(const QUrl &)));
connect(previousAction,SIGNAL(activated()),this,SLOT(previousLink()));
connect(nextAction,SIGNAL(activated()),this,SLOT(nextLink()));
connect(viewBrowseDock, SIGNAL(toggled(bool)), SLOT(slotToggleSidebar(bool)));
toolbar->addAction(backAction);
toolbar->addAction(forwardAction);
toolbar->addSeparator();
toolbar->addAction(homeAction);
toolbar->addAction(previousAction);
toolbar->addAction(nextAction);
toolbar->addSeparator();
toolbar->addAction(quitAction);
QMenu *fileMenu = menuBar()->addMenu(tr("&File"));
fileMenu->addAction(quitAction);
fileMenu->addAction(quitAction);
QMenu *viewMenu = menuBar()->addMenu(tr("&View"));
viewMenu->addAction(backAction);
viewMenu->addAction(forwardAction);
viewMenu->addAction(homeAction);
viewMenu->addAction(previousAction);
viewMenu->addAction(nextAction);
viewMenu->addSeparator();
viewMenu->addAction(viewBrowseDock);
QMenu *helpMenu = menuBar()->addMenu(tr("&Help"));
helpMenu->addAction(tr("&About Qt"),qApp,SLOT(aboutQt()));
}
void FileMainWindow::setup()
{
QSplitter *splitter = new QSplitter( this );
dirlist = new DirectoryView( splitter, "dirlist", TRUE );
dirlist->addColumn( "Name" );
dirlist->addColumn( "Type" );
Directory *root = new Directory( dirlist, "/" );
root->setOpen( TRUE );
splitter->setResizeMode( dirlist, QSplitter::KeepSize );
fileview = new QtFileIconView( "/", splitter );
fileview->setSelectionMode( QIconView::Extended );
setCentralWidget( splitter );
QToolBar *toolbar = new QToolBar( this, "toolbar" );
setRightJustification( TRUE );
(void)new QLabel( tr( " Path: " ), toolbar );
pathCombo = new QComboBox( TRUE, toolbar );
pathCombo->setAutoCompletion( TRUE );
toolbar->setStretchableWidget( pathCombo );
connect( pathCombo, SIGNAL( activated( const QString & ) ),
this, SLOT ( changePath( const QString & ) ) );
toolbar->addSeparator();
QPixmap pix;
pix = QPixmap( cdtoparent_xpm );
upButton = new QToolButton( pix, "One directory up", QString::null,
this, SLOT( cdUp() ), toolbar, "cd up" );
pix = QPixmap( newfolder_xpm );
mkdirButton = new QToolButton( pix, "New Folder", QString::null,
this, SLOT( newFolder() ), toolbar, "new folder" );
connect( dirlist, SIGNAL( folderSelected( const QString & ) ),
fileview, SLOT ( setDirectory( const QString & ) ) );
connect( fileview, SIGNAL( directoryChanged( const QString & ) ),
this, SLOT( directoryChanged( const QString & ) ) );
connect( fileview, SIGNAL( startReadDir( int ) ),
this, SLOT( slotStartReadDir( int ) ) );
connect( fileview, SIGNAL( readNextDir() ),
this, SLOT( slotReadNextDir() ) );
connect( fileview, SIGNAL( readDirDone() ),
this, SLOT( slotReadDirDone() ) );
setDockEnabled( DockLeft, FALSE );
setDockEnabled( DockRight, FALSE );
label = new QLabel( statusBar() );
statusBar()->addWidget( label, 2, TRUE );
progress = new QProgressBar( statusBar() );
statusBar()->addWidget( progress, 1, TRUE );
connect( fileview, SIGNAL( enableUp() ),
this, SLOT( enableUp() ) );
connect( fileview, SIGNAL( disableUp() ),
this, SLOT( disableUp() ) );
connect( fileview, SIGNAL( enableMkdir() ),
this, SLOT( enableMkdir() ) );
connect( fileview, SIGNAL( disableMkdir() ),
this, SLOT( disableMkdir() ) );
}
toPLSQLEditor::toPLSQLEditor(QWidget *main, toConnection &connection)
: toToolWidget(PLSQLEditorTool, "plsqleditor.html", main, connection, "toPLSQLEditor")
{
createActions();
QToolBar *toolbar = toAllocBar(this, tr("PLSQLEditor"));
layout()->addWidget(toolbar);
toolbar->addAction(refreshAct);
toolbar->addSeparator();
Schema = new QComboBox(toolbar);
Schema->setObjectName("PLSQLEditorSchemaCombo");
toolbar->addWidget(Schema);
connect(Schema,
SIGNAL(activated(int)),
this,
SLOT(changeSchema(int)));
toolbar->addSeparator();
toolbar->addAction(newSheetAct);
toolbar->addAction(compileAct);
toolbar->addAction(compileWarnAct);
// only show static check button when static checker is specified
if (!toConfigurationSingle::Instance().staticChecker().isEmpty())
{
toolbar->addAction(checkCodeAct);
}
toolbar->addSeparator();
toolbar->addAction(nextErrorAct);
toolbar->addAction(previousErrorAct);
toolbar->addAction(describeAct);
toolbar->addWidget(new toSpacer());
splitter = new QSplitter(Qt::Horizontal, this);
layout()->addWidget(splitter);
Objects = new QTreeView(splitter);
CodeModel = new toCodeModel(Objects);
Objects->setModel(CodeModel);
QString selected = Schema->currentText();
if (!selected.isEmpty())
CodeModel->refresh(connection, selected);
// even better (?) for reopening the tabs
// connect(Objects->selectionModel(),
// SIGNAL(currentChanged(const QModelIndex &, const QModelIndex &)),
// this,
// SLOT(changePackage(const QModelIndex &, const QModelIndex &)));
connect(Objects, SIGNAL(doubleClicked(const QModelIndex &)),
this, SLOT(changePackage(const QModelIndex &)));
splitter->addWidget(Objects);
Editors = new QTabWidget(this);
#if QT_VERSION >= 0x040500
Editors->setTabsClosable(true);
connect(Editors, SIGNAL(tabCloseRequested(int)),
this, SLOT(closeEditor(int)));
#endif
splitter->addWidget(Editors);
Editors->setTabPosition(QTabWidget::North);
QToolButton *closeButton = new toPopupButton(Editors);
closeButton->setIcon(QPixmap(const_cast<const char**>(close_xpm)));
closeButton->setFixedSize(20, 18);
// HACK: disable closing the editor tabs with the global shortcut.
// it raises: "QAction::eventFilter: Ambiguous shortcut overload: Ctrl+W"
// on some systems. But it rejects to close unfinished.unsaved work.
// - <*****@*****.**>
closeButton->setShortcut(QKeySequence::Close);
connect(closeButton, SIGNAL(clicked()), this, SLOT(closeEditor()));
Editors->setCornerWidget(closeButton);
setFocusProxy(Editors);
newSheet();
ToolMenu = NULL;
connect(toMainWidget()->workspace(), SIGNAL(subWindowActivated(QMdiSubWindow *)),
this, SLOT(windowActivated(QMdiSubWindow *)));
QSettings s;
s.beginGroup("toPLSQLEditor");
splitter->restoreState(s.value("splitter").toByteArray());
s.endGroup();
conn = &connection;
refresh();
}
MainWindow::MainWindow( QWidget *parent ):
QMainWindow( parent )
{
d_plot = new Plot( this );
const int margin = 5;
d_plot->setContentsMargins( margin, margin, margin, 0 );
setContextMenuPolicy( Qt::NoContextMenu );
d_zoomer[0] = new Zoomer( QwtPlot::xBottom, QwtPlot::yLeft,
d_plot->canvas() );
d_zoomer[0]->setRubberBand( QwtPicker::RectRubberBand );
d_zoomer[0]->setRubberBandPen( QColor( Qt::green ) );
d_zoomer[0]->setTrackerMode( QwtPicker::ActiveOnly );
d_zoomer[0]->setTrackerPen( QColor( Qt::white ) );
d_zoomer[1] = new Zoomer( QwtPlot::xTop, QwtPlot::yRight,
d_plot->canvas() );
d_panner = new QwtPlotPanner( d_plot->canvas() );
d_panner->setMouseButton( Qt::MidButton );
d_picker = new QwtPlotPicker( QwtPlot::xBottom, QwtPlot::yLeft,
QwtPlotPicker::CrossRubberBand, QwtPicker::AlwaysOn,
d_plot->canvas() );
d_picker->setStateMachine( new QwtPickerDragPointMachine() );
d_picker->setRubberBandPen( QColor( Qt::green ) );
d_picker->setRubberBand( QwtPicker::CrossRubberBand );
d_picker->setTrackerPen( QColor( Qt::white ) );
setCentralWidget( d_plot );
QToolBar *toolBar = new QToolBar( this );
QToolButton *btnZoom = new QToolButton( toolBar );
btnZoom->setText( "Zoom" );
btnZoom->setIcon( QPixmap( zoom_xpm ) );
btnZoom->setCheckable( true );
btnZoom->setToolButtonStyle( Qt::ToolButtonTextUnderIcon );
toolBar->addWidget( btnZoom );
connect( btnZoom, SIGNAL( toggled( bool ) ), SLOT( enableZoomMode( bool ) ) );
#ifndef QT_NO_PRINTER
QToolButton *btnPrint = new QToolButton( toolBar );
btnPrint->setText( "Print" );
btnPrint->setIcon( QPixmap( print_xpm ) );
btnPrint->setToolButtonStyle( Qt::ToolButtonTextUnderIcon );
toolBar->addWidget( btnPrint );
connect( btnPrint, SIGNAL( clicked() ), SLOT( print() ) );
#endif
QToolButton *btnExport = new QToolButton( toolBar );
btnExport->setText( "Export" );
btnExport->setIcon( QPixmap( print_xpm ) );
btnExport->setToolButtonStyle( Qt::ToolButtonTextUnderIcon );
toolBar->addWidget( btnExport );
connect( btnExport, SIGNAL( clicked() ), SLOT( exportDocument() ) );
toolBar->addSeparator();
QWidget *hBox = new QWidget( toolBar );
QHBoxLayout *layout = new QHBoxLayout( hBox );
layout->setSpacing( 0 );
layout->addWidget( new QWidget( hBox ), 10 ); // spacer
layout->addWidget( new QLabel( "Damping Factor", hBox ), 0 );
layout->addSpacing( 10 );
QwtCounter *cntDamp = new QwtCounter( hBox );
cntDamp->setRange( 0.0, 5.0, 0.01 );
cntDamp->setValue( 0.0 );
layout->addWidget( cntDamp, 0 );
( void )toolBar->addWidget( hBox );
addToolBar( toolBar );
#ifndef QT_NO_STATUSBAR
( void )statusBar();
#endif
enableZoomMode( false );
showInfo();
connect( cntDamp, SIGNAL( valueChanged( double ) ),
d_plot, SLOT( setDamp( double ) ) );
connect( d_picker, SIGNAL( moved( const QPoint & ) ),
SLOT( moved( const QPoint & ) ) );
connect( d_picker, SIGNAL( selected( const QPolygon & ) ),
SLOT( selected( const QPolygon & ) ) );
}
RMainWnd::RMainWnd(reditor::REditor* edit) : QMainWindow(), medit(edit)
{
setWindowTitle(tr("Room Editor"));
setWindowIcon(QIcon(":/resources/favicon.ico"));
// central widget
meditWnd = new REditWnd(medit->objects(), medit->camera(), this);
setCentralWidget(meditWnd);
// set corners for docks
setCorner(Qt::TopRightCorner, Qt::RightDockWidgetArea);
setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea);
setCorner(Qt::TopLeftCorner, Qt::LeftDockWidgetArea);
setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea);
// docks
mloggerDock = new QDockWidget(this);
mloggerDock->setWindowTitle(tr("Editor Log"));
mlogger = new RLogger(mloggerDock);
mloggerDock->setWidget(mlogger);
addDockWidget(Qt::BottomDockWidgetArea, mloggerDock);
// TODO attach dock window with objects on the scene
// File menu
QMenu* fileMenu = menuBar()->addMenu(tr("&File"));
QAction* newAction = fileMenu->addAction(tr("&New Project"), this, SIGNAL(newProject()), QKeySequence::New);
newAction->setIcon(QIcon(":/resources/new.png"));
QAction* openAction = fileMenu->addAction(tr("&Open Project.."), this, SIGNAL(openProject()), QKeySequence::Open);
openAction->setIcon(QIcon(":/resources/open.png"));
fileMenu->addSeparator();
msaveAction = fileMenu->addAction(tr("&Save Project"), this, SIGNAL(saveProject()), QKeySequence::Save);
msaveAction->setIcon(QIcon(":/resources/save.png"));
msaveAsAction = fileMenu->addAction(tr("S&ave Project As..."), this, SIGNAL(saveProjectAs()), Qt::SHIFT + Qt::CTRL + Qt::Key_S);
msaveAsAction->setIcon(QIcon(":/resources/saveAs.png"));
enableSave(false); // activate after user makes some changes, no sense to save empty project
fileMenu->addSeparator();
fileMenu->addAction(tr("&Exit.."), this, SLOT(close()), QKeySequence::Quit);
// Help menu
QMenu* helpMenu = menuBar()->addMenu(tr("&Help"));
helpMenu->addAction(tr("&About RoomEdit"), this, SIGNAL(helpAbout()));
// File toolbar
QToolBar* fileToolBar = addToolBar(tr("File"));
fileToolBar->addAction(newAction);
fileToolBar->addAction(openAction);
fileToolBar->addSeparator();
fileToolBar->addAction(msaveAction);
fileToolBar->addAction(msaveAsAction);
// Camera view toolbar
QToolBar* cameraToolBar = addToolBar(tr("Camera"));
mcameraGroup = new QButtonGroup(cameraToolBar);
QPushButton * cam1 = new QPushButton(QString("1"), this);
QPushButton * cam2 = new QPushButton(QString("2"), this);
QPushButton * cam3 = new QPushButton(QString("3"), this);
cam1->setCheckable(true);
cam2->setCheckable(true);
cam3->setCheckable(true);
cam1->setChecked(true);
mcameraGroup->addButton(cam1, 1);
mcameraGroup->addButton(cam2, 2);
mcameraGroup->addButton(cam3, 3);
mcameraGroup->setExclusive(true);
connect(mcameraGroup, SIGNAL(buttonClicked(int)), this, SIGNAL(switchCamera(int)));
cameraToolBar->addWidget(cam1);
cameraToolBar->addWidget(cam2);
cameraToolBar->addWidget(cam3);
}
toProfiler::toProfiler(QWidget *parent, toConnection &connection)
: toToolWidget(ProfilerTool, "toprofiler.html", parent, connection, "toProfiler")
{
QToolBar *toolbar = toAllocBar(this, tr("PL/SQL Profiler"));
layout()->addWidget(toolbar);
toolbar->addAction(QIcon(QPixmap(const_cast<const char**>(refresh_xpm))),
tr("Refresh list"),
this,
SLOT(refresh()));
toolbar->addSeparator();
toolbar->addWidget(
new QLabel(tr("Repeat run") + " ", toolbar));
Repeat = new QSpinBox(toolbar);
Repeat->setValue(5);
Repeat->setMaximum(1000);
toolbar->addWidget(Repeat);
toolbar->addSeparator();
toolbar->addWidget(new QLabel(tr("Comment") + " ", toolbar));
Comment = new QLineEdit(toolbar);
Comment->setText(tr("Unknown"));
toolbar->addWidget(Comment);
toolbar->addSeparator();
#if 0
Background = new QToolButton(toolbar);
Background->setToggleButton(true);
Background->setIconSet(QIcon(QPixmap(const_cast<const char**>(background_xpm))));
QToolTip::add
(Background, tr("Run profiling in background"));
toolbar->addSeparator();
#endif
toolbar->addAction(QIcon(QPixmap(const_cast<const char**>(execute_xpm))),
tr("Execute current profiling"),
this,
SLOT(execute()));
toolbar->addWidget(new toSpacer());
new toChangeConnection(toolbar, TO_TOOLBAR_WIDGET_NAME);
Tabs = new QTabWidget(this);
layout()->addWidget(Tabs);
Script = new toWorksheetWidget(Tabs, NULL, connection);
Tabs->addTab(Script, tr("Script"));
Result = new QSplitter(Tabs);
Tabs->addTab(Result, tr("Result"));
QWidget *box = new QWidget(Result);
QVBoxLayout *vbox = new QVBoxLayout;
vbox->setSpacing(0);
vbox->setContentsMargins(0, 0, 0, 0);
box->setLayout(vbox);
Run = new QComboBox(box);
vbox->addWidget(Run);
QSplitter *vsplit = new QSplitter(Qt::Vertical, box);
vbox->addWidget(vsplit);
Info = new toResultItem(2, vsplit);
Info->setSQL(SQLRunInfo);
connect(Run, SIGNAL(activated(int)), this, SLOT(changeRun()));
Units = new toProfilerUnits(vsplit);
Units->setReadAll(true);
Units->setSelectionMode(toTreeWidget::Single);
connect(Units, SIGNAL(selectionChanged()), this, SLOT(changeObject()));
Lines = new toProfilerSource(Result);
Lines->setReadAll(true);
connect(Lines, SIGNAL(done()), this, SLOT(calcTotals()));
LastUnit = CurrentRun = 0;
// show();
try
{
toQuery query(connection, SQLProfilerDetect);
}
catch (const QString &)
{
int ret = TOMessageBox::warning(this,
tr("Profiler tables doesn't exist"),
tr("Profiler tables doesn't exist. Should TOra\n"
"try to create them in the current schema?"),
tr("&Yes"), tr("&No"), QString::null, 0, 1);
if (ret == 0)
{
try
{
connection.execute(SQLProfilerRuns);
connection.execute(SQLProfilerUnits);
connection.execute(SQLProfilerData);
connection.execute(SQLProfilerNumber);
}
catch (const QString &str)
{
toStatusMessage(str);
QTimer::singleShot(1, this, SLOT(noTables()));
return ;
}
}
else
{
QTimer::singleShot(1, this, SLOT(noTables()));
return ;
}
}
refresh();
}
DrumrollEditor::DrumrollEditor(QWidget* parent)
: QMainWindow(parent)
{
setObjectName("Drumroll");
setWindowTitle(QString("MuseScore"));
// setIconSize(QSize(preferences.iconWidth, preferences.iconHeight));
QWidget* mainWidget = new QWidget;
QGridLayout* layout = new QGridLayout;
mainWidget->setLayout(layout);
layout->setSpacing(0);
QToolBar* tb = addToolBar(tr("Toolbar 1"));
tb->addAction(getAction("undo"));
tb->addAction(getAction("redo"));
tb->addSeparator();
#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("Toolbar 3"));
layout->addWidget(tb, 1, 0, 1, 2);
for (int i = 0; i < VOICES; ++i) {
QToolButton* b = new QToolButton(this);
b->setToolButtonStyle(Qt::ToolButtonTextOnly);
QPalette p(b->palette());
p.setColor(QPalette::Base, MScore::selectColor[i]);
b->setPalette(p);
QAction* a = getAction(voiceActions[i]);
b->setDefaultAction(a);
tb->addWidget(b);
}
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"), int(Note::ValueType::OFFSET_VAL));
veloType->addItem(tr("user"), int(Note::ValueType::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 DrumView;
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*)));
readSettings();
}
void Monitor::initToolBar()
{
QActionGroup* group;
QAction* action;
QToolBar* toolBar = new QToolBar(this);
/* Menu bar */
Q_ASSERT(layout() != NULL);
layout()->setMenuBar(toolBar);
/* Font */
toolBar->addAction(QIcon(":/fonts.png"), tr("Font"),
this, SLOT(slotChooseFont()));
toolBar->addSeparator();
/* Channel style */
group = new QActionGroup(this);
group->setExclusive(true);
action = toolBar->addAction(tr("DMX Channels"));
action->setToolTip(tr("Show absolute DMX channel numbers"));
action->setCheckable(true);
action->setData(DMXChannels);
connect(action, SIGNAL(triggered(bool)),
this, SLOT(slotChannelStyleTriggered()));
toolBar->addAction(action);
group->addAction(action);
if (channelStyle() == DMXChannels)
action->setChecked(true);
action = toolBar->addAction(tr("Relative Channels"));
action->setToolTip(tr("Show channel numbers relative to fixture"));
action->setCheckable(true);
action->setData(RelativeChannels);
connect(action, SIGNAL(triggered(bool)),
this, SLOT(slotChannelStyleTriggered()));
toolBar->addAction(action);
group->addAction(action);
if (channelStyle() == RelativeChannels)
action->setChecked(true);
toolBar->addSeparator();
/* Value display style */
group = new QActionGroup(this);
group->setExclusive(true);
action = toolBar->addAction(tr("DMX Values"));
action->setToolTip(tr("Show DMX values 0-255"));
action->setCheckable(true);
action->setData(DMXValues);
connect(action, SIGNAL(triggered(bool)),
this, SLOT(slotValueStyleTriggered()));
toolBar->addAction(action);
group->addAction(action);
action->setChecked(true);
if (valueStyle() == DMXValues)
action->setChecked(true);
action = toolBar->addAction(tr("Percent Values"));
action->setToolTip(tr("Show percentage values 0-100%"));
action->setCheckable(true);
action->setData(PercentageValues);
connect(action, SIGNAL(triggered(bool)),
this, SLOT(slotValueStyleTriggered()));
toolBar->addAction(action);
group->addAction(action);
if (valueStyle() == PercentageValues)
action->setChecked(true);
}
// id is an old ident in case of an import
ActivityDiagramWindow::ActivityDiagramWindow(const QString & s, BrowserActivityDiagram * b, int id)
: DiagramWindow(b, s), view(0) {
QToolBar * toolbar = new QToolBar(this, "activity operations");
addToolBar(toolbar, TR("Toolbar"), Top, TRUE);
add_edit_button(toolbar);
select =
new QToolButton(*selectButton, TR("Select"), QString::null,
this, SLOT(hit_select()), toolbar, "select");
select->setToggleButton(TRUE);
select->setOn(TRUE);
current_button = UmlSelect;
addPackage
= new QToolButton(*packageButton, TR("New Package"), QString::null,
this, SLOT(hit_package()), toolbar, "add package");
addPackage->setToggleButton(TRUE);
QWhatsThis::add(addPackage, addpackageText());
addFragment
= new QToolButton(*fragmentButton, TR("New Fragment"), QString::null,
this, SLOT(hit_fragment()), toolbar, "add fragment");
addFragment->setToggleButton(TRUE);
QWhatsThis::add(addFragment, addfragmentText());
addActivity =
new QToolButton(*activityButton, TR("New Activity"), QString::null,
this, SLOT(hit_activity()), toolbar, "add activity");
addActivity->setToggleButton(TRUE);
QWhatsThis::add(addActivity, addactivityText());
addInterruptibleActivityRegion =
new QToolButton(*interruptibleactivityregionButton,
TR("New Interruptible Activity Region"), QString::null,
this, SLOT(hit_interruptibleactivityregion()),
toolbar, "add interruptible activity region");
addInterruptibleActivityRegion->setToggleButton(TRUE);
QWhatsThis::add(addInterruptibleActivityRegion,
addinterruptibleactivityregionText());
addExpansionRegion =
new QToolButton(*expansionregionButton,
TR("New Expansion Region"), QString::null,
this, SLOT(hit_expansionregion()),
toolbar, "add expansion region");
addExpansionRegion->setToggleButton(TRUE);
QWhatsThis::add(addExpansionRegion,
addexpansionregionText());
addActivityPartition =
new QToolButton(*activitypartitionButton,
TR("New Activity Partition"), QString::null,
this, SLOT(hit_activitypartition()),
toolbar, "add activity partition");
addActivityPartition->setToggleButton(TRUE);
QWhatsThis::add(addActivityPartition,
addactivitypartitionText());
addAction =
new QToolButton(*activityactionButton, TR("New Action"), QString::null,
this, SLOT(hit_action()), toolbar, "add action");
addAction->setToggleButton(TRUE);
QWhatsThis::add(addAction, addactionText());
addObject =
new QToolButton(*actionButton, TR("New Object Node"), QString::null,
this, SLOT(hit_object()), toolbar, "add object node");
addObject->setToggleButton(TRUE);
QWhatsThis::add(addObject, addobjectText());
addInitial =
new QToolButton(*initialButton, TR("New Initial node"), QString::null,
this, SLOT(hit_initial()), toolbar, "add initial");
addInitial->setToggleButton(TRUE);
QWhatsThis::add(addInitial, addinitialText());
addActivityFinal =
new QToolButton(*finalButton, TR("New Activity Final"), QString::null,
this, SLOT(hit_activityfinal()), toolbar, "add activity final");
addActivityFinal->setToggleButton(TRUE);
QWhatsThis::add(addActivityFinal, addactivityfinalText());
addFlowFinal =
new QToolButton(*exitpointButton, TR("New Flow Final"), QString::null,
this, SLOT(hit_flowfinal()), toolbar, "add flow final");
addFlowFinal->setToggleButton(TRUE);
QWhatsThis::add(addFlowFinal, addflowfinalText());
addMerge =
new QToolButton(*mergeButton, TR("New Merge"), QString::null,
this, SLOT(hit_merge()), toolbar, "add merge");
addMerge->setToggleButton(TRUE);
QWhatsThis::add(addMerge, addmergeText());
addDecision =
new QToolButton(*decisionButton, TR("New Decision"), QString::null,
this, SLOT(hit_decision()), toolbar, "add decision");
addDecision->setToggleButton(TRUE);
QWhatsThis::add(addDecision, adddecisionText());
addFork =
new QToolButton(*forkButton, TR("New Fork"), QString::null,
this, SLOT(hit_fork()), toolbar, "add fork");
addFork->setToggleButton(TRUE);
QWhatsThis::add(addFork, addforkText());
addJoin =
new QToolButton(*joinButton, TR("New Join"), QString::null,
this, SLOT(hit_join()), toolbar, "add join");
addJoin->setToggleButton(TRUE);
QWhatsThis::add(addJoin, addjoinText());
addFlow =
new QToolButton(*directionalAssociationButton, TR("New Flow"), QString::null,
this, SLOT(hit_flow()), toolbar, "add flow");
addFlow->setToggleButton(TRUE);
QWhatsThis::add(addFlow, addflowText());
dependency =
new QToolButton(*dependencyButton, TR("Dependency"), QString::null,
this, SLOT(hit_dependency()), toolbar, "dependency");
dependency->setToggleButton(TRUE);
QWhatsThis::add(dependency, dependencyText());
note =
new QToolButton(*noteButton, TR("Note"), QString::null,
this, SLOT(hit_note()), toolbar, "note");
note->setToggleButton(TRUE);
QWhatsThis::add(note, noteText());
anchor =
new QToolButton(*anchorButton, TR("Anchor"), QString::null,
this, SLOT(hit_anchor()), toolbar, "anchor");
anchor->setToggleButton(TRUE);
QWhatsThis::add(anchor, anchorText());
text =
new QToolButton(*textButton, TR("Text"), QString::null,
this, SLOT(hit_text()), toolbar, "text");
text->setToggleButton(TRUE);
QWhatsThis::add(text, textText());
image =
new QToolButton(*imageButton, TR("Image"), QString::null,
this, SLOT(hit_image()), toolbar, "image");
image->setToggleButton(TRUE);
QWhatsThis::add(image, imageText());
toolbar->addSeparator();
add_scale_cmd(toolbar);
//
view = new ActivityDiagramView(this, canvas, (id != -1) ? id : b->get_ident());
setFocusProxy(view);
setCentralWidget(view);
//qApp->setMainWidget(this);
QWorkspace * w = UmlWindow::get_workspace();
resize((w->width() * 4)/5, (w->height() * 4)/5);
/*if (w->windowList().isEmpty())
showMaximized();
else*/
show();
view->preferred_size_zoom();
//qApp->setMainWidget(0);
}
TextTools::TextTools(QWidget* parent)
: QDockWidget(parent)
{
_textElement = 0;
setObjectName("text-tools");
setWindowTitle(tr("Text Tools"));
setAllowedAreas(Qt::TopDockWidgetArea | Qt::BottomDockWidgetArea);
QToolBar* tb = new QToolBar(tr("Text Edit"));
textStyles = new QComboBox;
tb->addWidget(textStyles);
showKeyboard = getAction("show-keys");
tb->addAction(showKeyboard);
showKeyboard->setCheckable(true);
typefaceBold = tb->addAction(*icons[textBold_ICON], "");
typefaceBold->setToolTip(tr("bold"));
typefaceBold->setCheckable(true);
typefaceItalic = tb->addAction(*icons[textItalic_ICON], "");
typefaceItalic->setToolTip(tr("italic"));
typefaceItalic->setCheckable(true);
typefaceUnderline = tb->addAction(*icons[textUnderline_ICON], "");
typefaceUnderline->setToolTip(tr("underline"));
typefaceUnderline->setCheckable(true);
tb->addSeparator();
QActionGroup* ha = new QActionGroup(tb);
leftAlign = new QAction(*icons[textLeft_ICON], "", ha);
leftAlign->setToolTip(tr("align left"));
leftAlign->setCheckable(true);
leftAlign->setData(ALIGN_LEFT);
hcenterAlign = new QAction(*icons[textCenter_ICON], "", ha);
hcenterAlign->setToolTip(tr("align horizontal center"));
hcenterAlign->setCheckable(true);
hcenterAlign->setData(ALIGN_HCENTER);
rightAlign = new QAction(*icons[textRight_ICON], "", ha);
rightAlign->setToolTip(tr("align right"));
rightAlign->setCheckable(true);
rightAlign->setData(ALIGN_RIGHT);
tb->addActions(ha->actions());
QActionGroup* va = new QActionGroup(tb);
topAlign = new QAction(*icons[textTop_ICON], "", va);
topAlign->setToolTip(tr("align top"));
topAlign->setCheckable(true);
topAlign->setData(ALIGN_TOP);
bottomAlign = new QAction(*icons[textBottom_ICON], "", va);
bottomAlign->setToolTip(tr("align bottom"));
bottomAlign->setCheckable(true);
bottomAlign->setData(ALIGN_BOTTOM);
baselineAlign = new QAction(*icons[textVCenter_ICON], "", va);
baselineAlign->setToolTip(tr("align vertical baseline"));
baselineAlign->setCheckable(true);
baselineAlign->setData(ALIGN_BASELINE);
vcenterAlign = new QAction(*icons[textVCenter_ICON], "", va);
vcenterAlign->setToolTip(tr("align vertical center"));
vcenterAlign->setCheckable(true);
vcenterAlign->setData(ALIGN_VCENTER);
tb->addActions(va->actions());
typefaceSubscript = tb->addAction(*icons[textSub_ICON], "");
typefaceSubscript->setToolTip(tr("subscript"));
typefaceSubscript->setCheckable(true);
typefaceSuperscript = tb->addAction(*icons[textSuper_ICON], "");
typefaceSuperscript->setToolTip(tr("superscript"));
typefaceSuperscript->setCheckable(true);
unorderedList = tb->addAction(*icons[formatListUnordered_ICON], "");
unorderedList->setToolTip(tr("unordered list"));
orderedList = tb->addAction(*icons[formatListOrdered_ICON], "");
orderedList->setToolTip(tr("ordered list"));
indentMore = tb->addAction(*icons[formatIndentMore_ICON], "");
indentMore->setToolTip(tr("indent more"));
indentLess = tb->addAction(*icons[formatIndentLess_ICON], "");
indentLess->setToolTip(tr("indent less"));
tb->addSeparator();
typefaceFamily = new QFontComboBox(this);
tb->addWidget(typefaceFamily);
typefaceSize = new QDoubleSpinBox(this);
tb->addWidget(typefaceSize);
setWidget(tb);
QWidget* w = new QWidget(this);
setTitleBarWidget(w);
titleBarWidget()->hide();
connect(typefaceSize, SIGNAL(valueChanged(double)), SLOT(sizeChanged(double)));
connect(typefaceFamily, SIGNAL(currentFontChanged(const QFont&)), SLOT(fontChanged(const QFont&)));
connect(typefaceBold, SIGNAL(triggered(bool)), SLOT(boldClicked(bool)));
connect(typefaceItalic, SIGNAL(triggered(bool)), SLOT(italicClicked(bool)));
connect(typefaceUnderline, SIGNAL(triggered(bool)), SLOT(underlineClicked(bool)));
connect(typefaceSubscript, SIGNAL(triggered(bool)), SLOT(subscriptClicked(bool)));
connect(typefaceSuperscript, SIGNAL(triggered(bool)), SLOT(superscriptClicked(bool)));
connect(typefaceFamily, SIGNAL(currentFontChanged(const QFont&)), SLOT(fontChanged(const QFont&)));
connect(ha, SIGNAL(triggered(QAction*)), SLOT(setHalign(QAction*)));
connect(va, SIGNAL(triggered(QAction*)), SLOT(setValign(QAction*)));
connect(showKeyboard, SIGNAL(triggered(bool)), SLOT(showKeyboardClicked(bool)));
connect(textStyles, SIGNAL(currentIndexChanged(int)), SLOT(styleChanged(int)));
connect(unorderedList, SIGNAL(triggered()), SLOT(unorderedListClicked()));
connect(orderedList, SIGNAL(triggered()), SLOT(orderedListClicked()));
connect(indentLess, SIGNAL(triggered()), SLOT(indentLessClicked()));
connect(indentMore, SIGNAL(triggered()), SLOT(indentMoreClicked()));
}
Dialog_Mail::Dialog_Mail(QWidget *parent, QString iTitle, int *iIdx, DialogMailType iMode)
: QDialog(parent)
{
Mode = iMode;
Idx = iIdx;
setWindowTitle(iTitle);
QAction *ActSend = new QAction(tr("Отправить"),this);
ActSend->setIcon(QPixmap(":img/SendMail.png"));
ActSend->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_S));
ActSend->setText(tr("&Отправить Сообщения"));
ActSend->setToolTip(tr("Отправить Сообщения"));
ActSend->setStatusTip(tr("Отправить Сообщения"));
connect(ActSend, SIGNAL(triggered()), this, SLOT(SlotSend()));
QAction *ActSave = new QAction(tr("Сохранить"),this);
ActSave->setIcon(QPixmap(":img/Save.png"));
ActSave->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_R));
ActSave->setText(tr("&Сохранить Сообщение"));
ActSave->setToolTip(tr("Сохранить Сообщение"));
ActSave->setStatusTip(tr("Сохранить Сообщение"));
connect(ActSave, SIGNAL(triggered()), this, SLOT(SlotSave()));
QAction *ActCancel = new QAction(tr("Отменить"),this);
ActCancel->setIcon(QPixmap(":img/Cancel.png"));
ActCancel->setShortcut(QKeySequence("ESC"));
ActCancel->setText(tr("&Отменить Сообщение"));
ActCancel->setToolTip(tr("Отменить Сообщение"));
ActCancel->setStatusTip(tr("Отменить Сообщение"));
connect(ActCancel, SIGNAL(triggered()), this, SLOT(SlotCancel()));
QHBoxLayout *ToolLayout = new QHBoxLayout();
ToolLayout->setMargin(0);
QToolBar *ToolBar = new QToolBar();
ToolBar->setOrientation(Qt::Horizontal);
ToolBar->setToolButtonStyle(Qt::ToolButtonIconOnly);
ToolLayout->addWidget(ToolBar);
ToolBar->addAction(ActSend);
ToolBar->addSeparator();
ToolBar->addAction(ActSave);
ToolBar->addSeparator();
ToolBar->addAction(ActCancel);
QFrame *ToolFrame = new QFrame();
ToolFrame->setStyleSheet(QString("background-color: %1").arg(Global.Palette.color(QPalette::Window).name()));
ToolFrame->setFrameStyle(QFrame::StyledPanel | QFrame::Plain);
ToolFrame->setLayout(ToolLayout);
QVBoxLayout *TBox = new QVBoxLayout();
TBox->setMargin(0);
Receiver = new QComboBox();
Subj = new QLineEdit();
Message = new QTextEdit();
QFormLayout *Form = new QFormLayout();
Form->addRow(tr("Получатель: "), Receiver);
Form->addRow(tr("Тема: "), Subj);
Form->setLabelAlignment(Qt::AlignRight);
TBox->addLayout(Form,0);
TBox->addWidget(Message,1);
QFrame *Center = new QFrame();
Center->setLayout(TBox);
QVBoxLayout *Out = new QVBoxLayout();
Out->addWidget(ToolFrame,0);
Out->addSpacing(4);
Out->addWidget(Center,1);
setLayout(Out);
setMinimumSize(480,320);
Init();
}