void toPieChart::openCopy(void)
{
QWidget *newWin = new toPieChart(this,
toMainWidget()->workspace(),
NULL,
0);
newWin->setAttribute(Qt::WA_DeleteOnClose);
newWin->show();
newWin->raise();
newWin->setFocus();
toMainWidget()->updateWindowsMenu();
}
void toPLSQLEditor::windowActivated(QMdiSubWindow *widget)
{
if (!widget)
return;
if (widget->widget() == this)
{
if (!ToolMenu)
{
ToolMenu = new QMenu(tr("&PL/SQL Editor"), this);
ToolMenu->addAction(refreshAct);
ToolMenu->addAction(describeAct);
ToolMenu->addSeparator();
ToolMenu->addAction(newSheetAct);
ToolMenu->addAction(compileAct);
ToolMenu->addAction(compileWarnAct);
ToolMenu->addAction(closeAct);
ToolMenu->addAction(closeAllAct);
ToolMenu->addSeparator();
ToolMenu->addAction(nextErrorAct);
ToolMenu->addAction(previousErrorAct);
toMainWidget()->addCustomMenu(ToolMenu);
}
}
else
{
delete ToolMenu;
ToolMenu = NULL;
}
}
toLineChart *toBarChart::openCopy(QWidget *parent)
{
toBarChart *newWin = new toBarChart(this,
parent ? parent : toMainWidget()->workspace(),
NULL,
(Qt::WindowType) (parent ? 0 : Qt::WA_DeleteOnClose));
if (!parent)
{
newWin->show();
newWin->raise();
newWin->setFocus();
toMainWidget()->updateWindowsMenu();
}
return newWin;
}
void toAlert::windowActivated(QMdiSubWindow *widget)
{
if (!widget)
return;
if (widget->widget() == this)
{
if (!ToolMenu)
{
ToolMenu = new QMenu(tr("&Alert"), this);
ToolMenu->addAction(addAct);
ToolMenu->addAction(removeAct);
ToolMenu->addSeparator();
ToolMenu->addAction(memoEditAct);
ToolMenu->addAction(sendAct);
toMainWidget()->addCustomMenu(ToolMenu);
}
}
else
{
delete ToolMenu;
ToolMenu = NULL;
}
}
void toProjectTemplate::addFile(void)
{
QString file = toOpenFilename(QString::fromLatin1(PROJECT_EXTENSIONS),
toMainWidget());
if (!file.isNull())
{
toTreeWidget *view = Root->listView();
toProjectTemplateItem *item = dynamic_cast<toProjectTemplateItem *>(view->currentItem());
if (item)
{
item->setOpen(true);
toTreeWidgetItem *last = item->firstChild();
while (last && last->nextSibling())
last = last->nextSibling();
if (item->project())
new toProjectTemplateItem(item, last, file);
else
{
item = dynamic_cast<toProjectTemplateItem *>(item->parent());
if (item)
new toProjectTemplateItem(item, last, file);
}
}
if (Details)
Details->update();
}
}
void toMain::displayMessage ( void )
{
static bool recursive = false;
if ( recursive )
return;
recursive = true;
for ( QString str = toShift ( StatusMessages );!str.isEmpty();str = toShift ( StatusMessages ) ) {
toMessageUI dialog ( toMainWidget(), NULL, true );
dialog.Message->setText ( str );
dialog.exec();
if ( dialog.Statusbar->isChecked() ) {
toTool::globalSetConfig ( CONF_MESSAGE_STATUSBAR, "Yes" );
TOMessageBox::information ( toMainWidget(),
"Information", "You can enable this through the Global Settings in the Options (Edit menu)" );
toTool::saveConfig();
}
}
recursive = false;
}
void toChangeConnection::popupMenu(void)
{
try
{
menu()->clear();
toConnection &conn = toCurrentConnection(this);
std::list<QString> cons = toMainWidget()->connections();
for (std::list<QString>::iterator i = cons.begin(); i != cons.end(); i++)
{
if (toCurrentTool(this)->canHandle(toMainWidget()->connection(*i)))
{
QAction *act = menu()->addAction(*i);
act->setCheckable(true);
if (conn.description() == *i)
act->setChecked(true);
else
act->setChecked(false);
}
}
}
TOCATCH;
}
void toChangeConnection::changeConnection(QAction *act)
{
// the act of clicking the menu will invert the checked flag
if (!act->isChecked())
return;
std::list<QString> cons = toMainWidget()->connections();
try
{
for (std::list<QString>::iterator i = cons.begin(); i != cons.end(); i++)
{
if (act->text() == (*i))
{
QWidget *cur = parentWidget();
while (cur)
{
toToolWidget *tool = dynamic_cast<toToolWidget *>(cur);
if (tool)
{
tool->setConnection(toMainWidget()->connection(*i));
toMainWidget()->windowActivated(qobject_cast<QMdiSubWindow*>(tool->parent()));
toMainWidget()->changeConnection();
return;
}
cur = cur->parentWidget();
}
throw tr("Couldn't find parent connection. Internal error.");
}
}
}
TOCATCH;
toStatusMessage("Couldn't find selected connection");
}
void toToolWidget::exportData(std::map<QString, QString> &data, const QString &prefix)
{
QWidget *par = parentWidget();
if (!par)
par = this;
if (isMaximized() || par->width() >= toMainWidget()->workspace()->width())
data[prefix + ":State"] = QString::fromLatin1("Maximized");
else if (isMinimized())
data[prefix + ":State"] = QString::fromLatin1("Minimized");
data[prefix + ":X"] = QString::number(par->x());
data[prefix + ":Y"] = QString::number(par->y());
data[prefix + ":Width"] = QString::number(par->width());
data[prefix + ":Height"] = QString::number(par->height());
}
void toProject::generateSQL(void)
{
toTreeWidgetItem *item = Project->selectedItem();
if (item)
{
toProjectTemplateItem *oi = ItemMap[item];
if (oi)
{
if (!oi->project())
oi = dynamic_cast<toProjectTemplateItem *>(oi->parent());
if (oi)
{
QString data = generateSQL(oi);
new toMemoEditor(toMainWidget(), data);
}
}
}
}
void toBackup::windowActivated(QMdiSubWindow *widget)
{
if (!widget)
return;
if (widget->widget() == this)
{
if (!ToolMenu)
{
ToolMenu = new QMenu(tr("&Backup Manager"), this);
ToolMenu->addAction(updateAct);
toMainWidget()->addCustomMenu(ToolMenu);
}
}
else
{
delete ToolMenu;
ToolMenu = NULL;
}
}
void toMain::commandCallback ( int cmd )
{
QWidget * focus = qApp->focusWidget();
if ( focus ) {
toEditWidget * edit = findEdit ( focus );
if ( edit && edit != Edit )
setEditWidget ( edit );
else if ( focus->inherits ( "QLineEdit" ) ||
focus->isA ( "QSpinBox" ) )
editDisable ( Edit );
}
if ( Tools[cmd] )
Tools[cmd]->createWindow();
else if ( cmd >= TO_TOOL_ABOUT_ID && cmd <= TO_TOOL_ABOUT_ID_END ) {
if ( Tools[cmd-TO_ABOUT_ID_OFFSET] )
Tools[cmd-TO_ABOUT_ID_OFFSET]->about ( this );
} else if ( cmd >= TO_WINDOWS_WINDOWS && cmd <= TO_WINDOWS_END ) {
if ( cmd - TO_WINDOWS_WINDOWS < int ( workspace() ->windowList().count() ) )
workspace() ->windowList().at ( cmd - TO_WINDOWS_WINDOWS ) ->setFocus();
} else if ( cmd >= TO_STATUS_ID && cmd <= TO_STATUS_ID_END ) {
QString str = StatusMenu->text ( cmd );
new toMemoEditor ( this, str );
} else {
QWidget *currWidget = qApp->focusWidget();
toEditWidget *edit = NULL;
while ( currWidget && !edit ) {
edit = dynamic_cast<toEditWidget *> ( currWidget );
currWidget = currWidget->parentWidget();
}
if ( edit ) {
switch ( cmd ) {
case TO_EDIT_REDO:
edit->editRedo();
break;
case TO_EDIT_UNDO:
edit->editUndo();
break;
case TO_EDIT_COPY:
edit->editCopy();
break;
case TO_EDIT_PASTE:
edit->editPaste();
break;
case TO_EDIT_CUT:
edit->editCut();
break;
case TO_EDIT_SELECT_ALL:
edit->editSelectAll();;
break;
case TO_EDIT_READ_ALL:
edit->editReadAll();
break;
case TO_EDIT_SEARCH:
if ( !Search )
Search = new toSearchReplace ( this );
edit->editSearch ( Search );
break;
case TO_FILE_OPEN:
edit->editOpen();
break;
case TO_FILE_SAVE_AS:
edit->editSave ( true );
break;
case TO_FILE_SAVE:
edit->editSave ( false );
break;
case TO_FILE_PRINT:
edit->editPrint();
break;
}
}
switch ( cmd ) {
case TO_FILE_COMMIT:
try {
toConnection & conn = currentConnection();
emit willCommit ( conn, true );
conn.commit();
setNeedCommit ( conn, false );
}
TOCATCH
break;
case TO_FILE_CLEARCACHE:
try {
currentConnection().rereadCache();
}
TOCATCH
toMainWidget() ->checkCaching();
break;
case TO_FILE_ROLLBACK:
try {
toConnection &conn = currentConnection();
emit willCommit ( conn, false );
conn.rollback();
setNeedCommit ( conn, false );
}
TOCATCH
break;
case TO_FILE_CURRENT:
ConnectionSelection->setFocus();
break;
case TO_FILE_QUIT:
close ( true );
break;
case TO_EDIT_SEARCH_NEXT:
if ( Search )
Search->searchNext();
break;
case TO_WINDOWS_CASCADE:
workspace() ->cascade();
break;
case TO_WINDOWS_TILE:
workspace() ->tile();
break;
case TO_NEW_CONNECTION:
addConnection();
break;
case TO_HELP_CONTEXT:
contextHelp();
break;
case TO_HELP_CONTENTS:
toHelp::displayHelp ( "toc.htm" );
break;
case TO_HELP_ABOUT:
case TO_HELP_LICENSE:
case TO_HELP_QUOTES: {
toAbout *about = new toAbout ( cmd - TO_HELP_ABOUT, this, "About TOra", true );
about->exec();
delete about;
}
break;
case TO_HELP_REGISTER:
toCheckLicense ( true );
break;
case TO_EDIT_OPTIONS:
toPreferences::displayPreferences ( this );
break;
case TO_WINDOWS_CLOSE_ALL:
while ( workspace() ->windowList().count() > 0 && workspace() ->windowList().at ( 0 ) )
if ( workspace() ->windowList().at ( 0 ) &&
!workspace() ->windowList().at ( 0 ) ->close ( true ) )
return;
break;
case TO_WINDOWS_CLOSE:
QWidget *widget = workspace() ->activeWindow();
if ( widget )
widget->close ( true );
break;
}
}
}
toMain::toMain()
: toMainWindow()
{
qApp->setMainWidget ( this );
setDockMenuEnabled ( true );
Edit = NULL;
FileMenu = new QPopupMenu ( this );
FileMenu->insertItem ( QPixmap ( ( const char ** ) connect_xpm ),
"&New Connection...", TO_NEW_CONNECTION );
FileMenu->insertItem ( QPixmap ( ( const char ** ) disconnect_xpm ),
"&Close Connection", this, SLOT ( delConnection() ), 0, TO_CLOSE_CONNECTION );
FileMenu->insertSeparator();
FileMenu->insertItem ( QPixmap ( ( const char ** ) commit_xpm ), "&Commit Connection", TO_FILE_COMMIT );
FileMenu->insertItem ( QPixmap ( ( const char ** ) rollback_xpm ), "&Rollback Connection", TO_FILE_ROLLBACK );
FileMenu->insertItem ( "C&urrent Connection", TO_FILE_CURRENT );
FileMenu->insertItem ( QPixmap ( ( const char ** ) trash_xpm ), "Reread Object Cache", TO_FILE_CLEARCACHE );
FileMenu->insertSeparator();
FileMenu->insertItem ( QPixmap ( ( const char ** ) fileopen_xpm ), "&Open File...", TO_FILE_OPEN );
FileMenu->insertItem ( QPixmap ( ( const char ** ) filesave_xpm ), "&Save", TO_FILE_SAVE );
FileMenu->insertItem ( "Save A&s...", TO_FILE_SAVE_AS );
FileMenu->insertSeparator();
FileMenu->insertItem ( QPixmap ( ( const char ** ) print_xpm ), "&Print..", TO_FILE_PRINT );
FileMenu->insertSeparator();
FileMenu->insertItem ( "&Quit", TO_FILE_QUIT );
menuBar() ->insertItem ( "&File", FileMenu, TO_FILE_MENU );
FileMenu->setAccel ( Key_G | CTRL, TO_NEW_CONNECTION );
FileMenu->setAccel ( Key_O | CTRL, TO_FILE_OPEN );
FileMenu->setAccel ( Key_S | CTRL, TO_FILE_SAVE );
FileMenu->setAccel ( Key_W | CTRL, TO_FILE_COMMIT );
FileMenu->setAccel ( Key_R | CTRL, TO_FILE_ROLLBACK );
FileMenu->setAccel ( Key_U | CTRL, TO_FILE_CURRENT );
connect ( FileMenu, SIGNAL ( aboutToShow() ), this, SLOT ( editFileMenu() ) );
EditMenu = new QPopupMenu ( this );
EditMenu->insertItem ( QPixmap ( ( const char ** ) undo_xpm ), "&Undo", TO_EDIT_UNDO );
EditMenu->insertItem ( QPixmap ( ( const char ** ) redo_xpm ), "&Redo", TO_EDIT_REDO );
EditMenu->insertSeparator();
EditMenu->insertItem ( QPixmap ( ( const char ** ) cut_xpm ), "Cu&t", TO_EDIT_CUT );
EditMenu->insertItem ( QPixmap ( ( const char ** ) copy_xpm ), "&Copy", TO_EDIT_COPY );
EditMenu->insertItem ( QPixmap ( ( const char ** ) paste_xpm ), "&Paste", TO_EDIT_PASTE );
EditMenu->insertSeparator();
EditMenu->insertItem ( "&Search && Replace", TO_EDIT_SEARCH );
EditMenu->insertItem ( "Search &Next", TO_EDIT_SEARCH_NEXT );
EditMenu->insertItem ( "Select &All", TO_EDIT_SELECT_ALL );
EditMenu->insertItem ( "Read All &Items", TO_EDIT_READ_ALL );
EditMenu->insertSeparator();
EditMenu->insertItem ( "&Options...", TO_EDIT_OPTIONS );
EditMenu->setAccel ( Key_Z | CTRL, TO_EDIT_UNDO );
EditMenu->setAccel ( Key_Y | CTRL, TO_EDIT_REDO );
EditMenu->setAccel ( Key_X | CTRL, TO_EDIT_CUT );
EditMenu->setAccel ( Key_C | CTRL, TO_EDIT_COPY );
EditMenu->setAccel ( Key_V | CTRL, TO_EDIT_PASTE );
EditMenu->setAccel ( Key_F | CTRL, TO_EDIT_SEARCH );
EditMenu->setAccel ( Key_F3, TO_EDIT_SEARCH_NEXT );
connect ( EditMenu, SIGNAL ( aboutToShow() ), this, SLOT ( editFileMenu() ) );
menuBar() ->insertItem ( "&Edit", EditMenu, TO_EDIT_MENU );
std::map<QString, toTool *> &tools = toTool::tools();
QToolBar *toolbar = toAllocBar ( this, "Application", QString::null );
LoadButton = new QToolButton ( QPixmap ( ( const char ** ) fileopen_xpm ),
"Load file into editor",
"Load file into editor",
this, SLOT ( loadButton() ), toolbar );
SaveButton = new QToolButton ( QPixmap ( ( const char ** ) filesave_xpm ),
"Save file from editor",
"Save file from editor",
this, SLOT ( saveButton() ), toolbar );
PrintButton = new QToolButton ( QPixmap ( ( const char ** ) print_xpm ),
"Print",
"Print",
this, SLOT ( printButton() ), toolbar );
PrintButton->setEnabled ( false );
LoadButton->setEnabled ( false );
SaveButton->setEnabled ( false );
toolbar->addSeparator();
UndoButton = new QToolButton ( QPixmap ( ( const char ** ) undo_xpm ),
"Undo",
"Undo",
this, SLOT ( undoButton() ), toolbar );
RedoButton = new QToolButton ( QPixmap ( ( const char ** ) redo_xpm ),
"Redo",
"Redo",
this, SLOT ( redoButton() ), toolbar );
CutButton = new QToolButton ( QPixmap ( ( const char ** ) cut_xpm ),
"Cut to clipboard",
"Cut to clipboard",
this, SLOT ( cutButton() ), toolbar );
CopyButton = new QToolButton ( QPixmap ( ( const char ** ) copy_xpm ),
"Copy to clipboard",
"Copy to clipboard",
this, SLOT ( copyButton() ), toolbar );
PasteButton = new QToolButton ( QPixmap ( ( const char ** ) paste_xpm ),
"Paste from clipboard",
"Paste from clipboard",
this, SLOT ( pasteButton() ), toolbar );
UndoButton->setEnabled ( false );
RedoButton->setEnabled ( false );
CutButton->setEnabled ( false );
CopyButton->setEnabled ( false );
PasteButton->setEnabled ( false );
ToolsMenu = new QPopupMenu ( this );
#ifdef TOOL_TOOLBAR
toolbar = new toAllocBar ( this, "Tools", QString::null );
#else
toolbar->addSeparator();
#endif
int toolID = TO_TOOLS;
int lastPriorityPix = 0;
int lastPriorityMenu = 0;
SQLEditor = -1;
DefaultTool = toolID;
QString defName = toTool::globalConfig ( CONF_DEFAULT_TOOL, "" );
HelpMenu = new QPopupMenu ( this );
HelpMenu->insertItem ( "C&urrent Context", TO_HELP_CONTEXT );
HelpMenu->insertItem ( "&Contents", TO_HELP_CONTENTS );
HelpMenu->insertSeparator();
HelpMenu->insertItem ( "&About TOra", TO_HELP_ABOUT );
HelpMenu->insertItem ( "&License", TO_HELP_LICENSE );
HelpMenu->insertItem ( "&Quotes", TO_HELP_QUOTES );
HelpMenu->setAccel ( Key_F1, TO_HELP_CONTEXT );
if ( !toFreeware() ) {
HelpMenu->insertSeparator();
HelpMenu->insertItem ( "&Register", TO_HELP_REGISTER );
}
QPopupMenu *toolAbout = NULL;
for ( std::map<QString, toTool *>::iterator i = tools.begin();i != tools.end();i++ ) {
const QPixmap *pixmap = ( *i ).second->toolbarImage();
const char *toolTip = ( *i ).second->toolbarTip();
const char *menuName = ( *i ).second->menuItem();
QString tmp = ( *i ).second->name();
tmp += CONF_TOOL_ENABLE;
if ( toTool::globalConfig ( tmp, "Yes" ).isEmpty() )
continue;
if ( defName == menuName )
DefaultTool = toolID;
int priority = ( *i ).second->priority();
if ( priority / 100 != lastPriorityPix / 100 &&
pixmap ) {
toolbar->addSeparator();
lastPriorityPix = priority;
}
if ( priority / 100 != lastPriorityMenu / 100 &&
menuName ) {
ToolsMenu->insertSeparator();
lastPriorityMenu = priority;
}
if ( pixmap ) {
if ( !toolTip )
toolTip = "";
NeedConnection[new QToolButton ( *pixmap,
toolTip,
toolTip,
( *i ).second,
SLOT ( createWindow ( void ) ),
toolbar ) ] = ( *i ).second;
}
if ( menuName ) {
if ( pixmap )
ToolsMenu->insertItem ( *pixmap, menuName, toolID );
else
ToolsMenu->insertItem ( menuName, toolID );
ToolsMenu->setItemEnabled ( toolID, false );
}
if ( ( *i ).second->hasAbout() && menuName ) {
if ( !toolAbout ) {
toolAbout = new QPopupMenu ( this );
HelpMenu->insertItem ( "Tools", toolAbout );
}
if ( pixmap )
toolAbout->insertItem ( *pixmap, menuName, toolID + TO_ABOUT_ID_OFFSET );
else
toolAbout->insertItem ( menuName, toolID + TO_ABOUT_ID_OFFSET );
}
Tools[toolID] = ( *i ).second;
toolID++;
}
#ifndef TOOL_TOOLBAR
toolbar->setStretchableWidget ( new QLabel ( "", toolbar ) );
#endif
new QToolButton ( QPixmap ( ( const char ** ) connect_xpm ),
"Connect to database",
"Connect to database",
this, SLOT ( addConnection() ), toolbar );
DisconnectButton = new QToolButton ( QPixmap ( ( const char ** ) disconnect_xpm ),
"Disconnect current connection",
"Disconnect current connection",
this, SLOT ( delConnection() ), toolbar );
DisconnectButton->setEnabled ( false );
toolbar->addSeparator();
NeedConnection[new QToolButton ( QPixmap ( ( const char ** ) commit_xpm ),
"Commit connection",
"Commit connection",
this,SLOT ( commitButton() ),toolbar ) ] = NULL;
NeedConnection[new QToolButton ( QPixmap ( ( const char ** ) rollback_xpm ),
"Rollback connection",
"Rollback connection",
this,SLOT ( rollbackButton() ),toolbar ) ] = NULL;
toolbar->addSeparator();
ConnectionSelection = new QComboBox ( toolbar );
ConnectionSelection->setFixedWidth ( 200 );
ConnectionSelection->setFocusPolicy ( NoFocus );
connect ( ConnectionSelection, SIGNAL ( activated ( int ) ), this, SLOT ( changeConnection() ) );
menuBar() ->insertItem ( "&Tools", ToolsMenu, TO_TOOLS_MENU );
WindowsMenu = new QPopupMenu ( this );
WindowsMenu->setCheckable ( true );
connect ( WindowsMenu, SIGNAL ( aboutToShow() ), this, SLOT ( windowsMenu() ) );
menuBar() ->insertItem ( "&Window", WindowsMenu, TO_WINDOWS_MENU );
menuBar() ->insertSeparator();
menuBar() ->insertItem ( "&Help", HelpMenu, TO_HELP_MENU );
char buffer[100];
sprintf ( buffer, DEFAULT_TITLE, TOVERSION );
setCaption ( buffer );
#ifdef TO_KDE
KDockWidget *mainDock = createDockWidget ( buffer, QPixmap ( ( const char ** ) toramini_xpm ) );
Workspace = new QWorkspace ( mainDock );
mainDock->setWidget ( Workspace );
setView ( mainDock );
setMainDockWidget ( mainDock );
mainDock->setEnableDocking ( KDockWidget::DockNone );
#else
Workspace = new QWorkspace ( this );
setCentralWidget ( Workspace );
#endif
setIcon ( QPixmap ( ( const char ** ) toramini_xpm ) );
statusBar() ->message ( "Ready" );
menuBar() ->setItemEnabled ( TO_CLOSE_CONNECTION, false );
menuBar() ->setItemEnabled ( TO_FILE_COMMIT, false );
menuBar() ->setItemEnabled ( TO_FILE_ROLLBACK, false );
menuBar() ->setItemEnabled ( TO_FILE_CLEARCACHE, false );
DisconnectButton->setEnabled ( false );
for ( std::map<QToolButton *, toTool *>::iterator j = NeedConnection.begin();
j != NeedConnection.end();j++ )
( *j ).first->setEnabled ( false );
connect ( menuBar(), SIGNAL ( activated ( int ) ), this, SLOT ( commandCallback ( int ) ) );
RowLabel = new QLabel ( statusBar() );
statusBar() ->addWidget ( RowLabel, 0, true );
RowLabel->setMinimumWidth ( 60 );
RowLabel->hide();
ColumnLabel = new QLabel ( statusBar() );
statusBar() ->addWidget ( ColumnLabel, 0, true );
ColumnLabel->setMinimumWidth ( 60 );
ColumnLabel->hide();
QToolButton *dispStatus = new toPopupButton ( statusBar() );
dispStatus->setIconSet ( QPixmap ( ( const char ** ) up_xpm ) );
statusBar() ->addWidget ( dispStatus, 0, true );
StatusMenu = new QPopupMenu ( dispStatus );
dispStatus->setPopup ( StatusMenu );
connect ( StatusMenu, SIGNAL ( aboutToShow() ),
this, SLOT ( statusMenu() ) );
connect ( StatusMenu, SIGNAL ( activated ( int ) ), this, SLOT ( commandCallback ( int ) ) );
toolID = TO_TOOLS;
for ( std::map<QString, toTool *>::iterator k = tools.begin();k != tools.end();k++ ) {
( *k ).second->customSetup ( toolID );
toolID++;
}
Search = NULL;
if ( !toTool::globalConfig ( CONF_MAXIMIZE_MAIN, "Yes" ).isEmpty() )
showMaximized();
show();
QString welcome;
do {
welcome = toCheckLicense ( false );
} while ( welcome.isNull() );
toStatusMessage ( welcome, true );
connect ( &Poll, SIGNAL ( timeout() ), this, SLOT ( checkCaching() ) );
try {
toNewConnection newConnection ( this, "First connection", true );
toConnection *conn;
do {
conn = NULL;
if ( newConnection.exec() ) {
conn = newConnection.makeConnection();
} else {
break;
}
} while ( !conn );
if ( conn )
addConnection ( conn );
}
TOCATCH
connect ( toMainWidget() ->workspace(), SIGNAL ( windowActivated ( QWidget * ) ),
this, SLOT ( windowActivated ( QWidget * ) ) );
}
virtual void customSetup(void)
{
QMenu *edit = toMainWidget()->getEditMenu();
edit->addSeparator();
IncMenu = edit->addMenu(
qApp->translate("toEditExtensionTool", "Incremental Search"));
IncrementalSearch = IncMenu->addAction(qApp->translate("toEditExtensionTool",
"Forward"),
&toEditExtensionsSingle::Instance(),
SLOT(searchForward()));
IncrementalSearch->setShortcut(Qt::CTRL + Qt::SHIFT + Qt::Key_S);
ReverseSearch = IncMenu->addAction(qApp->translate("toEditExtensionTool",
"Backward"),
&toEditExtensionsSingle::Instance(),
SLOT(searchBackward()));
ReverseSearch->setShortcut(Qt::CTRL + Qt::SHIFT + Qt::Key_R);
// ------------------------------ indentation menu
IndentMenu = edit->addMenu(
qApp->translate("toEditExtensionTool", "Auto Indent"));
IndentBlock = IndentMenu->addAction(qApp->translate(
"toEditExtensionTool",
"Selection"),
&toEditExtensionsSingle::Instance(),
SLOT(autoIndentBlock()));
IndentBlock->setShortcut(Qt::CTRL + + Qt::ALT + Qt::Key_I);
IndentBuffer = IndentMenu->addAction(qApp->translate(
"toEditExtensionTool",
"Editor"),
&toEditExtensionsSingle::Instance(),
SLOT(autoIndentBuffer()));
IndentBuffer->setShortcut(Qt::CTRL + Qt::ALT + Qt::SHIFT + Qt::Key_I);
IndentMenu->addSeparator();
ObsBlock = IndentMenu->addAction(qApp->translate(
"toEditExtensionTool",
"Obfuscate Selection"),
&toEditExtensionsSingle::Instance(),
SLOT(obfuscateBlock()));
ObsBuffer = IndentMenu->addAction(qApp->translate("toEditExtensionTool",
"Obfuscate Editor"),
&toEditExtensionsSingle::Instance(),
SLOT(obfuscateBuffer()));
// ------------------------------ case menu
CaseMenu = edit->addMenu(
qApp->translate("toEditExtensionTool", "Modify Case"));
UpperCase = CaseMenu->addAction(qApp->translate("toEditExtensionTool",
"Upper"),
&toEditExtensionsSingle::Instance(),
SLOT(upperCase()));
UpperCase->setShortcut(Qt::CTRL + Qt::Key_U);
LowerCase = CaseMenu->addAction(qApp->translate("toEditExtensionTool",
"Lower"),
&toEditExtensionsSingle::Instance(),
SLOT(lowerCase()));
LowerCase->setShortcut(Qt::CTRL + Qt::Key_L);
// bookmark menu
BookmarkMenu = edit->addMenu(qApp->translate("toEditExtensionTool", "Bookmarks"));
BookmarkSwitchAct = BookmarkMenu->addAction("Add/Remove Bookmark",
&toEditExtensionsSingle::Instance(),
SLOT(bookmarkSwitch()));
BookmarkSwitchAct->setShortcut(Qt::CTRL + Qt::Key_B);
BookmarkPrevAct = BookmarkMenu->addAction("Go to previous Bookmark",
&toEditExtensionsSingle::Instance(),
SLOT(bookmarkPrev()));
BookmarkPrevAct->setShortcut(Qt::ALT + Qt::Key_PageUp);
BookmarkNextAct = BookmarkMenu->addAction("Go to next Bookmark",
&toEditExtensionsSingle::Instance(),
SLOT(bookmarkNext()));
BookmarkNextAct->setShortcut(Qt::ALT + Qt::Key_PageDown);
// EOL menu
EolMenu = edit->addMenu(qApp->translate("toEditExtensionTool", "Convert End of Lines to"));
EolUnixAct = EolMenu->addAction("UNIX", &toEditExtensionsSingle::Instance(), SLOT(convertEol()));
EolMacAct = EolMenu->addAction("Mac OS X", &toEditExtensionsSingle::Instance(), SLOT(convertEol()));
EolWindowsAct = EolMenu->addAction("MS Windows", &toEditExtensionsSingle::Instance(), SLOT(convertEol()));
// ------------------------------ etc
Indent = edit->addAction(
QIcon(QPixmap(const_cast<const char**>(indent_xpm))),
qApp->translate("toEditExtensionTool", "Indent Block"),
&toEditExtensionsSingle::Instance(),
SLOT(indentBlock()));
#ifndef Q_WS_MAC
Indent->setShortcut(Qt::ALT + Qt::Key_Right);
#endif
Deindent = edit->addAction(
QIcon(QPixmap(const_cast<const char**>(deindent_xpm))),
qApp->translate("toEditExtensionTool", "De-indent Block"),
&toEditExtensionsSingle::Instance(),
SLOT(deindentBlock()));
#ifndef Q_WS_MAC
Deindent->setShortcut(Qt::ALT + Qt::Key_Left);
#endif
Quote = edit->addAction(qApp->translate("toEditExtensionTool",
"Quote Selection"),
&toEditExtensionsSingle::Instance(),
SLOT(quoteBlock()));
UnQuote = edit->addAction(qApp->translate("toEditExtensionTool",
"UnQuote Selection"),
&toEditExtensionsSingle::Instance(),
SLOT(unquoteBlock()));
Comment = edit->addAction(qApp->translate("toEditExtensionTool",
"Comment or Uncomment"),
&toEditExtensionsSingle::Instance(),
SLOT(handleComment()),
Qt::CTRL + Qt::Key_D);
GotoLine = edit->addAction(qApp->translate("toEditExtensionTool",
"Goto Line"),
&toEditExtensionsSingle::Instance(),
SLOT(gotoLine()));
GotoLine->setShortcut(Qt::CTRL + Qt::Key_G);
AutoComplete = edit->addAction(
qApp->translate("toEditExtensionTool",
"Complete"),
&toEditExtensionsSingle::Instance(),
SLOT(autoComplete()));
AutoComplete->setShortcut(Qt::CTRL + Qt::Key_Space);
// add buttons to main window
// disabled due the problems in the state of toolbars
// toMainWidget()->addButtonApplication(Deindent);
// toMainWidget()->addButtonApplication(Indent);
toEditExtensionsSingle::Instance().receivedFocus(NULL);
connect(toMainWidget(),
SIGNAL(editEnabled(bool)),
&toEditExtensionsSingle::Instance(),
SLOT(editEnabled(bool)));
}
toEditExtensionSetup::toEditExtensionSetup(
toEditExtensionTool *tool,
QWidget *parent,
const char *name) : QWidget(parent),
toSettingTab("editextension.html"),
Tool(tool)
{
setupUi(this);
Current = toSQLParse::getSetting();
Started = false;
CommaBefore->setChecked(Current.CommaBefore);
BlockOpenLine->setChecked(Current.BlockOpenLine);
OperatorSpace->setChecked(Current.OperatorSpace);
KeywordUpper->setChecked(Current.KeywordUpper);
RightSeparator->setChecked(Current.RightSeparator);
EndBlockNewline->setChecked(Current.EndBlockNewline);
CommentColumn->setValue(Current.CommentColumn);
AutoIndent->setChecked(toConfigurationSingle::Instance().autoIndentRo());
DragDrop->setChecked(toConfigurationSingle::Instance().editDragDrop());
Ok = false;
try
{
Example->setAnalyzer(toMainWidget()->currentConnection().analyzer());
}
TOCATCH;
try
{
#ifdef TO_NO_ORACLE
Example->setText(toSQLParse::indent(
"CREATE PROCEDURE COUNT_EMPS_IN_DEPTS (OUT V_TOTAL INT)\n"
"BEGIN\n"
" DECLARE V_DEPTNO INT DEFAULT 10;\n"
" DECLARE V_COUNT INT DEFAULT 0;\n"
" SET V_TOTAL = 0;\n"
" WHILE V_DEPTNO < 100 DO\n"
" SELECT COUNT(*)\n"
" INTO V_COUNT\n"
" FROM TEST.EMP\n"
" WHERE DEPTNO = V_DEPTNO;\n"
" SET V_TOTAL = V_TOTAL + V_COUNT;\n"
" SET V_DEPTNO = V_DEPTNO + 10;\n"
" END WHILE;\n"
"END",
Example->analyzer()));
#else
Example->setText(toSQLParse::indent(
"CREATE OR REPLACE procedure spTuxGetAccData (oRet OUT NUMBER)\n"
"AS\n"
" vYear CHAR(4);\n"
"BEGIN\n"
"select a.TskCod TskCod, -- A Comment\n"
" count(1) Tot\n"
" from (select * from EssTsk where PrsID >= '1940');\n"
"having count(a.TspActOprID) > 0;\n"
" DECLARE\n"
" oTrdStt NUMBER;\n"
" BEGIN\n"
" oTrdStt := 0;\n"
" END;\n"
" EXCEPTION\n"
" WHEN VALUE_ERROR THEN\n"
" oRet := 3;\n"
"END;",
Example->analyzer()));
#endif
}
TOCATCH;
Started = true;
}
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();
}
toAlert::toAlert(QWidget *main, toConnection &connection)
: toToolWidget(AlertTool, "alert.html", main, connection, "toAlert")
, Connection(connection)
{
QToolBar *toolbar = toAllocBar(this, tr("Alert Messenger"));
layout()->addWidget(toolbar);
QString def;
try
{
toQList lst = toQuery::readQuery(connection, SQLHost);
def += toShift(lst);
if (!def.isEmpty())
def += QString::fromLatin1(":");
}
catch (...)
{}
def += connection.user();
toolbar->addWidget(
new QLabel(tr("Registered") + " ", toolbar));
Registered = new QComboBox(toolbar);
Registered->addItem(def);
Registered->setEditable(true);
Registered->setDuplicatesEnabled(false);
Registered->setCurrentIndex(0);
connect(Registered, SIGNAL(activated(int)), this, SLOT(add()));
toolbar->addWidget(Registered);
AddNames.insert(AddNames.end(), def);
addAct =
toolbar->addAction(QIcon(QPixmap(const_cast<const char**>(commit_xpm))),
tr("Register current"),
this,
SLOT(add()));
addAct->setShortcut(Qt::ALT + Qt::Key_R);
removeAct =
toolbar->addAction(QIcon(QPixmap(const_cast<const char**>(trash_xpm))),
tr("Remove registered"),
this,
SLOT(remove()));
removeAct->setShortcut(Qt::CTRL + Qt::Key_Backspace);
toolbar->addSeparator();
toolbar->addWidget(
new QLabel(tr("Name") + " ", toolbar));
toolbar->addWidget(
Name = new QLineEdit(toolbar));
Name->setText(def);
connect(Name, SIGNAL(returnPressed()), this, SLOT(send()));
toolbar->addWidget(
new QLabel(tr("Message") + " ", toolbar));
Message = new QLineEdit(toolbar);
connect(Message, SIGNAL(returnPressed()), this, SLOT(send()));
Message->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding,
QSizePolicy::Minimum));
toolbar->addWidget(Message);
memoEditAct =
toolbar->addAction(QIcon(QPixmap(const_cast<const char**>(toworksheet_xpm))),
tr("Edit message in memo"),
this,
SLOT(memo()));
memoEditAct->setShortcut(Qt::CTRL + Qt::Key_M);
sendAct =
toolbar->addAction(QIcon(QPixmap(const_cast<const char**>(return_xpm))),
tr("Send alert"),
this,
SLOT(send()));
sendAct->setShortcut(Qt::CTRL + Qt::Key_Return);
connect(&Timer, SIGNAL(timeout()), this, SLOT(poll()));
Timer.start(TIMEOUT*1000);
Alerts = new toListView(this);
Alerts->addColumn(tr("Time"));
Alerts->addColumn(tr("Name"));
Alerts->addColumn(tr("Message"));
layout()->addWidget(Alerts);
ToolMenu = NULL;
connect(toMainWidget()->workspace(), SIGNAL(subWindowActivated(QMdiSubWindow *)),
this, SLOT(windowActivated(QMdiSubWindow *)));
State = Started;
try
{
toThread *thread = new toThread(new pollTask(*this));
thread->start();
}
catch (...)
{
toStatusMessage(tr("Failed to start polling thread, try closing "
"some other tools and restart Alert Messenger"));
}
setFocusProxy(Message);
}
toBackup::toBackup(toTool* tool, QWidget *main, toConnection &connection)
: toToolWidget(*tool, "backup.html", main, connection, "toBackup")
, tool_(tool)
{
QToolBar *toolbar = toAllocBar(this, tr("Backup Manager"));
layout()->addWidget(toolbar);
updateAct = new QAction(QPixmap(const_cast<const char**>(refresh_xpm)),
tr("Update"), this);
updateAct->setShortcut(QKeySequence::Refresh);
connect(updateAct, SIGNAL(triggered()), this, SLOT(refresh(void)));
toolbar->addAction(updateAct);
toolbar->addWidget(new toSpacer());
new toChangeConnection(toolbar, TO_TOOLBAR_WIDGET_NAME);
Tabs = new QTabWidget(this);
layout()->addWidget(Tabs);
QWidget *box = new QWidget(Tabs);
QVBoxLayout *vbox = new QVBoxLayout;
vbox->setSpacing(0);
vbox->setContentsMargins(0, 0, 0, 0);
box->setLayout(vbox);
vbox->addWidget(new QLabel(tr("Logswitches per day and hour"), box));
LogSwitches = new toResultTableView(true, false, box);
LogSwitches->setSQL(SQLLogSwitches);
vbox->addWidget(LogSwitches);
Tabs->addTab(box, tr("Redo Switches"));
LogHistory = new toResultTableView(true, false, Tabs);
LogHistory->setSQL(SQLLogHistory);
Tabs->addTab(LogHistory, tr("Archived Logs"));
box = new QWidget(Tabs);
vbox = new QVBoxLayout;
vbox->setSpacing(0);
vbox->setContentsMargins(0, 0, 0, 0);
box->setLayout(vbox);
LastLabel = new QLabel(box);
vbox->addWidget(LastLabel);
LastBackup = new toResultTableView(true, false, box);
vbox->addWidget(LastBackup);
LastBackup->setSQL(SQLLastBackup);
Tabs->addTab(box, tr("Last Backup"));
CurrentBackup = new toResultTableView(true, false, Tabs);
CurrentBackup->setSQL(SQLCurrentBackup);
Tabs->addTab(CurrentBackup, tr("Backup Progress"));
ToolMenu = NULL;
connect(toMainWidget()->workspace(), SIGNAL(subWindowActivated(QMdiSubWindow *)),
this, SLOT(windowActivated(QMdiSubWindow *)));
refresh();
setFocusProxy(Tabs);
}
