Kwave::TopWidget Class Reference

#include <TopWidget.h>

Inheritance diagram for Kwave::TopWidget:

Collaboration diagram for Kwave::TopWidget:

Public Slots
void	updateRecentFiles ()
int	executeCommand (const QString &command)
int	forwardCommand (const QString &command)

Signals
void	sigFileContextSwitched (Kwave::FileContext *context)

Public Member Functions
	TopWidget (Kwave::App &app)
bool	init ()
virtual	~TopWidget () Q_DECL_OVERRIDE
QList< Kwave::App::FileAndInstance >	openFiles () const
Kwave::FileContext *	currentContext () const
QList< Kwave::FileContext * >	detachAllContexts ()
void	insertContext (Kwave::FileContext *context)
int	loadFile (const QUrl &url)

Protected Slots
virtual void	closeEvent (QCloseEvent *e) Q_DECL_OVERRIDE
virtual void	dragEnterEvent (QDragEnterEvent *event) Q_DECL_OVERRIDE
virtual void	dropEvent (QDropEvent *event) Q_DECL_OVERRIDE

Private Slots
void	metaDataChanged (Kwave::MetaDataList meta_data)
void	selectionChanged (sample_index_t offset, sample_index_t length)
void	setUndoRedoInfo (const QString &undo, const QString &redo)
void	clipboardChanged (bool data_available)
void	updateMenu ()
void	resetToolbarToDefaults ()
void	updateToolbar ()
void	toolbarRecord ()
void	toolbarFileNew ()
void	toolbarFileOpen ()
void	toolbarFileSave ()
void	toolbarFileSaveAs ()
void	toolbarFileClose ()
void	toolbarEditUndo ()
void	toolbarEditRedo ()
void	toolbarEditCut ()
void	toolbarEditCopy ()
void	toolbarEditPaste ()
void	toolbarEditErase ()
void	toolbarEditDelete ()
void	modifiedChanged ()
void	showInSplashSreen (const QString &message)
void	showStatusBarMessage (const QString &msg, unsigned int ms)
void	subWindowActivated (QMdiSubWindow *sub)
void	subWindowDeleted (QObject *obj)

Private Member Functions
int	newWindow (Kwave::FileContext *&context, const QUrl &url)
int	newSignal (sample_index_t samples, double rate, unsigned int bits, unsigned int tracks)
int	openFile ()
bool	closeAllSubWindows ()
int	openRecent (const QString &str)
void	updateCaption ()
void	connectContext (Kwave::FileContext *context)
Kwave::FileContext *	newFileContext ()

Private Attributes
Kwave::App &	m_application
QMap< QMdiSubWindow *, Kwave::FileContext * >	m_context_map
Kwave::PlayerToolBar *	m_toolbar_record_playback
Kwave::ZoomToolBar *	m_toolbar_zoom
Kwave::MenuManager *	m_menu_manager
QMdiArea *	m_mdi_area
QAction *	m_action_save
QAction *	m_action_save_as
QAction *	m_action_close
QAction *	m_action_undo
QAction *	m_action_redo
QAction *	m_action_cut
QAction *	m_action_copy
QAction *	m_action_erase
QAction *	m_action_delete
QLabel *	m_lbl_status_size
QLabel *	m_lbl_status_mode
QLabel *	m_lbl_status_cursor

Detailed Description

Toplevel widget of the Kwave application. Holds a main widget, a menu bar, a status bar and a toolbar.

Definition at line 62 of file TopWidget.h.

Constructor & Destructor Documentation

TopWidget()

Kwave::TopWidget::TopWidget ( Kwave::App &  app )

explicit

Constructor. Creates a new toplevel widget including menu bar, buttons, working are an s on.

Parameters

app	reference to the Kwave application instance

Definition at line 102 of file TopWidget.cpp.

References _, Kwave::App::cmdline(), m_application, m_lbl_status_cursor, m_lbl_status_mode, and m_lbl_status_size.

    :KMainWindow(),
     m_application(app),
     m_context_map(),
     m_toolbar_record_playback(Q_NULLPTR),
     m_toolbar_zoom(Q_NULLPTR),
     m_menu_manager(Q_NULLPTR),
     m_mdi_area(Q_NULLPTR),
     m_action_save(Q_NULLPTR),
     m_action_save_as(Q_NULLPTR),
     m_action_close(Q_NULLPTR),
     m_action_undo(Q_NULLPTR),
     m_action_redo(Q_NULLPTR),
     m_action_cut(Q_NULLPTR),
     m_action_copy(Q_NULLPTR),
     m_action_erase(Q_NULLPTR),
     m_action_delete(Q_NULLPTR),
     m_lbl_status_size(Q_NULLPTR),
     m_lbl_status_mode(Q_NULLPTR),
     m_lbl_status_cursor(Q_NULLPTR)
{
    // status bar items
    QStatusBar *status_bar = statusBar();
    Q_ASSERT(status_bar);
    if (!status_bar) return;

    QLabel *spacer = new QLabel(this);
    const int frame_style = QFrame::StyledPanel | QFrame::Sunken;
    status_bar->addWidget(spacer);
    spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
    spacer->setFrameStyle(frame_style);
    QSizePolicy policy = spacer->sizePolicy();
    policy.setHorizontalStretch(100);
    spacer->setSizePolicy(policy);
    policy.setHorizontalStretch(0);

    m_lbl_status_cursor = new QLabel(this);
    status_bar->addWidget(m_lbl_status_cursor);
    m_lbl_status_cursor->setSizePolicy(policy);
    m_lbl_status_cursor->setFrameStyle(frame_style);

    m_lbl_status_mode = new QLabel(this);
    status_bar->addWidget(m_lbl_status_mode);
    m_lbl_status_mode->setSizePolicy(policy);
    m_lbl_status_mode->setFrameStyle(frame_style);

    m_lbl_status_size = new QLabel(this);
    status_bar->addWidget(m_lbl_status_size);
    m_lbl_status_size->setSizePolicy(policy);
    m_lbl_status_size->setFrameStyle(frame_style);

    // start up iconified if requested
    const QCommandLineParser *args = m_application.cmdline();
    bool iconic = (args && args->isSet(_("iconic")));
    if (iconic) {
        showMinimized();
    }

    setAcceptDrops(true); // enable drag&drop

    // direct all kind of focus to this window per default
    setFocusPolicy(Qt::WheelFocus);
}

Here is the call graph for this function:

~TopWidget()

Kwave::TopWidget::~TopWidget ( )

virtual

Destructor.

Definition at line 480 of file TopWidget.cpp.

References closeAllSubWindows(), m_application, m_context_map, m_menu_manager, m_toolbar_record_playback, m_toolbar_zoom, and Kwave::App::toplevelWindowHasClosed().

{
    // close the current file (no matter what the user wants)
    closeAllSubWindows();

    delete m_toolbar_zoom;
    m_toolbar_zoom = Q_NULLPTR;

    delete m_toolbar_record_playback;
    m_toolbar_record_playback = Q_NULLPTR;

    delete m_menu_manager;
    m_menu_manager = Q_NULLPTR;

    while (!m_context_map.isEmpty()) {
        Kwave::FileContext *context = m_context_map.values().last();
        m_context_map.remove(m_context_map.keys().last());
        if (context) delete context;
    }

    m_application.toplevelWindowHasClosed(this);
}

Here is the call graph for this function:

Member Function Documentation

clipboardChanged

void Kwave::TopWidget::clipboardChanged ( bool  data_available )

privateslot

updates the menus when the clipboard has become empty/full

Definition at line 1293 of file TopWidget.cpp.

References _, m_menu_manager, and Kwave::MenuManager::setItemEnabled().

Referenced by init(), and updateMenu().

{
    if (!m_menu_manager) return;
    m_menu_manager->setItemEnabled(_("@CLIPBOARD"), data_available);
}

Here is the call graph for this function:

Here is the caller graph for this function:

closeAllSubWindows()

bool Kwave::TopWidget::closeAllSubWindows ( )

private

Close all the currently opened sub windows

Returns

true if closing is allowed

Definition at line 887 of file TopWidget.cpp.

References Kwave::FileContext::closeFile(), and m_context_map.

Referenced by closeEvent(), and ~TopWidget().

{
    bool allowed = true;

    QMutableMapIterator<QMdiSubWindow *, Kwave::FileContext *>
        it(m_context_map);
    it.toBack();
    while (it.hasPrevious()) {
        it.previous();
        QMdiSubWindow      *sub     = it.key();
        Kwave::FileContext *context = it.value();

        if (!sub) {
            // reached the default context (without sub windows)
            // or SDI mode with only one context
            if (context) allowed &= context->closeFile();
            break;
        }

        if (!context) {
            // invalid entry?
            it.remove();
            continue;
        }

        // try to close the sub window / context
        if (!sub->close()) {
            allowed = false;
            break;
        } else {
            it.remove();
            if (m_context_map.isEmpty()) {
                // keep the default context, without a window
                m_context_map[Q_NULLPTR] = context;
                break;
            }
        }
    }

    return allowed;
}

Here is the call graph for this function:

Here is the caller graph for this function:

closeEvent

void Kwave::TopWidget::closeEvent ( QCloseEvent *  e )

protectedvirtualslot

See also

QWidget::closeEvent()

Definition at line 1541 of file TopWidget.cpp.

References closeAllSubWindows().

{
    (closeAllSubWindows()) ? e->accept() : e->ignore();
}

Here is the call graph for this function:

connectContext()

void Kwave::TopWidget::connectContext ( Kwave::FileContext *  context )

private

Establishes all signal/slot connections between a context and this instance, including toolbars etc.

Definition at line 167 of file TopWidget.cpp.

References Kwave::connect(), m_toolbar_record_playback, m_toolbar_zoom, metaDataChanged(), modifiedChanged(), selectionChanged(), setUndoRedoInfo(), and showStatusBarMessage().

Referenced by insertContext(), and newFileContext().

