Source: tomain.h

# Source: tomain.h |
Annotated List
Files
Globals
Hierarchy
Index

    /*****
     *
     * TOra - An Oracle Toolkit for DBA's and developers
     * Copyright (C) 2003-2005 Quest Software, Inc
     * Portions Copyright (C) 2005 Other Contributors
     *
     * This program is free software; you can redistribute it and/or
     * modify it under the terms of the GNU General Public License
     * as published by the Free Software Foundation;  only version 2 of
     * the License is valid for this program.
     *
     * This program is distributed in the hope that it will be useful,
     * but WITHOUT ANY WARRANTY; without even the implied warranty of
     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     * GNU General Public License for more details.
     *
     * You should have received a copy of the GNU General Public License
     * along with this program; if not, write to the Free Software
     * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
     *
     *      As a special exception, you have permission to link this program
     *      with the Oracle Client libraries and distribute executables, as long
     *      as you follow the requirements of the GNU GPL in regard to all of the
     *      software in the executable aside from Oracle client libraries.
     *
     *      Specifically you are not permitted to link this program with the
     *      Qt/UNIX, Qt/Windows or Qt Non Commercial products of TrollTech.
     *      And you are not permitted to distribute binaries compiled against
     *      these libraries without written consent from Quest Software, Inc.
     *      Observe that this does not disallow linking to the Qt Free Edition.
     *
     *      You may link this product with any GPL'd Qt library such as Qt/Free
     *
     * All trademarks belong to their respective owners.
     *
     *****/

    #ifndef TOMAIN_H
    #define TOMAIN_H

    #include "tobackground.h"

    #ifdef TO_KDE
    #include "tomainwindow.kde.h"
    #else
    #include "tomainwindow.h"
    #endif

    #include
    #include

    #include

    #if QT_VERSION >= 0x030000
    class QUrlOperator;
    #endif

    #define TOMessageBox QMessageBox

    class QComboBox;
    class QLabel;
    class QListView;
    class QListViewItem;
    class QNetworkOperation;
    class QPopupMenu;
    class QToolBar;
    class QToolButton;
    class QWorkspace;
    class toConnection;
    class toEditWidget;
    class toLineChart;
    class toMarkedText;
    class toSearchReplace;
    class toTool;
    class toToolWidget;

    /** This class defines the main window. Observe that this class will have different baseclass
     * depending on if TOra is a Qt or KDE application. In the case of Qt this will be a
     * QMainWindow descendant.
     */
    class toMain : public toMainWindow {
      Q_OBJECT
    private:
      /**
       * The connections that have been opened in TOra.
       */
      std::list Connections;
      /**
       * Workspace of main window.
       */
      QWorkspace *Workspace;
      /**
       * Handles available connections list in toolbar.
       */
      QComboBox *ConnectionSelection;
      /**
       * Add a new connection. The connection itself must already be created.
       * Returns the connection or it's duplicate already opened connection.
       */
      toConnection *addConnection(toConnection *conn,bool def=true);
      /**
       * A map from menu ID:s to tools.
       */
      std::map Tools;
      /**
       * A list of toolbuttons that need an open connection to be enabled.
       */
      std::map NeedConnection;
      /**
       * The ID of the tool providing the SQL editor.
       */
      int SQLEditor;

      /** Status messages to display
       */
      std::list StatusMessages;

      /**
       * Disconnect connection button.
       */
      QToolButton *DisconnectButton;
      /**
       * Load file button.
       */
      QToolButton *LoadButton;
      /**
       * Save file button.
       */
      QToolButton *SaveButton;
      /**
       * Print button.
       */
      QToolButton *PrintButton;
      /**
       * Undo button.
       */
      QToolButton *UndoButton;
      /**
       * Redo button.
       */
      QToolButton *RedoButton;
      /**
       * Cut button.
       */
      QToolButton *CutButton;
      /**
       * Copy button.
       */
      QToolButton *CopyButton;
      /**
       * Paste button.
       */
      QToolButton *PasteButton;
      /**
       * Paste button.
       */
      QToolButton *SearchButton;

      /**
       * Edit buttons toolbar.
       */
      QToolBar *EditToolbar;
      /**
       * Tool buttons toolbar.
       */
      QToolBar *ToolsToolbar;
      /**
       * Connection buttons toolbar.
       */
      QToolBar *ConnectionToolbar;

      /**
       * File menu.
       */
      QPopupMenu *FileMenu;
      /**
       * Edit menu.
       */
      QPopupMenu *EditMenu;
      /**
       * Tools menu.
       */
      QPopupMenu *ToolsMenu;
      /**
       * Windows menu.
       */
      QPopupMenu *WindowsMenu;
      /**
       * Help menu.
       */
      QPopupMenu *HelpMenu;
      /**
       * Display latest status messages
       */
      QPopupMenu *StatusMenu;
      /**
       * Current column label.
       */
      QLabel *ColumnLabel;
      /**
       * Current row label.
       */
      QLabel *RowLabel;
      toBackground Poll;
      /**
       * Search & replace dialog if available.
       */
      toSearchReplace *Search;
      /**
       * Default tool id
       */
      int DefaultTool;

      QTimer KeepAlive;

      toEditWidget *Edit;

      toEditWidget *findEdit(QWidget *edit);

      void updateRecent(void);

      void editEnable(toEditWidget *edit,
    		  bool open,bool save,bool print,
    		  bool undo,bool redo,
    		  bool cut,bool copy,bool paste,
    		  bool search,
    		  bool selectAll,bool readAll);
    public:

      /** ID of the file menu
       */
      static const int TO_FILE_MENU;
      /** ID of the edit menu
       */
      static const int TO_EDIT_MENU;
      /** ID of the tools menu
       */
      static const int TO_TOOLS_MENU;
      /** ID of the windows menu
       */
      static const int TO_WINDOWS_MENU;
      /** ID of the help menu
       */
      static const int TO_HELP_MENU;

      /** First ID of the tool specific menu items.
       */
      static const int TO_TOOL_MENU_ID;
      /** Last ID of the tool specific menu items.
       */
      static const int TO_TOOL_MENU_ID_END;

      /** First ID of the tool specific menu items.
       */
      static const int TO_LAST_FILE_ID;
      /** Last ID of the tool specific menu items.
       */
      static const int TO_LAST_FILE_ID_END;

      /** First ID of the tool specific about menu items.
       */
      static const int TO_TOOL_ABOUT_ID;
      /** Last ID of the tool specific about menu items.
       */
      static const int TO_TOOL_ABOUT_ID_END;

      /**
       * Create main window. Always NULL as parent.
       */
      toMain();

      /**
       * Get the workspace widget of the main window.
       * @return Workspace widget.
       */
      QWorkspace *workspace()
      { return Workspace; }

      /**
       * Get the current database connection
       * @return Reference to current connection.
       */
      toConnection ¤tConnection(void);

      /**
       * Set the widget to edit through menues and toolbar.
       */
      static void setEditWidget(toEditWidget *edit);
      /**
       * Set available menu items in user interface. It is not enough to just call
       * this function to make open for instance to actually work. It is a lot of
       * more especially in @ref commandCallback and @ref editFileMenu. Will only
       * update if this is the current editing widget.
       */
      static void editEnable(toEditWidget *edit);
      /**
       * Disable all the current available items in the user interface (That @ref
       * editEnable can enable). If specified widget has the focus the edit widget
       * is cleared.
       */
      static void editDisable(toEditWidget *edit);
      /** Get current edit widget
       */
      toEditWidget *editWidget()
      { return Edit; }

      /**
       * Close window
       * @param del If user interaction is allowed.
       * @return True if close was allowed, otherwise false.
       */
      virtual bool close(bool del);
      /**
       * Create the default tool for the current connection.
       *
       * This is the tool with the highest priority, usually the SQL worksheet.
       */
      void createDefault(void);
      /**
       * Set coordinates in the statusbar.
       *
       * Used to indicate current cursor position by child widgets.
       */
      void setCoordinates(int,int);

      /**
       * Get the file menu.
       * @return File menu
       */
      QPopupMenu *fileMenu()
      { return FileMenu; }
      /**
       * Get the edit menu.
       * @return Edit menu
       */
      QPopupMenu *editMenu()
      { return EditMenu; }
      /**
       * Get the tools menu.
       * @return Tools menu
       */
      QPopupMenu *toolsMenu()
      { return ToolsMenu; }
      /**
       * Get the help menu.
       * @return Help menu
       */
      QPopupMenu *helpMenu()
      { return HelpMenu; }

      /* Update the keepalive from configuration
       */
      void updateKeepAlive();

      /**
       * Get a list of currently open connections.
       * @return List of connection names. The returned list can then be used by
       * @ref connection to get the actual connection.
       */
      std::list connections(void);
      /** Get a connection identified by a string.
       * @return A reference to a connection.
       * @exception QString If connection wasn't found.
       */
      toConnection &connection(const QString &);
      /** Set if a connection needs to be commited. Also updates visual feedback in interface.
       */
      void setNeedCommit(toConnection &conn,bool needCommit=true);

      /** Edit an SQL statement in the SQL editor if any connected.
       * @param str Identifier of the SQL to edit.
       */
      void editSQL(const QString &str);
      /**
       * Register a tool which to use as an SQL editor. When something is to be edited
       * first a toolwindow will be created and the @ref sqlEditor will be emited, so
       * the SQL editor must connect to this signal as well.
       *
       * @param toolid Which tool identifier to register as the SQL editor. This
       *               is the value which is passed to the @ref toTool::customSetup
       *               member.
       */
      void registerSQLEditor(int toolid);

      /** Called by @ref toTool when a new tool is created.
       * @param tool The tool widget created.
       */
      void toolWidgetAdded(toToolWidget *tool);
      /** Called by @ref toToolWidget when a new tool is about to be destroyed.
       * @param tool The tool widget created.
       */
      void toolWidgetRemoved(toToolWidget *tool);

      /** Export data to a map.
       * @param data A map that can be used to recreate the session.
       * @param prefix Prefix to add to the map.
       */
      virtual void exportData(std::map &data,const QCString &prefix);
      /** Import data
       * @param data Data to read from a map.
       * @param prefix Prefix to read data from.
       */
      virtual void importData(std::map &data,const QCString &prefix);
      /** Get edit toolbar pointer.
       */
      QToolBar *editToolbar()
      { return EditToolbar; }
      /** Get connection toolbar pointer.
       */
      QToolBar *connectionToolbar()
      { return ConnectionToolbar; }
      /** Added chart.
       */
      void addChart(toLineChart *chart);
      /** Removed chart.
       */
      void removeChart(toLineChart *chart);
      /** Setup chart.
       */
      void setupChart(toLineChart *chart);
      /** Display status message in dialog.
       */
      void displayMessage(const QString &str);
      /** Add recent file
       */
      void addRecentFile(const QString &filename);
    signals:
      /** Invoked to start editing an SQL identifier.
       * @param str Identifier to start editing.
       */
      void sqlEditor(const QString &str);
      /** Invoked when a new chart is created.
       */
      void chartAdded(toLineChart *chart);
      /** Invoked before a chart is destroyed.
       */
      void chartSetup(toLineChart *chart);
      /** Invoked before a chart is destroyed.
       */
      void chartRemoved(toLineChart *chart);
      /** Invoked when a connection is added.
       * @param str Connection identifier.
       */
      void addedConnection(const QString &str);
      /** Invoked when a connection is removed.
       * @param str Connection identifier.
       */
      void removedConnection(const QString &str);
      /** Invoked when a tool window is created.
       * @param tool The tool created.
       */
      void addedToolWidget(toToolWidget *tool);
      /** Invoked when a tool window is closed.
       * @param tool Tool about to be removed.
       */
      void removedToolWidget(toToolWidget *tool);
      /** Emitted before a commit or rollback is made to the current connection.
       * @param conn Connection that is commited
       * @param cmt True if commit, false if rollback.
       */
      void willCommit(toConnection &conn,bool cmt);
    public slots:
      /** Used to enable/disable entries in the windows menu
       */
      void windowsMenu(void);
      /** Used to fill the status menu with the latest status entries
       */
      void statusMenu(void);
      /** Display context help.
       */
      void contextHelp(void);
      /** Called when active window is changed.
       */
      void windowActivated(QWidget *);
      /** Used to enable/disable entries in the file menu
       */
      void showFileMenu(void);
      /** Check if object caching is done.
       */
      void checkCaching(void);
      /** Save the current TOra session
       */
      void saveSession(void);
      /** Load a session (Merge with current)
       */
      void loadSession(void);
      /** Close all windows and connections.
       */
      void closeSession(void);
      /** Change current connection
       */
      void changeConnection(void);
    private slots:
      /** Add a connection
       */
      void addConnection(void);
      /** Remove a connection
       */
      bool delConnection(void);
      /** Handles menu selections
       * @param cmd Menu entry ID selected
       */
      void commandCallback(int cmd);

      /** Commit button pressed
       */
      void commitButton(void);
      /** Rollback button pressed
       */
      void rollbackButton(void);

      /** Load button pressed
       */
      void loadButton(void);
      /** Save button pressed
       */
      void saveButton(void);
      /** Print button pressed
       */
      void printButton(void);
      /** Options button pressed
       */
      void optionButton(void);
      /** Undo button pressed
       */
      void undoButton(void);
      /** Redo button pressed
       */
      void redoButton(void);
      /** Copy button pressed
       */
      void copyButton(void);
      /** Cut button pressed
       */
      void cutButton(void);
      /** Paste button pressed
       */
      void pasteButton(void);
      /** Paste button pressed
       */
      void searchButton(void);
      /** Stop running queries on connection
       */
      void stopButton(void);
      /** Display status message
       */
      void displayMessage(void);

      void keepAlive();
    };

    /** Get a pointer to the main window
     * @return Pointer to main window.
     */
    toMain *toMainWidget(void);

    #endif

Generated by: nneul on skyhawk on Wed Feb 23 19:49:58 2005, using kdoc 2.0a54.