{
    // connect the context to the top widget
    connect(context, SIGNAL(sigMetaDataChanged(Kwave::MetaDataList)),
            this,         SLOT(metaDataChanged(Kwave::MetaDataList)));
    connect(context,
            SIGNAL(sigSelectionChanged(sample_index_t,sample_index_t)),
            this,
            SLOT(selectionChanged(sample_index_t,sample_index_t)));
    connect(context, SIGNAL(sigUndoRedoInfo(QString,QString)),
            this,      SLOT(setUndoRedoInfo(QString,QString)));
    connect(context, SIGNAL(sigModified()),
            this,      SLOT(modifiedChanged()));

    // connect the zoom toolbar
    connect(context,   SIGNAL(sigZoomChanged(Kwave::FileContext*,double)),
            m_toolbar_zoom, SLOT(setZoomInfo(Kwave::FileContext*,double)));
    connect(context,             SIGNAL(destroyed(Kwave::FileContext*)),
            m_toolbar_zoom, SLOT(contextDestroyed(Kwave::FileContext*)));

    // connect the playback/record toolbar
    connect(context,
            SIGNAL(destroyed(Kwave::FileContext*)),
            m_toolbar_record_playback,
            SLOT(contextDestroyed(Kwave::FileContext*))
    );
    connect(context, SIGNAL(sigMetaDataChanged(Kwave::MetaDataList)),
            m_toolbar_record_playback,
            SLOT(metaDataChanged(Kwave::MetaDataList)));

    // connect the status bar
    connect(context, SIGNAL(sigStatusBarMessage(QString,uint)),
            this,    SLOT(showStatusBarMessage(QString,uint)));
}

Here is the call graph for this function:

Here is the caller graph for this function:

currentContext()

Kwave::FileContext * Kwave::TopWidget::currentContext

(

)

const

Returns the currently active file context (corresponds to a MDI sub window or tab in MDI / TAB mode). In SDI mode, m_context_map contains only one element, the current context (reachable per index null).

Returns

pointer to a active FileContext within m_context_map

Definition at line 232 of file TopWidget.cpp.

References m_context_map, and m_mdi_area.

Referenced by forwardCommand(), loadFile(), newSignal(), selectionChanged(), subWindowActivated(), updateCaption(), updateMenu(), and updateToolbar().

{
    if (m_context_map.isEmpty()) return Q_NULLPTR;

    if (m_context_map.contains(Q_NULLPTR)) {
        // the "null" entry is special, it has precedence over all
        // other entries. In SDI mode it is the only one ever and in
        // MDI/TAB mode it is used for a context that has no sub
        // window yet.
        return m_context_map[Q_NULLPTR];
    }

    if (m_mdi_area) {
        // MDI or TAB mode
        QMdiSubWindow *current_sub = m_mdi_area->currentSubWindow();
        if (!m_context_map.contains(current_sub)) {
            qWarning("WARNING: unassociated MDI sub window %p?",
                     static_cast<void *>(current_sub));
            QMapIterator<QMdiSubWindow*, Kwave::FileContext*> it(m_context_map);
            Kwave::FileContext *context = Q_NULLPTR;
            while (it.hasNext()) {
                it.next();
                context = it.value();
            }
            return (m_context_map.count() == 1) ? context : Q_NULLPTR;
        }
        return m_context_map[current_sub];
    } else {
        // SDI mode
        Q_ASSERT(0 && "SDI mode but no context?");
        return Q_NULLPTR;
    }
}

Here is the caller graph for this function:

detachAllContexts()

QList< Kwave::FileContext * > Kwave::TopWidget::detachAllContexts

(

)

Detaches all file contexts from this instance

Returns

a list of Kwave::FileContext pointers (non-null)

Definition at line 520 of file TopWidget.cpp.

References Kwave::FileContext::isInUse(), m_context_map, m_mdi_area, Kwave::FileContext::release(), Kwave::FileContext::setParent(), and sigFileContextSwitched().

Referenced by Kwave::App::switchGuiType().

{
    QList<Kwave::FileContext *> list;

    QMutableMapIterator<QMdiSubWindow *, Kwave::FileContext *> i(m_context_map);
    while (i.hasNext()) {
        i.next();
        QMdiSubWindow      *sub     = i.key();
        Kwave::FileContext *context = i.value();

        // remove the entry from the map to prevent damage
        i.remove();

        if (sub) {
            // leave the "minimized" state before migration
            Qt::WindowStates state = sub->windowState();
            if (state & Qt::WindowMinimized)
            {
                state &= ~Qt::WindowMinimized;
                sub->setWindowState(state);
                sub->showNormal();
            }

            // detach the main widget from the MDI sub window
            sub->setWidget(Q_NULLPTR);
            delete sub;
        }

        // detach the context from this parent widget
        if (context) {
            context->disconnect();
            context->setParent(Q_NULLPTR);
            if (context->isInUse())
                list += context;    // in use -> keep
            else
                context->release(); // empty -> release
        }
    }

    // get rid of the MDI area, it should be empty now
    setCentralWidget(Q_NULLPTR);
    if (m_mdi_area) {
        delete m_mdi_area;
        m_mdi_area = Q_NULLPTR;
    }

    emit sigFileContextSwitched(Q_NULLPTR);

    return list;
}

Here is the call graph for this function:

Here is the caller graph for this function:

dragEnterEvent

void Kwave::TopWidget::dragEnterEvent ( QDragEnterEvent *  event )

protectedvirtualslot

See also

Qt XDND documentation

Definition at line 1597 of file TopWidget.cpp.

References Kwave::FileDrag::canDecode().

{
    if (!event) return;
    if ((event->proposedAction() != Qt::MoveAction) &&
        (event->proposedAction() != Qt::CopyAction))
        return; /* unsupported action */

    if (Kwave::FileDrag::canDecode(event->mimeData()))
        event->acceptProposedAction();
}

Here is the call graph for this function:

dropEvent

void Kwave::TopWidget::dropEvent ( QDropEvent *  event )

protectedvirtualslot

For dropping data into an empty signal

See also

Qt XDND documentation

Definition at line 1609 of file TopWidget.cpp.

References _, Kwave::CodecManager::canDecode(), Kwave::Parser::escape(), forwardCommand(), and Kwave::CodecManager::mimeTypeOf().

{
    if (!event) return;
    if (!event->mimeData()) return;

    if (event->mimeData()->hasUrls()) {
        bool first = true;
        foreach (const QUrl &url, event->mimeData()->urls()) {
            QString filename = url.toLocalFile();
            QString mimetype = Kwave::CodecManager::mimeTypeOf(url);
            if (Kwave::CodecManager::canDecode(mimetype)) {
                if (first) {
                    // first dropped URL -> open in this window
                    forwardCommand(_("open(%1)").arg(
                        Kwave::Parser::escape(filename)));
                    first = false;
                } else {
                    // all others -> open a new window
                    forwardCommand(_("newwindow(%1)").arg(
                        Kwave::Parser::escape(filename)));
                }
            }
        }
    }
}

Here is the call graph for this function:

executeCommand

int Kwave::TopWidget::executeCommand ( const QString &  command )

slot

Execute a Kwave text command

Parameters

command

a text command

Return values

0	if succeeded
negative	error code if failed
ENOSYS	if the command is unknown in this component

Definition at line 706 of file TopWidget.cpp.

References _, CASE_COMMAND, Kwave::Parser::command(), Kwave::MenuManager::executeCommand(), Kwave::PlayerToolBar::executeCommand(), Kwave::App::executeCommand(), Kwave::Parser::firstParam(), Kwave::App::GUI_MDI, Kwave::App::GUI_SDI, Kwave::App::GUI_TAB, Kwave::App::guiType(), loadFile(), m_application, m_context_map, m_mdi_area, m_menu_manager, m_toolbar_record_playback, newSignal(), Kwave::Parser::nextParam(), openFile(), openRecent(), Kwave::MessageBox::questionYesNo(), resetToolbarToDefaults(), Kwave::App::switchGuiType(), Kwave::Parser::toDouble(), Kwave::Parser::toSampleIndex(), Kwave::Parser::toUInt(), and Kwave::FileContext::windowCaption().

Referenced by loadFile().

{
    int result = 0;
    QString command = line;

//     qDebug("TopWidget::executeCommand(%s)", DBG(command));
    if (!command.length()) return 0; // empty line -> nothing to do

    // parse one single command
    Kwave::Parser parser(command);

    // playback commands are always possible
    if ( (parser.command() == _("playback")) && (m_toolbar_record_playback) )
        return m_toolbar_record_playback->executeCommand(parser.firstParam());

    if ((result = m_application.executeCommand(command)) != ENOSYS)
        return result;
    result = 0;
    if (false) {
    CASE_COMMAND("about_kde")
        // Help / About KDE
        KHelpMenu *dlg = new KHelpMenu(this, _("Kwave"));
        if (dlg) dlg->aboutKDE();
        result = 0;
    CASE_COMMAND("menu")
        Q_ASSERT(m_menu_manager);
        if (m_menu_manager) result = m_menu_manager->executeCommand(command);
    CASE_COMMAND("newsignal")
        sample_index_t samples = parser.toSampleIndex();
        double         rate    = parser.toDouble();
        unsigned int   bits    = parser.toUInt();
        unsigned int   tracks  = parser.toUInt();
        result = newSignal(samples, rate, bits, tracks);
    CASE_COMMAND("open")
        QString filename = parser.nextParam();
        if (!filename.isEmpty()) {
            // open the selected file
            result = loadFile(QUrl::fromUserInput(filename));
        } else {
            // show file open dialog
            result = openFile();
        }
    CASE_COMMAND("openrecent")
        result = openRecent(command);
    CASE_COMMAND("quit")
        result = (close()) ? 0 : -1;
    CASE_COMMAND("reset_toolbars")
        if ((result = (Kwave::MessageBox::questionYesNo(this,
            i18n("Reset the toolbar to default settings?"))
            == KMessageBox::Yes) ? 1 : 0))
        {
            resetToolbarToDefaults();
        }
        result = 0;
    CASE_COMMAND("select_gui_type")
        QString gui_type = parser.nextParam();
        Kwave::App::GuiType new_type = Kwave::App::GUI_SDI;

        if (gui_type == _("SDI"))
            new_type = Kwave::App::GUI_SDI;
        else if (gui_type == _("MDI"))
            new_type = Kwave::App::GUI_MDI;
        else if (gui_type == _("TAB"))
            new_type = Kwave::App::GUI_TAB;
        else
            return -1;

        KConfigGroup cfg = KSharedConfig::openConfig()->group("Global");
        cfg.writeEntry(_("UI Type"), gui_type);
        m_application.switchGuiType(this, new_type);
        result = 0;
    CASE_COMMAND("reenable_dna")
        if ((result = (Kwave::MessageBox::questionYesNo(this,
            i18n("Re-enable all disabled notifications?\n"
                 "All messages that you previously turned off by activating "
                 "the \"Do not ask again\" checkbox will then be enabled again."
            ))
            == KMessageBox::Yes) ? 1 : 0))
        {
            KMessageBox::enableAllMessages();
        }
        result = 0;
    CASE_COMMAND("window:minimize")
        if (m_application.guiType() == Kwave::App::GUI_MDI) {
            // in case of MDI mode: minimize the current sub window
            if (m_mdi_area) {
                QMdiSubWindow *sub = m_mdi_area->activeSubWindow();
                if (!sub) return -1;
                sub->setWindowState(windowState() | Qt::WindowMinimized);
            }
        } else {
            // in case of TAB or SDI mode: minimize the toplevel window
            setWindowState(windowState() | Qt::WindowMinimized);
        }
        result = 0;
    CASE_COMMAND("window:next_sub")
        if (m_mdi_area) m_mdi_area->activateNextSubWindow();
        result = 0;
    CASE_COMMAND("window:prev_sub")
        if (m_mdi_area) m_mdi_area->activatePreviousSubWindow();
        result = 0;
    CASE_COMMAND("window:cascade")
        if (m_mdi_area) m_mdi_area->cascadeSubWindows();
        result = 0;
    CASE_COMMAND("window:tile")
        if (m_mdi_area) m_mdi_area->tileSubWindows();
        result = 0;
    CASE_COMMAND("window:tile_vertical")
        if (!m_mdi_area) return 0;

        // determine the number of not minimized sub windows
        int count = 0;
        foreach (QMdiSubWindow *sub, m_mdi_area->subWindowList()) {
            if (sub && !(sub->windowState() & Qt::WindowMinimized))
                ++count;
        }
        if (!count) return 0;

        int total_height = m_mdi_area->height();
        int width = m_mdi_area->width();
        int height = total_height / count;
        int increment = height;
        int y = 0;
        foreach (QMdiSubWindow *sub, m_mdi_area->subWindowList()) {
            if (!sub || (sub->windowState() & Qt::WindowMinimized))
                continue;
            // resize/move the sub window
            sub->resize(width, height);
            sub->move(0, y);
            y += increment;
        }
        result = 0;

    CASE_COMMAND("window:activate")
        if (m_mdi_area) {
            QString title = parser.nextParam();
            foreach (QMdiSubWindow *sub, m_context_map.keys()) {
                if (!sub) continue;
                Kwave::FileContext *context = m_context_map[sub];
                if (!context) continue;

                // identify the window by it's title
                if (context->windowCaption(false) == title) {
                    // activate the sub window if it is not the active one
                    if (m_mdi_area->activeSubWindow() != sub)
                        m_mdi_area->setActiveSubWindow(sub);

                    // leave the "minimized" state if necessary
                    Qt::WindowStates state = sub->windowState();
                    if (state & Qt::WindowMinimized)
                        sub->setWindowState(state & ~(Qt::WindowMinimized));
                    sub->raise();
                    return 0;
                }
            }
        } else return ENOSYS;
        return EINVAL;
    } else {
        return ENOSYS; // command not implemented (here)
    }

    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

forwardCommand

int Kwave::TopWidget::forwardCommand ( const QString &  command )

slot

forward a Kwave text command coming from an upper layer to the currently active context below us (which is the main entry point for all text commands)

Parameters

command

a text command

Return values

0	if succeeded
negative	error code if failed
EAGAIN	if there is no "current" context (yet)
ENOSYS	if the command is unknown in this component

Definition at line 871 of file TopWidget.cpp.

References currentContext(), Kwave::FileContext::executeCommand(), Kwave::FileContext::pluginManager(), and Kwave::PluginManager::sync().

Referenced by dropEvent(), and init().

{
    Kwave::FileContext *context = currentContext();
    if (!context) return EAGAIN;

    // execute the command in the current context
    int retval = context->executeCommand(command);

    // synchronize after the command
    Kwave::PluginManager *plugin_manager = context->pluginManager();
    if (plugin_manager) plugin_manager->sync();

    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

init()

bool Kwave::TopWidget::init

(

)

Does some initialization at startup of the instance

Return values

true	if this instance was successfully initialized
false	if something went wrong during initialization

Definition at line 267 of file TopWidget.cpp.

References _, clipboardChanged(), Kwave::connect(), Kwave::FileContext::createMainWidget(), forwardCommand(), Kwave::App::GUI_MDI, Kwave::App::GUI_SDI, Kwave::App::GUI_TAB, Kwave::App::guiType(), Kwave::ClipBoard::instance(), m_action_close, m_action_copy, m_action_cut, m_action_delete, m_action_erase, m_action_redo, m_action_save, m_action_save_as, m_action_undo, m_application, m_mdi_area, m_menu_manager, m_toolbar_record_playback, m_toolbar_zoom, Kwave::FileContext::mainWidget(), metaDataChanged(), newFileContext(), resetToolbarToDefaults(), selectionChanged(), setUndoRedoInfo(), showInSplashSreen(), sigFileContextSwitched(), subWindowActivated(), TOOLBAR_EDIT, TOOLBAR_FILE, TOOLBAR_RECORD_PLAY, TOOLBAR_ZOOM, toolbarEditCopy(), toolbarEditCut(), toolbarEditDelete(), toolbarEditErase(), toolbarEditPaste(), toolbarEditRedo(), toolbarEditUndo(), toolbarFileClose(), toolbarFileNew(), toolbarFileOpen(), toolbarFileSave(), toolbarFileSaveAs(), updateMenu(), updateRecentFiles(), and updateToolbar().

Referenced by Kwave::App::newWindow(), and Kwave::App::switchGuiType().

{
    showInSplashSreen(i18n("Loading main menu..."));
    QMenuBar *menubar = menuBar();
    Q_ASSERT(menubar);
    if (!menubar) return false;
    m_menu_manager = new(std::nothrow) Kwave::MenuManager(this, *menubar);
    Q_ASSERT(m_menu_manager);
    if (!m_menu_manager) return false;

    // connect clicked menu entries with main communication channel of kwave
    connect(m_menu_manager, SIGNAL(sigMenuCommand(QString)),
            this, SLOT(forwardCommand(QString)));
    connect(&Kwave::ClipBoard::instance(), SIGNAL(clipboardChanged(bool)),
            this, SLOT(clipboardChanged(bool)));

    // --- zoom control toolbar ---

    m_toolbar_zoom = new(std::nothrow) Kwave::ZoomToolBar(this, TOOLBAR_ZOOM);
    Q_ASSERT(m_toolbar_zoom);
    if (!m_toolbar_zoom) return false;

    connect(this,  SIGNAL(sigFileContextSwitched(Kwave::FileContext*)),
            m_toolbar_zoom, SLOT(contextSwitched(Kwave::FileContext*)));

    // --- playback control toolbar ---
    m_toolbar_record_playback = new(std::nothrow) Kwave::PlayerToolBar(
        this, TOOLBAR_RECORD_PLAY, *m_menu_manager);
    Q_ASSERT(m_toolbar_record_playback);
    if (!m_toolbar_record_playback) return false;

    connect(this,  SIGNAL(sigFileContextSwitched(Kwave::FileContext*)),
            m_toolbar_record_playback,
            SLOT(contextSwitched(Kwave::FileContext*)));
    connect(m_toolbar_record_playback, SIGNAL(sigCommand(QString)),
            this,                    SLOT(forwardCommand(QString)));

    // -- create a new file context ---
    Kwave::FileContext *context = newFileContext();
    if (!context) return false;

    QWidget *central_widget = Q_NULLPTR;
    switch (m_application.guiType()) {
        case Kwave::App::GUI_SDI:
            // create a main widget
            if (!context->createMainWidget(geometry().size() * 0.85))
                return false;
            central_widget = context->mainWidget();
            break;
        case Kwave::App::GUI_MDI:
            // create a MDI area if required, MDI mode
            m_mdi_area = new(std::nothrow) QMdiArea(this);
            Q_ASSERT(m_mdi_area);
            if (!m_mdi_area) return false;
            m_mdi_area->setViewMode(QMdiArea::SubWindowView);
            break;
        case Kwave::App::GUI_TAB:
            // create a MDI area if required, TAB mode
            m_mdi_area = new(std::nothrow) QMdiArea(this);
            Q_ASSERT(m_mdi_area);
            if (!m_mdi_area) return false;
            m_mdi_area->setViewMode(QMdiArea::TabbedView);
            m_mdi_area->setTabsClosable(true);
            m_mdi_area->setTabsMovable(true);
            break;
    }

    if (m_mdi_area) {
        connect(m_mdi_area, SIGNAL(subWindowActivated(QMdiSubWindow*)),
                this,       SLOT(subWindowActivated(QMdiSubWindow*)) );
        central_widget = m_mdi_area;
    }

    // --- set up the toolbar ---

    showInSplashSreen(i18n("Initializing toolbar..."));
    KToolBar *toolbar_file = toolBar(TOOLBAR_FILE);
    Q_ASSERT(toolbar_file);
    if (!toolbar_file) return false;

    // --- file open and save ---

    toolbar_file->addAction(
        QIcon::fromTheme(_("document-new")),
        i18n("Create a new empty file"),
        this, SLOT(toolbarFileNew()));

    toolbar_file->addAction(
        QIcon::fromTheme(_("document-open")),
        i18n("Open an existing file"),
        this, SLOT(toolbarFileOpen()));

    m_action_save = toolbar_file->addAction(
        QIcon::fromTheme(_("document-save")),
        i18n("Save the current file"),
        this, SLOT(toolbarFileSave()));

    m_action_save_as = toolbar_file->addAction(
        QIcon::fromTheme(_("document-save-as")),
        i18n("Save the current file under a different name or file format..."),
        this, SLOT(toolbarFileSaveAs()));

    m_action_close = toolbar_file->addAction(
        QIcon::fromTheme(_("document-close")),
        i18n("Close the current file"),
        this, SLOT(toolbarFileClose()));

    // --- edit, cut&paste ---

    KToolBar *toolbar_edit = toolBar(TOOLBAR_EDIT);
    Q_ASSERT(toolbar_edit);
    if (!toolbar_edit) return false;

    m_action_undo = toolbar_edit->addAction(
        QIcon::fromTheme(_("edit-undo")),
        i18n("Undo"),
        this, SLOT(toolbarEditUndo()));

    m_action_redo = toolbar_edit->addAction(
        QIcon::fromTheme(_("edit-redo")),
        i18n("Redo"),
        this, SLOT(toolbarEditRedo()));

    m_action_cut = toolbar_edit->addAction(
        QIcon::fromTheme(_("edit-cut")),
        i18n("Cut"),
        this, SLOT(toolbarEditCut()));

    m_action_copy = toolbar_edit->addAction(
        QIcon::fromTheme(_("edit-copy")),
        i18n("Copy"),
        this, SLOT(toolbarEditCopy()));

    QAction *btPaste = toolbar_edit->addAction(
        QIcon::fromTheme(_("edit-paste")),
        i18n("Insert"),
        this, SLOT(toolbarEditPaste()));
    btPaste->setEnabled(!Kwave::ClipBoard::instance().isEmpty());
    connect(&Kwave::ClipBoard::instance(), SIGNAL(clipboardChanged(bool)),
            btPaste, SLOT(setEnabled(bool)));

    m_action_erase = toolbar_edit->addAction(
        QIcon::fromTheme(_("draw-eraser")),
        i18n("Mute selection"),
        this, SLOT(toolbarEditErase()));

    m_action_delete = toolbar_edit->addAction(
        QIcon::fromTheme(_("edit-delete")),
        i18n("Delete selection"),
        this, SLOT(toolbarEditDelete()));

    // set up the relationship between top widget / mdi area / main widget
    Q_ASSERT(central_widget);
    if (!central_widget)
        return false;

    setCentralWidget(central_widget);

    // set a nice initial size of the toplevel window
    int w = central_widget->minimumSize().width();
    w = qMax(w, central_widget->sizeHint().width());
    w = qMax(w, width());
    int h = qMax(central_widget->sizeHint().height(), (w * 6) / 10);
    h = qMax(h, height());
    resize(w, h);

    metaDataChanged(Kwave::MetaDataList());
    setUndoRedoInfo(QString(), QString());
    selectionChanged(0, 0);
    updateMenu();
    updateToolbar();
    updateRecentFiles();

    // make sure that everything of our window is visible
    QRect desk = qApp->desktop()->rect();
    QRect g    = this->geometry();
    if (!desk.contains(g)) {
        // KDE's stupid geometry management has failed ?
        // this happens when one passes "-geometry <WIDTH>x<HEIGHT>" without
        // specifying a target position!?
        // passing "-geometry <WIDTH>x<HEIGHT>-<LEFT>-<TOP>" works...
        g = desk.intersected(g);
        setGeometry(g);
    }

    // enable saving of window size and position for next startup
    setAutoSaveSettings();

    // workaround for KDE4: detect first startup and set all toolbars
    // to "only symbols" mode
    KConfigGroup cfg = KSharedConfig::openConfig()->group("MainWindow");
    QString magic = _("3");
    if (cfg.readEntry("toolbars") != magic) {
        qDebug("toolbar layout changed => resetting toolbars to defaults");

        // unlock all toolbars
        KToolBar::setToolBarsLocked(false);

        // reset all toolbars to default layout
        resetToolbarToDefaults();

        cfg.writeEntry("toolbars", magic);
    }

    // make sure we have the focus, not the zoom combo box
    setFocus();

    // special handling: a null string tells the splash screen to hide
    showInSplashSreen(QString());
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

insertContext()

void Kwave::TopWidget::insertContext

(

Kwave::FileContext *

context

)

Insert a new file context into this instance

Parameters

context

the new file context

Definition at line 572 of file TopWidget.cpp.

References Kwave::connect(), connectContext(), Kwave::FileContext::createMainWidget(), Kwave::App::GUI_MDI, Kwave::App::GUI_SDI, Kwave::App::GUI_TAB, Kwave::App::guiType(), m_application, m_context_map, m_mdi_area, Kwave::FileContext::mainWidget(), newFileContext(), Kwave::FileContext::release(), Kwave::FileContext::setParent(), sigFileContextSwitched(), subWindowActivated(), subWindowDeleted(), updateCaption(), updateMenu(), updateToolbar(), and Kwave::FileContext::windowCaption().

Referenced by newWindow(), and Kwave::App::switchGuiType().

{
    // if no context was given: create a new empty default context
    if (!context) {
        context = newFileContext();
        Q_ASSERT(context);
        if (!context) return;
        if ( (m_application.guiType() == Kwave::App::GUI_SDI) &&
             !context->mainWidget() )
        {
            context->createMainWidget(geometry().size() * 0.85);
        }
        // prevent it from getting removed again
        m_context_map.remove(Q_NULLPTR);
    }

    switch (m_application.guiType()) {
        case Kwave::App::GUI_SDI:
            // we may have an empty default context -> get rid of it
            Q_ASSERT(m_context_map.count() <= 1);
            if (!m_context_map.isEmpty()) {
                Kwave::FileContext *ctx = m_context_map[Q_NULLPTR];
                m_context_map.remove(Q_NULLPTR);
                if (ctx) ctx->release();
            }
            // take over the new context
            m_context_map[Q_NULLPTR] = context;
            connectContext(context);
            context->setParent(this);

            // set the central widget to the new main widget
            setCentralWidget(context->mainWidget());
            break;
        case Kwave::App::GUI_MDI:
            if (!m_mdi_area) {
                // create a MDI area if required, MDI mode
                m_mdi_area = new(std::nothrow) QMdiArea(this);
                Q_ASSERT(m_mdi_area);
                if (!m_mdi_area) return;
                m_mdi_area->setViewMode(QMdiArea::SubWindowView);
            }
            /* FALLTHROUGH */
        case Kwave::App::GUI_TAB: {
            // create a MDI area if required, TAB mode
            if (!m_mdi_area) {
                m_mdi_area = new(std::nothrow) QMdiArea(this);
                Q_ASSERT(m_mdi_area);
                if (!m_mdi_area) return;
                m_mdi_area->setViewMode(QMdiArea::TabbedView);
                m_mdi_area->setTabsClosable(true);
                m_mdi_area->setTabsMovable(true);
            }

            context->setParent(this);
            setCentralWidget(m_mdi_area);

            connect(m_mdi_area, SIGNAL(subWindowActivated(QMdiSubWindow*)),
                    this,       SLOT(subWindowActivated(QMdiSubWindow*)) );

            QWidget *main_widget = context->mainWidget();
            if (main_widget) {
                QMdiSubWindow *sub = m_mdi_area->addSubWindow(
                    main_widget, Qt::SubWindow);
                Q_ASSERT(sub);
                if (!sub) return;
                sub->adjustSize();

                if (m_context_map.contains(Q_NULLPTR))
                    m_context_map.remove(Q_NULLPTR);
                m_context_map[sub] = context;

                connect(context->mainWidget(), SIGNAL(destroyed(QObject*)),
                        sub,                   SLOT(close()));
                connect(sub,  SIGNAL(destroyed(QObject*)),
                        this, SLOT(subWindowDeleted(QObject*)));
                connectContext(context);

                if (m_application.guiType() != Kwave::App::GUI_SDI) {
                    // this really sucks...
                    // Qt adds a "Close" entry to the MDI subwindow's system
                    // menu, with the shortcut "Ctrl+W". This collides with
                    // our own shortcut, produces a warning and makes the
                    // shortcut key not work:
                    // QAction::eventFilter: Ambiguous shortcut overload: Ctrl+W
                    QMenu *m = sub->systemMenu();
                    if (m) {
                        foreach (QAction *act, m->actions())
                            if (act) act->setShortcut(0); // remove shortcut
                    }
                }

                sub->setAttribute(Qt::WA_DeleteOnClose);
                main_widget->setWindowTitle(context->windowCaption(true));

                // workaround for stupid bug in Qt: when having only one
                // single sub window, switching to tab mode shows a tab +
                // a sub window with frame and title (not maximized within
                // the mdi area)
                Qt::WindowStates state = sub->windowState();
                if (m_application.guiType() == Kwave::App::GUI_TAB)
                {
                    state |=  Qt::WindowMaximized;
                    sub->setWindowState(state);
                    sub->show();
                }
                else
                {
                    state &= ~Qt::WindowMaximized;
                    sub->setWindowState(state);
                    sub->showNormal();
                }

                // NOTE: we have to mark the sub window as "not hidden",
                // otherwise currentSubWindow() would return a null pointer!
                sub->setHidden(false);
                m_mdi_area->setActiveSubWindow(sub);
            } else {
                m_context_map[Q_NULLPTR] = context; // set empty default context
            }

            break;
        }
    }

    // update the menu bar, toolbar etc.
    emit sigFileContextSwitched(Q_NULLPTR);
    emit sigFileContextSwitched(context);
    updateMenu();
    updateToolbar();
    updateCaption();

}

Here is the call graph for this function:

Here is the caller graph for this function:

loadFile()

int Kwave::TopWidget::loadFile

(

const QUrl &

url

)

Loads a new file and updates the widget's title, menu, status bar and so on.

Parameters

url	URL of the file to be loaded

Returns

0 if successful

Definition at line 991 of file TopWidget.cpp.

References _, Kwave::App::addRecentFile(), Kwave::FileContext::closeFile(), currentContext(), Kwave::MessageBox::error(), executeCommand(), Kwave::FileContext::executeCommand(), Kwave::Parser::fromUrl(), Kwave::Logger::Info, Kwave::FileContext::loadBatch(), Kwave::SignalManager::loadFile(), Kwave::Logger::log(), m_application, newWindow(), Kwave::Splash::showMessage(), Kwave::FileContext::signalManager(), updateMenu(), updateToolbar(), and Kwave::urlScheme().

Referenced by executeCommand(), Kwave::App::newWindow(), openFile(), and openRecent().

{
    Kwave::FileContext *context = currentContext();

    // special handling for kwave: URLs
    if (url.scheme().toLower() == Kwave::urlScheme()) {
        QString cmd = Kwave::Parser::fromUrl(url);
        Kwave::Logger::log(this, Kwave::Logger::Info,
            _("CMD: from command line: '") + cmd + _("'"));
        Kwave::Splash::showMessage(i18n("Executing command '%1'...", cmd));
        return (context) ? context->executeCommand(cmd) : executeCommand(cmd);
    }

    if (!context) return -1;
    Kwave::SignalManager *signal_manager = context->signalManager();
    Q_ASSERT(signal_manager);

    // add an entry to the list of recent files
    m_application.addRecentFile(url.isLocalFile() ?
        url.toLocalFile() : url.toDisplayString());

    // abort if new file not valid and local
    if (!url.isLocalFile()) return -1;

    // detect whether it is a macro (batch) file
    QFileInfo file(url.fileName());
    QString suffix = file.suffix();
    if (suffix == _("kwave")) {
        Kwave::Splash::showMessage(
            i18n("Executing Kwave script file '%1'...", url.toDisplayString())
        );
        return context->loadBatch(url);
    }

    // open a new window (empty in case of MDI/TAB)
    int retval = newWindow(context, url);
    if ((retval <= 0) || !context) return retval;

    Kwave::Splash::showMessage(
        i18n("Loading file '%1'...", url.toDisplayString())
    );

    // NOTE: the context may have changed, now we may have a different
    //       signal manager
    signal_manager = context->signalManager();
    int res = -ENOMEM;
    if (signal_manager && !(res = signal_manager->loadFile(url))) {
        // succeeded
    } else {
        qWarning("TopWidget::loadFile() failed: result=%d", res);
        QString reason;
        switch (res) {
            case -ENOMEM:
                reason = i18n("Out of memory");
                break;
            case -EIO:
                reason = i18nc("error message after opening a file failed",
                               "Unable to open '%1'", url.toDisplayString());
                break;
            case -EINVAL:
                reason = i18nc("error message after opening a file failed",
                               "Invalid or unknown file type: '%1'",
                               url.toDisplayString());
                break;
            default:
                reason = _("");
        }

        // show an error message box if the reason was known
        if (reason.length()) {
            Kwave::MessageBox::error(this, reason);
        }

        // load failed
        context->closeFile();
    }

    updateMenu();
    updateToolbar();

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

metaDataChanged

void Kwave::TopWidget::metaDataChanged ( Kwave::MetaDataList  meta_data )

privateslot

Called when the meta data of the current signal has changed

Parameters

meta_data

the new meta data, after the change

Definition at line 1125 of file TopWidget.cpp.

References _, Kwave::FileInfo::bits(), Kwave::FileInfo::length(), m_lbl_status_mode, m_lbl_status_size, m_menu_manager, Kwave::ms2string(), Kwave::FileInfo::rate(), Kwave::samples2string(), selectionChanged(), Kwave::FileInfo::tracks(), updateCaption(), updateMenu(), and updateToolbar().

Referenced by connectContext(), and init().

{
    Q_ASSERT(statusBar());
    if (!statusBar() || !m_menu_manager) return;
    QString txt;

    const Kwave::FileInfo info(meta_data);
    sample_index_t length = info.length();
    unsigned int tracks   = info.tracks();
    double rate           = info.rate();
    unsigned int bits     = info.bits();

    // length in milliseconds
    if (length) {
        double ms = (rate > 0) ? (static_cast<double>(length) /
            static_cast<double>(rate) * 1E3) : 0;
        txt = _(" ") + i18nc(
            "Length, as in total duration of loaded song",
            "Length: %1 (%2 samples)",
            Kwave::ms2string(ms),
            Kwave::samples2string(length)
        ) + _(" ");
    } else txt = _("");
    m_lbl_status_size->setText(txt);

    // sample rate and resolution
    if (bits) {
        QString khz = _("%0.3f");
        khz = khz.sprintf("%0.3f", static_cast<double>(rate) * 1E-3);
        txt = _(" ") + i18n("Mode: %1 kHz @ %2 Bit", khz, bits) +  _(" ");
    } else txt = _("");
    m_lbl_status_mode->setText(txt);

    // remove selection/position display on file close
    bool have_signal = (tracks != 0);
    if (!have_signal) selectionChanged(0, 0);

    // update the menu
    updateMenu();

    // update the toolbar as well
    updateToolbar();

    // update the window caption
    updateCaption();
}

Here is the call graph for this function:

Here is the caller graph for this function:

modifiedChanged

void Kwave::TopWidget::modifiedChanged ( )

privateslot

called if the signal now or no longer is modified

Definition at line 1526 of file TopWidget.cpp.

References updateCaption(), and updateMenu().

Referenced by connectContext().

{
    updateCaption();
    updateMenu();
}

Here is the call graph for this function:

Here is the caller graph for this function:

newFileContext()

Kwave::FileContext * Kwave::TopWidget::newFileContext ( )

private

Creates a new file context and initializes it.

Returns

the new file context or null pointer if creation or initialization failed

Definition at line 203 of file TopWidget.cpp.

References connectContext(), Kwave::FileContext::init(), m_application, m_context_map, m_toolbar_zoom, and sigFileContextSwitched().

Referenced by init(), insertContext(), and newWindow().

{
    Q_ASSERT(m_toolbar_zoom);
    if (!m_toolbar_zoom) return Q_NULLPTR;

    Kwave::FileContext *context =
        new(std::nothrow) Kwave::FileContext(m_application);
    if (!context) return Q_NULLPTR;
    if (!context->init(this)) {
        delete context;
        return Q_NULLPTR;
    }

    // if we are in SDI mode, there is a context but no MDI sub window
    // and in MDI/TAB mode we use this special entry for a context that
    // has just been created but has no sub window yet
    m_context_map[Q_NULLPTR] = context;

    // do all signal/slot connections
    connectContext(context);

    // if we reach this point everything was ok, now we can safely switch
    // to the new context
    emit sigFileContextSwitched(context);

    return context;
}

Here is the call graph for this function:

Here is the caller graph for this function:

newSignal()

int Kwave::TopWidget::newSignal ( sample_index_t  samples, double  rate, unsigned int  bits, unsigned int  tracks  )

private

Closes the current file and creates a new empty signal.

Parameters

samples	number of samples per track
rate	sample rate
bits	number of bits per sample
tracks	number of tracks

Returns

zero if successful, -1 if failed or canceled

Definition at line 1102 of file TopWidget.cpp.

References _, currentContext(), Kwave::SignalManager::newSignal(), newWindow(), Kwave::FileContext::signalManager(), and Kwave::Parser::toUrl().

Referenced by executeCommand().

{
    Kwave::FileContext *context = currentContext();
    if (!context) return -1;

    Kwave::SignalManager *signal_manager = context->signalManager();
    if (!signal_manager) return -1;

    QUrl url = Kwave::Parser::toUrl(
        _("newsignal(%1,%2,%3,%4)"
        ).arg(samples).arg(rate).arg(bits).arg(tracks));
    int retval = newWindow(context, url);
    if (retval <= 0) return retval;

    signal_manager = context->signalManager();
    if (!signal_manager) return -1;

    signal_manager->newSignal(samples, rate, bits, tracks);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

newWindow()

int Kwave::TopWidget::newWindow ( Kwave::FileContext *&  context, const QUrl &  url  )

private

Opens a new empty window.

Parameters

context	reference to the pointer to the current context, can be modified in case that a new context has to be created for the new window! Must not be a null pointer
url	URL of the file to be loaded (optional), used for opening a new SDI window

Return values

-1	or negative in case of an error
0	if succeeded and done (SDI mode)
1	if succeeded but window is still empty (MDI or TAB mode)

Definition at line 930 of file TopWidget.cpp.

References Kwave::FileContext::closeFile(), Kwave::FileContext::createMainWidget(), Kwave::App::GUI_MDI, Kwave::App::GUI_SDI, Kwave::App::GUI_TAB, Kwave::App::guiType(), insertContext(), Kwave::SignalManager::isEmpty(), Kwave::FileContext::isEmpty(), m_application, m_context_map, m_mdi_area, newFileContext(), Kwave::App::newWindow(), Kwave::FileContext::release(), sigFileContextSwitched(), Kwave::FileContext::signalManager(), and Kwave::urlScheme().

Referenced by loadFile(), and newSignal().

{
    switch (m_application.guiType()) {
        case Kwave::App::GUI_SDI: {
            // SDI mode and already something loaded
            // -> open a new toplevel window
            //    (except for processing commands per kwave: URL
            Kwave::SignalManager *signal_manager = (context) ?
                context->signalManager() : Q_NULLPTR;
            if ( signal_manager && !signal_manager->isEmpty() &&
                (url.scheme().toLower() != Kwave::urlScheme()) )
                return m_application.newWindow(url);

            // try to close the previous file
            if (context && !context->closeFile()) return -1;

            break;
        }
        case Kwave::App::GUI_MDI: /* FALLTHROUGH */
        case Kwave::App::GUI_TAB:
            // MDI or TAB mode: open a new sub window
            Q_ASSERT(m_mdi_area);
            if (!m_mdi_area) return -1;

            if (context && context->isEmpty()) {
                // current context is empty, no main widget etc -> discard it
                if (m_context_map.contains(Q_NULLPTR)) {
                    // must have been the default context
                    Q_ASSERT(m_context_map[Q_NULLPTR] == context);
                    m_context_map.remove(Q_NULLPTR);
                }

                // NOTE: do not handle the following context switch
                //       notification, it might be handled with a
                //       refcount that has already been set to zero
                disconnect(
                    this,
                    SIGNAL(sigFileContextSwitched(Kwave::FileContext*)),
                    context,
                    SLOT(contextSwitched(Kwave::FileContext*))
                );
                context->release();
            }

            // create a new file context
            context = newFileContext();
            if (!context) return -1;

            // create a main widget
            if (!context->createMainWidget(
                m_mdi_area->geometry().size() * 0.85)) return -1;

            // insert the context into this instance
            insertContext(context);
            break;
    }

    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

openFile()

int Kwave::TopWidget::openFile ( )

private

Shows an "open file" dialog and opens the .wav file the user has selected.

Returns

zero if succeeded or error code

Definition at line 1082 of file TopWidget.cpp.

References _, Kwave::CodecManager::decodingFilter(), loadFile(), Kwave::FileDialog::OpenFile, and Kwave::FileDialog::selectedUrl().

Referenced by executeCommand().

{
    QString filter = Kwave::CodecManager::decodingFilter();
    QPointer<Kwave::FileDialog> dlg = new (std::nothrow) Kwave::FileDialog(
        _("kfiledialog:///kwave_open_dir"),
        Kwave::FileDialog::OpenFile, filter, this
    );
    if (!dlg) return -1;
    dlg->setWindowTitle(i18n("Open"));
    if (dlg->exec() == QDialog::Accepted) {
        QUrl url = dlg->selectedUrl();
        delete dlg;
        return loadFile(url);
    } else {
        delete dlg;
        return -1;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

openFiles()

QList< Kwave::App::FileAndInstance > Kwave::TopWidget::openFiles

(

)

const

Returns a list of currently opened files and their instance number

Definition at line 504 of file TopWidget.cpp.

References Kwave::FileContext::instanceNr(), m_context_map, name, and Kwave::FileContext::signalName().

Referenced by Kwave::App::openFiles().

{
    QList<Kwave::App::FileAndInstance> all_files;

    foreach (Kwave::FileContext *context, m_context_map.values()) {
        if (!context) continue;
        QString name = context->signalName();
        if (!name.length()) continue;
        int instance_nr = context->instanceNr();
        all_files.append(Kwave::App::FileAndInstance(name, instance_nr));
    }

    return all_files;
}

Here is the call graph for this function:

Here is the caller graph for this function:

openRecent()

int Kwave::TopWidget::openRecent ( const QString &  str )

private

Opens a file contained in the list of recent files.

Parameters

str	the entry contained in the list

Returns

zero if succeeded, non-zero if failed

Definition at line 1075 of file TopWidget.cpp.

References Kwave::Parser::firstParam(), and loadFile().

Referenced by executeCommand().

{
    Kwave::Parser parser(str);
    return loadFile(QUrl::fromUserInput(parser.firstParam()));
}

Here is the call graph for this function:

Here is the caller graph for this function:

resetToolbarToDefaults

void Kwave::TopWidget::resetToolbarToDefaults ( )

privateslot

resets the toolbar layout to default settings

Definition at line 1453 of file TopWidget.cpp.

References TOOLBAR_EDIT, TOOLBAR_FILE, TOOLBAR_RECORD_PLAY, and TOOLBAR_ZOOM.

Referenced by executeCommand(), and init().

{
    KToolBar *toolbar_file        = toolBar(TOOLBAR_FILE);
    KToolBar *toolbar_edit        = toolBar(TOOLBAR_EDIT);
    KToolBar *toolbar_record_play = toolBar(TOOLBAR_RECORD_PLAY);
    KToolBar *toolbar_zoom        = toolBar(TOOLBAR_ZOOM);

    int icon_size_def = style()->pixelMetric(QStyle::PM_ToolBarIconSize);
    int icon_size_big = style()->pixelMetric(QStyle::PM_LargeIconSize);

    // change style to "symbols only mode" and set standard size
    foreach(KToolBar *bar, toolBars()) {
        bar->setToolButtonStyle(Qt::ToolButtonIconOnly);
        bar->setIconSize( QSize(icon_size_def, icon_size_def) );
    }

    // re-order the tool bars:
    // -----------------------
    // file  |  edit  |
    // -----------------------
    // record/play  | zoom
    // -----------------------
    insertToolBar(toolbar_zoom,        toolbar_record_play);
    insertToolBar(toolbar_record_play, toolbar_edit);
    insertToolBar(toolbar_edit,        toolbar_file);

    // move record/playback into a separate line, below file/edit
    insertToolBarBreak(toolbar_record_play);

    // let record/playback and zoom use bigger icons
    toolbar_record_play->setIconSize(QSize(icon_size_big, icon_size_big));
    toolbar_zoom->setIconSize(QSize(icon_size_big, icon_size_big));

    foreach(KToolBar *bar, toolBars()) {
        bar->update();
        bar->show();
    }
}

Here is the caller graph for this function:

selectionChanged

void Kwave::TopWidget::selectionChanged ( sample_index_t  offset, sample_index_t  length  )

privateslot

Updates the number of selected samples in the status bar.

Parameters

offset	index of the first selected sample
length	number of selected samples

Definition at line 1173 of file TopWidget.cpp.

References _, currentContext(), m_lbl_status_cursor, m_menu_manager, Kwave::ms2string(), Kwave::SignalManager::rate(), Kwave::samples2string(), Kwave::MenuManager::setItemEnabled(), Kwave::FileContext::signalManager(), Kwave::SignalManager::tracks(), and updateToolbar().

Referenced by connectContext(), init(), and metaDataChanged().

{
    const Kwave::FileContext *context = currentContext();
    if (!context) return;

    Kwave::SignalManager *signal_manager = context->signalManager();
    Q_ASSERT(signal_manager);
    if (!signal_manager) return;
    Q_ASSERT(statusBar());
    if (!statusBar()) return;

    // force sample mode if rate==0
    const double rate        = signal_manager->rate();
    const bool   sample_mode = (qFuzzyIsNull(rate));

    if (length > 1) {
        // show offset and length
        // Selected: 2000...3000 (1000 samples)
        // Selected: 02:00...05:00 (3 min)
        sample_index_t last = offset + ((length) ? length-1 : 0);

        QString txt = _(" ");
        if (sample_mode) {
            txt += i18nc(
                "%1=first sample, %2=last sample, %3=number of samples, "\
                "example: 'Selected: 2000...3000 (1000 samples)'",
                "Selected: %1...%2 (%3 samples)",
                Kwave::samples2string(offset),
                Kwave::samples2string(last),
                Kwave::samples2string(length)
            );
        } else {
            double ms_first = static_cast<double>(offset)   * 1E3 / rate;
            double ms_last  = static_cast<double>(last + 1) * 1E3 / rate;
            double ms = (ms_last - ms_first);
            txt += i18nc(
                "%1=start time, %2=end time, %3=time span, "\
                "example: 'Selected: 02:00...05:00 (3 min)'",
                "Selected: %1...%2 (%3)",
                Kwave::ms2string(ms_first),
                Kwave::ms2string(ms_last),
                Kwave::ms2string(ms)
            );
        }

        m_lbl_status_cursor->setText(_(""));
        statusBar()->showMessage(txt, 4000);
        if (m_menu_manager)
            m_menu_manager->setItemEnabled(_("@SELECTION"), true);
    } else {
        // show cursor position
        // Position: 02:00

        if (sample_mode || !signal_manager->tracks()) {
            m_lbl_status_cursor->setText(_(""));
        } else {
            double ms_first = static_cast<double>(offset) * 1E3 / rate;
            QString txt = i18n("Position: %1",
                Kwave::ms2string(ms_first));
            m_lbl_status_cursor->setText(txt);
        }

        if (m_menu_manager)
            m_menu_manager->setItemEnabled(_("@SELECTION"), false);
    }

    // update the toolbar on selection change, maybe the
    // button for "zoom selection" has to be enabled/disabled
    updateToolbar();
}

Here is the call graph for this function:

Here is the caller graph for this function:

setUndoRedoInfo

void Kwave::TopWidget::setUndoRedoInfo ( const QString &  undo, const QString &  redo  )

privateslot

Sets the descriptions of the last undo and redo action. If the name is zero or zero-length, the undo / redo is currently not available.

Definition at line 1246 of file TopWidget.cpp.

References _, m_action_redo, m_action_undo, m_menu_manager, Kwave::MenuManager::setItemEnabled(), and Kwave::MenuManager::setItemText().

Referenced by connectContext(), and init().

{
    QString txt;
    bool undo_enabled = (undo.length() != 0);
    bool redo_enabled = (redo.length() != 0);

    // set the state and tooltip of the undo toolbar button
    if (m_action_undo) {
        txt = (undo_enabled) ?
            i18nc("tooltip of the undo toolbar button if undo enabled",
                  "Undo (%1)", undo) :
            i18nc("tooltip of the undo toolbar button if undo disabled",
                  "Undo");
        m_action_undo->setToolTip(txt);
        m_action_undo->setEnabled(undo_enabled);
    }

    // set the state and tooltip of the redo toolbar button
    if (m_action_redo) {
        txt = (redo_enabled) ?
            i18nc("tooltip of the redo toolbar button, redo enabled",
                  "Redo (%1)", redo) :
            i18nc("tooltip of the redo toolbar button, redo disabled",
                  "Redo");
        m_action_redo->setToolTip(txt);
        m_action_redo->setEnabled(redo_enabled);
    }

    if (!m_menu_manager) return;

    // set new enable and text of the undo menu entry
    m_menu_manager->setItemEnabled(_("ID_EDIT_UNDO"), undo_enabled);
    txt = (undo_enabled) ?
        i18nc("menu entry for undo if undo enabled",  "Undo (%1)", undo) :
        i18nc("menu entry for undo if undo disabled", "Undo");
    m_menu_manager->setItemText(_("ID_EDIT_UNDO"), txt);

    // set new enable and text of the undo menu entry
    m_menu_manager->setItemEnabled(_("ID_EDIT_REDO"), redo_enabled);
    txt = (redo_enabled) ?
        i18nc("menu entry for redo if redo enabled",  "Redo (%1)", redo) :
        i18nc("menu entry for redo if redo disabled", "Redo");
    m_menu_manager->setItemText(_("ID_EDIT_REDO"), txt);
}

Here is the call graph for this function:

Here is the caller graph for this function:

showInSplashSreen

void Kwave::TopWidget::showInSplashSreen ( const QString &  message )

privateslot

shows a message/progress in the splash screen

Definition at line 1547 of file TopWidget.cpp.

References Kwave::Splash::showMessage().

Referenced by init().

{
    Kwave::Splash::showMessage(message);
}

Here is the call graph for this function:

Here is the caller graph for this function:

showStatusBarMessage

void Kwave::TopWidget::showStatusBarMessage ( const QString &  msg, unsigned int  ms  )

privateslot

Show a message in the status bar

Parameters

msg	the status bar message, already localized
ms	the time in milliseconds to show the message

Definition at line 1553 of file TopWidget.cpp.

Referenced by connectContext().

{
    QStatusBar *status_bar = statusBar();
    if (!status_bar) return;

    if (msg.length())
        status_bar->showMessage(msg, ms);
    else
        status_bar->clearMessage();
}

Here is the caller graph for this function:

sigFileContextSwitched

void Kwave::TopWidget::sigFileContextSwitched ( Kwave::FileContext *  context )

signal

Emitted by us when the current file context has switched

Parameters

context

the new file context

Referenced by detachAllContexts(), init(), insertContext(), newFileContext(), newWindow(), and subWindowActivated().

Here is the caller graph for this function:

subWindowActivated

void Kwave::TopWidget::subWindowActivated ( QMdiSubWindow *  sub )

privateslot

called when a MDI sub window or TAB has been activated

Parameters

sub	the sub window that has been activated

Definition at line 1566 of file TopWidget.cpp.

References currentContext(), m_context_map, and sigFileContextSwitched().

Referenced by init(), and insertContext().

{
    if (!sub || !m_context_map.contains(sub)) return;
    emit sigFileContextSwitched(currentContext());
}

Here is the call graph for this function:

Here is the caller graph for this function:

subWindowDeleted

void Kwave::TopWidget::subWindowDeleted ( QObject *  obj )

privateslot

called when a MDI sub window or TAB is about to be deleted

Parameters

obj	the sub window (not yet deleted)

Definition at line 1573 of file TopWidget.cpp.

References m_context_map, and Kwave::FileContext::release().

Referenced by insertContext().

{
    QMdiSubWindow *sub = static_cast<QMdiSubWindow *>(obj);
    if (!sub || !m_context_map.contains(sub)) {
        // sub window is not in the map, maybe it has already been detached
        return;
    }

    Kwave::FileContext *context = m_context_map[sub];
    Q_ASSERT(context);
    if (!context) return;

    m_context_map.remove(sub);

    if (m_context_map.isEmpty()) {
        // keep the default context, without a window
        m_context_map[Q_NULLPTR] = context;
    } else {
        // remove the context
        context->release();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

toolbarEditCopy

void Kwave::TopWidget::toolbarEditCopy ( )

inlineprivateslot

toolbar: "edit/copy"

Definition at line 228 of file TopWidget.h.

References _.

Referenced by init().

{ forwardCommand(_("copy () ")); }

Here is the caller graph for this function:

toolbarEditCut

void Kwave::TopWidget::toolbarEditCut ( )

inlineprivateslot

toolbar: "edit/cut"

Definition at line 225 of file TopWidget.h.

References _.

Referenced by init().

{ forwardCommand(_("cut () ")); }

Here is the caller graph for this function:

toolbarEditDelete

void Kwave::TopWidget::toolbarEditDelete ( )

inlineprivateslot

toolbar: "edit/delete"

Definition at line 237 of file TopWidget.h.

References _.

Referenced by init().

{ forwardCommand(_("delete () ")); }

Here is the caller graph for this function:

toolbarEditErase

void Kwave::TopWidget::toolbarEditErase ( )

inlineprivateslot

toolbar: "edit/erase"

Definition at line 234 of file TopWidget.h.

References _.

Referenced by init().

{ forwardCommand(_("plugin(zero)")); }

Here is the caller graph for this function:

toolbarEditPaste

void Kwave::TopWidget::toolbarEditPaste ( )

inlineprivateslot

toolbar: "edit/paste"

Definition at line 231 of file TopWidget.h.

References _.

Referenced by init().

{ forwardCommand(_("paste () ")); }

Here is the caller graph for this function:

toolbarEditRedo

void Kwave::TopWidget::toolbarEditRedo ( )

inlineprivateslot

toolbar: "edit/redo"

Definition at line 222 of file TopWidget.h.

References _.

Referenced by init().

{ forwardCommand(_("redo () ")); }

Here is the caller graph for this function:

toolbarEditUndo

void Kwave::TopWidget::toolbarEditUndo ( )

inlineprivateslot

toolbar: "edit/undo"

Definition at line 219 of file TopWidget.h.

References _.

Referenced by init().

{ forwardCommand(_("undo () ")); }

Here is the caller graph for this function:

toolbarFileClose

void Kwave::TopWidget::toolbarFileClose ( )

inlineprivateslot

toolbar: "file/save"

Definition at line 216 of file TopWidget.h.

References _.

Referenced by init().

{ forwardCommand(_("close () ")); }

Here is the caller graph for this function:

toolbarFileNew

void Kwave::TopWidget::toolbarFileNew ( )

inlineprivateslot

toolbar: "file/new"

Definition at line 204 of file TopWidget.h.

References _.

Referenced by init().

{ forwardCommand(_("plugin(newsignal)")); }

Here is the caller graph for this function:

toolbarFileOpen

void Kwave::TopWidget::toolbarFileOpen ( )

inlineprivateslot

toolbar: "file/open"

Definition at line 207 of file TopWidget.h.

References _.

Referenced by init().

{ forwardCommand(_("open () ")); }

Here is the caller graph for this function:

toolbarFileSave

void Kwave::TopWidget::toolbarFileSave ( )

inlineprivateslot

toolbar: "file/save"

Definition at line 210 of file TopWidget.h.

References _.

Referenced by init().

{ forwardCommand(_("save () ")); }

Here is the caller graph for this function:

toolbarFileSaveAs

void Kwave::TopWidget::toolbarFileSaveAs ( )

inlineprivateslot

toolbar: "file/save"

Definition at line 213 of file TopWidget.h.

References _.

Referenced by init().

{ forwardCommand(_("saveas () ")); }

Here is the caller graph for this function:

toolbarRecord

void Kwave::TopWidget::toolbarRecord ( )

inlineprivateslot

Definition at line 201 of file TopWidget.h.

References _.

{ forwardCommand(_("plugin(record)")); }

updateCaption()

void Kwave::TopWidget::updateCaption ( )

private

Updates the window caption

Definition at line 1533 of file TopWidget.cpp.

References currentContext(), and Kwave::FileContext::windowCaption().

Referenced by insertContext(), metaDataChanged(), and modifiedChanged().

{
    const Kwave::FileContext *context = currentContext();
    QString caption = (context) ? context->windowCaption(true) : QString();
    setCaption(caption);
}

Here is the call graph for this function:

Here is the caller graph for this function:

updateMenu

void Kwave::TopWidget::updateMenu ( )

privateslot

Updates the menu by enabling/disabling some entries

Definition at line 1316 of file TopWidget.cpp.

References _, Kwave::MenuManager::addNumberedMenuEntry(), Kwave::MenuManager::clearNumberedMenu(), clipboardChanged(), currentContext(), Kwave::App::GUI_MDI, Kwave::App::GUI_SDI, Kwave::App::GUI_TAB, Kwave::App::guiType(), Kwave::INF_FILENAME, Kwave::ClipBoard::instance(), Kwave::ClipBoard::isEmpty(), Kwave::SignalManager::isModified(), m_application, m_context_map, m_menu_manager, Kwave::SignalManager::metaData(), Kwave::Label::name(), name, Kwave::MenuManager::selectItem(), Kwave::MenuManager::setItemEnabled(), Kwave::MenuManager::setItemVisible(), Kwave::FileContext::signalManager(), Kwave::FileContext::signalName(), Kwave::SignalManager::tracks(), and Kwave::FileContext::windowCaption().

Referenced by init(), insertContext(), loadFile(), metaDataChanged(), and modifiedChanged().

{
    const Kwave::FileContext *context = currentContext();
    Kwave::SignalManager *signal_manager =
        (context) ? context->signalManager() : Q_NULLPTR;
    Q_ASSERT(m_menu_manager);
    if (!m_menu_manager) return;

    bool have_window_menu = false;
    switch (m_application.guiType()) {
        case Kwave::App::GUI_SDI:
            m_menu_manager->selectItem(_("@GUI_TYPE"), _("ID_GUI_SDI"));
            m_menu_manager->setItemVisible(_("ID_WINDOW"),               false);
            m_menu_manager->setItemVisible(_("ID_WINDOW_NEXT"),          false);
            m_menu_manager->setItemVisible(_("ID_WINDOW_PREV"),          false);
            m_menu_manager->setItemVisible(_("ID_WINDOW_CASCADE"),       false);
            m_menu_manager->setItemVisible(_("ID_WINDOW_TILE"),          false);
            m_menu_manager->setItemVisible(_("ID_WINDOW_TILE_VERTICAL"), false);
            m_menu_manager->setItemVisible(_("ID_FILE_NEW_WINDOW"),      true);
            break;
        case Kwave::App::GUI_MDI:
            m_menu_manager->selectItem(_("@GUI_TYPE"), _("ID_GUI_MDI"));
            m_menu_manager->setItemVisible(_("ID_WINDOW"),               true);
            m_menu_manager->setItemVisible(_("ID_WINDOW_NEXT"),          true);
            m_menu_manager->setItemVisible(_("ID_WINDOW_PREV"),          true);
            m_menu_manager->setItemVisible(_("ID_WINDOW_CASCADE"),       true);
            m_menu_manager->setItemVisible(_("ID_WINDOW_TILE"),          true);
            m_menu_manager->setItemVisible(_("ID_WINDOW_TILE_VERTICAL"), true);
            m_menu_manager->setItemVisible(_("ID_FILE_NEW_WINDOW"),      false);
            have_window_menu = true;
            break;
        case Kwave::App::GUI_TAB:
            m_menu_manager->selectItem(_("@GUI_TYPE"), _("ID_GUI_TAB"));
            m_menu_manager->setItemVisible(_("ID_WINDOW"),               true);
            m_menu_manager->setItemVisible(_("ID_WINDOW_NEXT"),          true);
            m_menu_manager->setItemVisible(_("ID_WINDOW_PREV"),          true);
            m_menu_manager->setItemVisible(_("ID_WINDOW_CASCADE"),       false);
            m_menu_manager->setItemVisible(_("ID_WINDOW_TILE"),          false);
            m_menu_manager->setItemVisible(_("ID_WINDOW_TILE_VERTICAL"), false);
            m_menu_manager->setItemVisible(_("ID_FILE_NEW_WINDOW"),      false);
            have_window_menu = true;
            break;
    }

    if (have_window_menu) {
        // update the "Windows" menu
        m_menu_manager->clearNumberedMenu(_("ID_WINDOW_LIST"));
        unsigned int win_count = 0;
        foreach (const Kwave::FileContext *ctx, m_context_map.values()) {
            if (!ctx) continue;
            QString caption = ctx->windowCaption(false);
            if (!caption.length()) continue;
            m_menu_manager->addNumberedMenuEntry(_("ID_WINDOW_LIST"),
                caption, QString());
            ++win_count;
        }

        bool on = (win_count > 1);
        m_menu_manager->setItemEnabled(_("ID_WINDOW_NEXT"),          on);
        m_menu_manager->setItemEnabled(_("ID_WINDOW_PREV"),          on);
        m_menu_manager->setItemEnabled(_("ID_WINDOW_CASCADE"),       on);
        m_menu_manager->setItemEnabled(_("ID_WINDOW_TILE"),          on);
        m_menu_manager->setItemEnabled(_("ID_WINDOW_TILE_VERTICAL"), on);
    }

    // enable/disable all items that depend on having a file
    bool have_file = (context && context->signalName().length());
    m_menu_manager->setItemEnabled(_("@NOT_CLOSED"), have_file);

    // enable/disable all items that depend on having a label
    // and update the label menu
    bool have_labels = false;
    if (signal_manager) {
        Kwave::LabelList labels(signal_manager->metaData());
        have_labels = !labels.isEmpty();

        m_menu_manager->clearNumberedMenu(_("ID_LABEL_DELETE"));
        if (labels.count()) {

            // add special entry to delete all labels
            m_menu_manager->addNumberedMenuEntry(
                _("ID_LABEL_DELETE"),
                i18nc("special entry in the list of labels to delete all",
                      "(All)"), _("-1"));

            // iterate over the list of labels
            unsigned int index = 0;
            foreach (const Kwave::Label &label, labels) {
                QString name = label.name();
                QString desc = (name.length()) ?
                i18nc(
                    "list menu entry of a label, %1=index, %2=description/name",
                    "#%1 (%2)", index, name) :
                    i18nc("list menue entry of a label, "
                            "without description, %1=index",
                            "#%1", index);
                m_menu_manager->addNumberedMenuEntry(
                    _("ID_LABEL_DELETE"), desc, name.setNum(index));
                index++;
            }
        }
    }
    m_menu_manager->setItemEnabled(_("@LABELS"), have_labels);

    // update the list of deletable tracks
    unsigned int tracks = (signal_manager) ? signal_manager->tracks() : 0;
    m_menu_manager->clearNumberedMenu(_("ID_EDIT_TRACK_DELETE"));
    QString buf;
    for (unsigned int i = 0; i < tracks; i++) {
        m_menu_manager->addNumberedMenuEntry(
            _("ID_EDIT_TRACK_DELETE"), buf.setNum(i), buf.setNum(i));
    }

    // enable/disable all items that depend on having a signal
    bool have_signal = (tracks != 0);
    m_menu_manager->setItemEnabled(_("@SIGNAL"), have_signal);

    // revert is only possible if the signal exists, is modified and there
    // is a file behind from which we could reload (which is not the case
    // after File/New...).
    bool enable_revert = false;
    if (signal_manager) {
        bool have_filename = Kwave::FileInfo(
            signal_manager->metaData()
        ).contains(Kwave::INF_FILENAME);
        bool is_modified = signal_manager->isModified();
        enable_revert = have_filename && is_modified;
    }
    m_menu_manager->setItemEnabled(_("ID_FILE_REVERT"), enable_revert);

    // enable/disable all items that depend on having something in the
    // clipboard
    bool have_clipboard_data = !Kwave::ClipBoard::instance().isEmpty();
    clipboardChanged(have_clipboard_data);
}

Here is the call graph for this function:

Here is the caller graph for this function:

updateRecentFiles

void Kwave::TopWidget::updateRecentFiles ( )

slot

Updates the list of recent files in the menu, maybe some other window has changed it. The list of recent files is static and global in KwaveApp.

Definition at line 1300 of file TopWidget.cpp.

References _, Kwave::MenuManager::addNumberedMenuEntry(), Kwave::MenuManager::clearNumberedMenu(), m_application, m_menu_manager, Kwave::App::recentFiles(), and Kwave::MenuManager::setItemEnabled().

Referenced by init().

{
    Q_ASSERT(m_menu_manager);
    if (!m_menu_manager) return;
    m_menu_manager->clearNumberedMenu(_("ID_FILE_OPEN_RECENT"));

    foreach (const QString &file, m_application.recentFiles())
        m_menu_manager->addNumberedMenuEntry(
            _("ID_FILE_OPEN_RECENT"), file, QString());

    // enable/disable the "clear" menu entry in Files / Open Recent
    m_menu_manager->setItemEnabled(_("ID_FILE_OPEN_RECENT_CLEAR"),
        !m_application.recentFiles().isEmpty());
}

Here is the call graph for this function:

Here is the caller graph for this function:

updateToolbar

void Kwave::TopWidget::updateToolbar ( )

privateslot

updates all elements in the toolbar

Definition at line 1493 of file TopWidget.cpp.

References currentContext(), Kwave::Selection::length(), m_action_close, m_action_copy, m_action_cut, m_action_delete, m_action_erase, m_action_save, m_action_save_as, m_toolbar_zoom, Kwave::SignalManager::selection(), Kwave::FileContext::signalManager(), Kwave::SignalManager::tracks(), and Kwave::ZoomToolBar::updateToolbar().

Referenced by init(), insertContext(), loadFile(), metaDataChanged(), and selectionChanged().

{
    const Kwave::FileContext *context = currentContext();
    if (!context) return;

    Kwave::SignalManager *signal_manager = context->signalManager();
    Q_ASSERT(signal_manager);
    if (!signal_manager) return;

    bool have_signal = signal_manager->tracks();
    if (m_action_save)
        m_action_save->setEnabled(have_signal);
    if (m_action_save_as)
        m_action_save_as->setEnabled(have_signal);
    if (m_action_close)
        m_action_close->setEnabled(have_signal);

    bool have_selection = (signal_manager->selection().length() > 1);
    if (m_action_cut)
        m_action_cut->setEnabled(have_selection);
    if (m_action_copy)
        m_action_copy->setEnabled(have_selection);
    if (m_action_erase)
        m_action_erase->setEnabled(have_selection);
    if (m_action_delete)
        m_action_delete->setEnabled(have_selection);

    // update the zoom toolbar
    if (m_toolbar_zoom)
        m_toolbar_zoom->updateToolbar();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_action_close

QAction* Kwave::TopWidget::m_action_close

private

action of the "file close" toolbar button

Definition at line 371 of file TopWidget.h.

Referenced by init(), and updateToolbar().

m_action_copy

QAction* Kwave::TopWidget::m_action_copy

private

action of the "edit copy" toolbar button

Definition at line 383 of file TopWidget.h.

Referenced by init(), and updateToolbar().

m_action_cut

QAction* Kwave::TopWidget::m_action_cut

private

action of the "edit cut" toolbar button

Definition at line 380 of file TopWidget.h.

Referenced by init(), and updateToolbar().

m_action_delete

QAction* Kwave::TopWidget::m_action_delete

private

action of the "edit delete" toolbar button

Definition at line 389 of file TopWidget.h.

Referenced by init(), and updateToolbar().

m_action_erase

QAction* Kwave::TopWidget::m_action_erase

private

action of the "erase" toolbar button

Definition at line 386 of file TopWidget.h.

Referenced by init(), and updateToolbar().

m_action_redo

QAction* Kwave::TopWidget::m_action_redo

private

action of the "edit redo" toolbar button

Definition at line 377 of file TopWidget.h.

Referenced by init(), and setUndoRedoInfo().

m_action_save

QAction* Kwave::TopWidget::m_action_save

private

action of the "file save" toolbar button

Definition at line 365 of file TopWidget.h.

Referenced by init(), and updateToolbar().

m_action_save_as

QAction* Kwave::TopWidget::m_action_save_as

private

action of the "file save as..." toolbar button

Definition at line 368 of file TopWidget.h.

Referenced by init(), and updateToolbar().

m_action_undo

QAction* Kwave::TopWidget::m_action_undo

private

action of the "edit undo" toolbar button

Definition at line 374 of file TopWidget.h.

Referenced by init(), and setUndoRedoInfo().

m_application

Kwave::App& Kwave::TopWidget::m_application

private

each TopWidget has exactly one corresponding Kwave::App instance

Definition at line 340 of file TopWidget.h.

Referenced by executeCommand(), init(), insertContext(), loadFile(), newFileContext(), newWindow(), TopWidget(), updateMenu(), updateRecentFiles(), and ~TopWidget().

m_context_map

QMap<QMdiSubWindow *, Kwave::FileContext *> Kwave::TopWidget::m_context_map

private

map for retrieving the file context that corresponds to a MDI sub window or TAB. In SDI mode it contains only one entry, corresponding to a null pointer as index.

Definition at line 347 of file TopWidget.h.

Referenced by closeAllSubWindows(), currentContext(), detachAllContexts(), executeCommand(), insertContext(), newFileContext(), newWindow(), openFiles(), subWindowActivated(), subWindowDeleted(), updateMenu(), and ~TopWidget().

m_lbl_status_cursor

QLabel* Kwave::TopWidget::m_lbl_status_cursor

private

status bar label for cursor / playback position

Definition at line 398 of file TopWidget.h.

Referenced by selectionChanged(), and TopWidget().

m_lbl_status_mode

QLabel* Kwave::TopWidget::m_lbl_status_mode

private

status bar label for mode information

Definition at line 395 of file TopWidget.h.

Referenced by metaDataChanged(), and TopWidget().

m_lbl_status_size

QLabel* Kwave::TopWidget::m_lbl_status_size

private

status bar label for length of the signal

Definition at line 392 of file TopWidget.h.

Referenced by metaDataChanged(), and TopWidget().

m_mdi_area

QMdiArea* Kwave::TopWidget::m_mdi_area

private

MDI area, parent of all MDI child windows (only used in MDI and TAB gui mode, null for SDI)

Definition at line 362 of file TopWidget.h.

Referenced by currentContext(), detachAllContexts(), executeCommand(), init(), insertContext(), and newWindow().

m_menu_manager

Kwave::MenuManager* Kwave::TopWidget::m_menu_manager

private

menu manager for this window

Definition at line 356 of file TopWidget.h.

Referenced by clipboardChanged(), executeCommand(), init(), metaDataChanged(), selectionChanged(), setUndoRedoInfo(), updateMenu(), updateRecentFiles(), and ~TopWidget().

m_toolbar_record_playback

Kwave::PlayerToolBar* Kwave::TopWidget::m_toolbar_record_playback

private

toolbar with playback/record and seek controls

Definition at line 350 of file TopWidget.h.

Referenced by connectContext(), executeCommand(), init(), and ~TopWidget().

m_toolbar_zoom

Kwave::ZoomToolBar* Kwave::TopWidget::m_toolbar_zoom

private

toolbar with zoom controls

Definition at line 353 of file TopWidget.h.

Referenced by connectContext(), init(), newFileContext(), updateToolbar(), and ~TopWidget().

---

The documentation for this class was generated from the following files:

• kwave/TopWidget.h
• kwave/TopWidget.cpp