Kwave::App Class Reference

#include <App.h>

Inheritance diagram for Kwave::App:

Collaboration diagram for Kwave::App:

Public Types
enum	GuiType { GUI_SDI, GUI_MDI, GUI_TAB }
typedef QPair< QString, int >	FileAndInstance

Public Slots
int	newInstance (const QStringList &args, const QString &dir)

Signals
void	recentFilesChanged ()

Public Member Functions
	App (int &argc, char **argv)
void	processCmdline (QCommandLineParser *cmdline)
virtual bool	isOK () const
virtual	~App ()
void	addRecentFile (const QString &filename)
int	newWindow (const QUrl &url)
bool	toplevelWindowHasClosed (Kwave::TopWidget *todel)
QStringList	recentFiles () const
QList< FileAndInstance >	openFiles () const
GuiType	guiType () const
void	switchGuiType (Kwave::TopWidget *top, GuiType new_type)
const QCommandLineParser *	cmdline () const

Protected Member Functions
int	executeCommand (const QString &command)

Private Member Functions
void	readConfig ()
void	saveRecentFiles ()

Private Attributes
QCommandLineParser *	m_cmdline
QStringList	m_recent_files
QList< Kwave::TopWidget * >	m_top_widgets
GuiType	m_gui_type

Friends
class	Kwave::TopWidget

Detailed Description

This is the main application class for Kwave. It contains functions for opening and saving files, opening new windows and holds global configuration data.

Definition at line 44 of file App.h.

Member Typedef Documentation

FileAndInstance

typedef QPair<QString,int> Kwave::App::FileAndInstance

pair of file name and instance

See also

openFiles()

Definition at line 60 of file App.h.

Member Enumeration Documentation

GuiType

enum Kwave::App::GuiType

Enumerator
GUI_SDI	single document interface (SDI)
GUI_MDI	multi document interface (MDI)
GUI_TAB	tabbed interface

Definition at line 49 of file App.h.

                     {
            GUI_SDI, 
            GUI_MDI, 
            GUI_TAB  
        /*  GUI_IDE       integrated development environment (IDE) */
        } GuiType;

Constructor & Destructor Documentation

App()

Kwave::App::App	(	int &	argc,
		char **	argv
	)

Constructor

Parameters

argc	number of cmdline args, must be >= 1
argv	list of cmdline args, must be static

Definition at line 55 of file App.cpp.

References Kwave::connect(), and Kwave::ClipBoard::instance().

   :QApplication(argc, argv),
    m_cmdline(Q_NULLPTR),
    m_recent_files(),
    m_top_widgets(),
    m_gui_type(Kwave::App::GUI_TAB)
{
    qRegisterMetaType<Kwave::SampleArray>("Kwave::SampleArray");
    qRegisterMetaType<Kwave::LabelList>("Kwave::LabelList");
    qRegisterMetaType<sample_index_t>("sample_index_t");
    qRegisterMetaType<Kwave::MetaDataList>("Kwave::MetaDataList");

    // connect the clipboard
    connect(QApplication::clipboard(),
            SIGNAL(changed(QClipboard::Mode)),
            &(Kwave::ClipBoard::instance()),
            SLOT(slotChanged(QClipboard::Mode)));
}

Here is the call graph for this function:

~App()

Kwave::App::~App ( )

virtual

Destructor.

Definition at line 119 of file App.cpp.

References m_recent_files, and saveRecentFiles().

{
    saveRecentFiles();
    m_recent_files.clear();

    // let remaining cleanup handlers run (deferred delete)
    processEvents(QEventLoop::ExcludeUserInputEvents);
}

Here is the call graph for this function:

Member Function Documentation

addRecentFile()

void Kwave::App::addRecentFile

(

const QString &

filename

)

Adds a file to the top of the list of recent files. If it was already contained in the list the previous occurrence is removed.

Parameters

filename

path to the file

Definition at line 202 of file App.cpp.

References m_recent_files, MAX_RECENT_FILES, recentFilesChanged(), and saveRecentFiles().

Referenced by Kwave::TopWidget::loadFile(), and Kwave::FileContext::saveFileAs().

{
    if (!newfile.length()) return;

    // remove old entries if present
    m_recent_files.removeAll(newfile);

    // shorten the list down to (MAX_RECENT_FILES - 1) entries
    while (m_recent_files.count() >= MAX_RECENT_FILES)
        m_recent_files.removeLast();

    // insert the new entry at top
    m_recent_files.prepend(newfile);

    // save the list of recent files
    saveRecentFiles();

    // update all toplevel widgets
    emit recentFilesChanged();
}

Here is the call graph for this function:

Here is the caller graph for this function:

cmdline()

const QCommandLineParser* Kwave::App::cmdline ( ) const

inline

Returns the command line parameters passed to the application

Definition at line 130 of file App.h.

References m_cmdline, newInstance(), and recentFilesChanged().

Referenced by processCmdline(), and Kwave::TopWidget::TopWidget().

{ return m_cmdline; }

Here is the call graph for this function:

Here is the caller graph for this function:

executeCommand()

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

protected

process an application global Kwave text command

Parameters

command

the text command to handle

Return values

0	if succeeded
ENOSYS	if the command is unknown
-EIO	if failed

Definition at line 178 of file App.cpp.

References _, Kwave::Parser::command(), Kwave::Parser::hasParams(), m_recent_files, newWindow(), Kwave::Parser::params(), recentFilesChanged(), and saveRecentFiles().

Referenced by Kwave::TopWidget::executeCommand().

{
    Kwave::Parser parser(command);
    if (parser.command() == _("newwindow")) {
        int retval = 0;
        if (parser.hasParams()) {
            retval = newWindow(QUrl(parser.params().at(0)));
        } else {
            retval = newWindow(QUrl(QString()));
        }
        return (retval == 0) ? 0 : -EIO;
    } else if (parser.command() == _("openrecent:clear")) {
        m_recent_files.clear();
        saveRecentFiles();
        emit recentFilesChanged();
    } else if (parser.command() == _("help")) {
        KHelpClient::invokeHelp();
    } else {
        return ENOSYS; // command not implemented (here)
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

guiType()

GuiType Kwave::App::guiType ( ) const

inline

returns the GUI type (e.g. SDI, MDI etc.)

Definition at line 119 of file App.h.

References m_gui_type, and switchGuiType().

Referenced by Kwave::FileContext::closeFile(), Kwave::TopWidget::executeCommand(), Kwave::TopWidget::init(), Kwave::TopWidget::insertContext(), Kwave::FileContext::metaDataChanged(), Kwave::FileContext::modifiedChanged(), Kwave::TopWidget::newWindow(), Kwave::MainWidget::resizeEvent(), Kwave::TopWidget::updateMenu(), and Kwave::FileContext::windowCaption().

{ return m_gui_type; }

Here is the call graph for this function:

Here is the caller graph for this function:

isOK()

bool Kwave::App::isOK ( ) const

virtual

Returns true if this instance was successfully initialized, or false if something went wrong during initialization.

Definition at line 172 of file App.cpp.

References m_top_widgets.

{
    return (!m_top_widgets.isEmpty());
}

newInstance

int Kwave::App::newInstance ( const QStringList &  args, const QString &  dir  )

slot

Connected to the DBus service to open a new window.

Return values

0	if the new instance was successfully created and the application should run
ECANCELED	if the application should shut down (e.g. when a script was loaded and the script has called quit() )

Definition at line 129 of file App.cpp.

References _, Kwave::connect(), m_cmdline, name, newWindow(), Kwave::Logger::open(), readConfig(), and Kwave::Splash::showMessage().

Referenced by cmdline(), and main().

{
    int retval = 0;
    Q_UNUSED(dir);

    Q_ASSERT(m_cmdline);
    if (!m_cmdline) return -EINVAL;

    m_cmdline->parse(args);

    static bool first_time = true;
    if (first_time) {
        first_time = false;

        // open the log file if given on the command line
        if (m_cmdline->isSet(_("logfile"))) {
            if (!Kwave::Logger::open(m_cmdline->value(_("logfile"))))
                exit(-1);
        }

        Kwave::Splash::showMessage(i18n("Reading configuration..."));
        readConfig();

        // close when the last window closed
        connect(this, SIGNAL(lastWindowClosed()), this, SLOT(quit()));
    }

    QStringList params = m_cmdline->positionalArguments();

    // only one parameter -> open with empty window
    if (params.isEmpty()) {
        retval = newWindow(QUrl());
    } else {
        // open a window for each file specified in the
        // command line an load it
        foreach (const QString &name, params) {
            retval = newWindow(QUrl::fromUserInput(name));
        }
    }
    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

newWindow()

int Kwave::App::newWindow

(

const QUrl &

url

)

Opens a new toplevel window. If a filename is specified the file will be opened.

Parameters

url	URL of the file to be loaded, (optional, might be empty)

Return values

0	if succeeded
ECANCELED	if the application should shut down (e.g. when a script was loaded and the script has called quit() )

See also

toplevelWindowHasClosed()

TopWidget

Definition at line 224 of file App.cpp.

References Kwave::connect(), GUI_MDI, GUI_SDI, GUI_TAB, Kwave::TopWidget::init(), Kwave::TopWidget::loadFile(), m_gui_type, m_top_widgets, recentFilesChanged(), Kwave::Splash::showMessage(), and Kwave::urlScheme().

Referenced by executeCommand(), newInstance(), and Kwave::TopWidget::newWindow().

{
    int retval = 0;
    Kwave::TopWidget *new_top_widget = Q_NULLPTR;

    Kwave::Splash::showMessage(i18n("Opening main window..."));

    switch (m_gui_type) {
        case Kwave::App::GUI_TAB: /* FALLTHROUGH */
        case Kwave::App::GUI_MDI:
            // re-use the last top widget to open the file
            if (!m_top_widgets.isEmpty())
                new_top_widget = m_top_widgets.last();
            break;
        case Kwave::App::GUI_SDI:
            // always create a new top widget, except when handling commands
            if ( (url.scheme().toLower() == Kwave::urlScheme()) &&
                 !m_top_widgets.isEmpty() )
                new_top_widget = m_top_widgets.last();
            break;
    }

    if (!new_top_widget) {
        new_top_widget = new(std::nothrow) Kwave::TopWidget(*this);
        if (!new_top_widget || !new_top_widget->init()) {
            // init failed
            qWarning("ERROR: initialization of TopWidget failed");
            delete new_top_widget;
            return ECANCELED;
        }

        if (!m_top_widgets.isEmpty()) {
            // create a new widget with the same geometry as
            // the last created one
            const QRect &geom = m_top_widgets.last()->geometry();
            // calling setGeometry(geom) would overlap :-(
            new_top_widget->resize(geom.width(), geom.height());
        }

        m_top_widgets.append(new_top_widget);
        new_top_widget->show();

        // inform the widget about changes in the list of recent files
        connect(this, SIGNAL(recentFilesChanged()),
                new_top_widget, SLOT(updateRecentFiles()));
    }

    retval = (!url.isEmpty()) ? new_top_widget->loadFile(url) : 0;
    if (retval == ECANCELED)
        delete new_top_widget;

    Kwave::Splash::showMessage(i18n("Startup done"));
    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

openFiles()

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

(

)

const

Returns a list of currently opened files and their instance

Definition at line 294 of file App.cpp.

References m_top_widgets, and Kwave::TopWidget::openFiles().

Referenced by Kwave::FileContext::metaDataChanged(), and recentFiles().

{
    QList<Kwave::App::FileAndInstance> all_files;
    foreach (Kwave::TopWidget *topwidget, m_top_widgets) {
        if (!topwidget) continue;
        QList<Kwave::App::FileAndInstance> files = topwidget->openFiles();
        if (!files.isEmpty())
            all_files += files;
    }
    return all_files;
}

Here is the call graph for this function:

Here is the caller graph for this function:

processCmdline()

void Kwave::App::processCmdline

(

QCommandLineParser *

cmdline

)

process the command line settings, after setting up the application, command line parser and about data

Parameters

cmdline

command line parser

Definition at line 75 of file App.cpp.

References _, cmdline(), GUI_MDI, GUI_SDI, GUI_TAB, m_cmdline, and m_gui_type.

Referenced by main().

{
    Q_ASSERT(cmdline);
    if (!cmdline) return;

    m_cmdline = cmdline;
    m_cmdline->parse(arguments());

    // read the configured user interface type
    QString result;
    KConfigGroup cfg = KSharedConfig::openConfig()->group("Global");
    result = cfg.readEntry("UI Type");
    if (result == _("SDI")) {
        m_gui_type = Kwave::App::GUI_SDI;
    } else if (result == _("MDI")) {
        m_gui_type = Kwave::App::GUI_MDI;
    } else if (result == _("TAB")) {
        m_gui_type = Kwave::App::GUI_TAB;
    }
    // else: use default

    // if user interface type is given as cmdline parameter: use that one
    if (m_cmdline->isSet(_("gui"))) {
        QString arg = m_cmdline->value(_("gui")).toUpper();
        bool valid = false;
        if (arg == _("SDI")) {
            m_gui_type = Kwave::App::GUI_SDI;
            valid = true;
        } else if (arg == _("MDI")) {
            m_gui_type = Kwave::App::GUI_MDI;
            valid = true;
        } else if (arg == _("TAB")) {
            m_gui_type = Kwave::App::GUI_TAB;
            valid = true;
        }
        // else: use previous setting

        // save this setting
        if (valid && (arg != result))
            cfg.writeEntry(_("UI Type"), arg);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

readConfig()

void Kwave::App::readConfig ( )

private

Reads the configuration settings and the list of recent files

Definition at line 409 of file App.cpp.

References m_recent_files, and MAX_RECENT_FILES.

Referenced by newInstance().

{
    QString result;
    QString key;
    const KConfigGroup cfg = KSharedConfig::openConfig()->group("Recent Files");

    for (unsigned int i = 0 ; i < MAX_RECENT_FILES; i++) {
        key = QString::number(i);        // generate number

        // read corresponding entry, which is stored in UTF-8
        result = cfg.readEntry(key);
        if (result.length()) {
            QFile file(result);

            //check if file exists and insert it if not already present
            if (file.exists() && (m_recent_files.contains(result) == 0))
                m_recent_files.append(result);
        }
    }
}

Here is the caller graph for this function:

recentFiles()

QStringList Kwave::App::recentFiles ( ) const

inline

Returns a reference to the list of recent files

Definition at line 113 of file App.h.

References m_recent_files, and openFiles().

Referenced by Kwave::TopWidget::updateRecentFiles().

{ return m_recent_files; }

Here is the call graph for this function:

Here is the caller graph for this function:

recentFilesChanged

void Kwave::App::recentFilesChanged ( )

signal

Will be emitted if the list of recent files has changed. Can be used by toplevel widgets to update their menus.

Referenced by addRecentFile(), cmdline(), executeCommand(), newWindow(), and switchGuiType().

Here is the caller graph for this function:

saveRecentFiles()

void Kwave::App::saveRecentFiles ( )

private

Saves the list of recent files to the kwave configuration file

See also

KConfig

Definition at line 392 of file App.cpp.

References m_recent_files, and MAX_RECENT_FILES.

Referenced by addRecentFile(), executeCommand(), toplevelWindowHasClosed(), and ~App().

{
    KConfigGroup cfg = KSharedConfig::openConfig()->group("Recent Files");

    QString num;
    for (int i = 0 ; i < MAX_RECENT_FILES; i++) {
        num.setNum(i);
        if (i < m_recent_files.count())
            cfg.writeEntry(num, m_recent_files[i]);
        else
            cfg.deleteEntry(num);
    }

    cfg.sync();
}

Here is the caller graph for this function:

switchGuiType()

void Kwave::App::switchGuiType	(	Kwave::TopWidget *	top,
		GuiType	new_type
	)

Switches the GUI type to a new style, using the current toplevel widget as start.

Parameters

top	the current toplevel widget
new_type	the new GUI type

Definition at line 307 of file App.cpp.

References Kwave::connect(), Kwave::TopWidget::detachAllContexts(), GUI_MDI, GUI_SDI, GUI_TAB, Kwave::TopWidget::init(), Kwave::TopWidget::insertContext(), Kwave::FileContext::isEmpty(), m_gui_type, m_top_widgets, recentFilesChanged(), Kwave::FileContext::release(), and Kwave::FileContext::setParent().

Referenced by Kwave::TopWidget::executeCommand(), and guiType().

{
    Q_ASSERT(top);
    if (!top) return;
    if (new_type == m_gui_type) return;

    // collect all contexts of all toplevel widgets, and delete all except
    // the new top widget that is calling us
    QList<Kwave::FileContext *> all_contexts;
    QMutableListIterator<Kwave::TopWidget *> it(m_top_widgets);
    while (it.hasNext()) {
        Kwave::TopWidget *topwidget = it.next();
        if (!topwidget) { it.remove(); continue; }
        QList<Kwave::FileContext *> contexts = topwidget->detachAllContexts();
        if (!contexts.isEmpty()) all_contexts += contexts;
        if (topwidget != top) {
            it.remove();
            delete topwidget;
        }
    }

    // from now on use the new GUI type
    m_gui_type = new_type;

    // at this point we should have exactly one toplevel widget without
    // context and a list of contexts (which may be empty)
    if (!all_contexts.isEmpty()) {
        bool first = true;
        foreach (Kwave::FileContext *context, all_contexts) {
            Kwave::TopWidget *top_widget = Q_NULLPTR;

            switch (m_gui_type) {
                case GUI_SDI:
                    if (!context->isEmpty() || (all_contexts.count() == 1)) {
                        // either the context contains some signal and is worth
                        // assigning it to a toplevel widget, or it is the one
                        // and only context
                        if (first) {
                            // the context reuses the calling toplevel widget
                            top_widget = top;
                            first = false;
                        } else {
                            // for all other contexts we have to create a new
                            // toplevel widget
                            top_widget = new(std::nothrow) Kwave::TopWidget(*this);
                            if (!top_widget || !top_widget->init()) {
                                // init failed
                                qWarning("ERROR: initialization of TopWidget failed");
                                delete top_widget;
                                delete context;
                            }
                            m_top_widgets.append(top_widget);
                            top_widget->show();

                            // inform the widget about changes in the list of
                            // recent files
                            connect(this, SIGNAL(recentFilesChanged()),
                                    top_widget, SLOT(updateRecentFiles()));
                        }
                    } else {
                        // probably this context is only executing a script and
                        // has (no longer) any valid signal. We need to assign
                        // it to a toplevel widget for processing further
                        // commands but reduce the reference count to make it
                        // vanish as soon as the script terminates.
                        context->setParent(top);
                        context->release();
                    }
                    break;
                case GUI_MDI: /* FALLTHROUGH */
                case GUI_TAB:
                    // all contexts go into the same toplevel widget
                    top_widget = top;
                    break;
            }

            if (top_widget) top_widget->insertContext(context);
        }
    } else {
        // give our one and only toplevel widget a default context
        top->insertContext(Q_NULLPTR);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

toplevelWindowHasClosed()

bool Kwave::App::toplevelWindowHasClosed

(

Kwave::TopWidget *

todel

)

Called when a toplevel window has closed.

Parameters

todel

the toplevel window that has closed

Returns

true if it was the last toplevel window

Definition at line 280 of file App.cpp.

References m_top_widgets, and saveRecentFiles().

Referenced by Kwave::TopWidget::~TopWidget().

{
    // save the list of recent files
    saveRecentFiles();

    // remove the toplevel widget from our list
    if (m_top_widgets.contains(todel))
        m_top_widgets.removeAll(todel);

    // if list is empty -> no more windows there -> exit application
    return (m_top_widgets.isEmpty());
}

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

Kwave::TopWidget

friend class Kwave::TopWidget

friend

Definition at line 152 of file App.h.

Member Data Documentation

m_cmdline

QCommandLineParser* Kwave::App::m_cmdline

private

reference to a (static) command line parser

Definition at line 179 of file App.h.

Referenced by cmdline(), newInstance(), and processCmdline().

m_gui_type

GuiType Kwave::App::m_gui_type

private

the GUI type, e.g. SDI or MDI

Definition at line 192 of file App.h.

Referenced by guiType(), newWindow(), processCmdline(), and switchGuiType().

m_recent_files

QStringList Kwave::App::m_recent_files

private

Local list of recent files. This list will be synchronized with the global list of recent files stored in the libkwave library whenever there is a change.

Definition at line 186 of file App.h.

Referenced by addRecentFile(), executeCommand(), readConfig(), recentFiles(), saveRecentFiles(), and ~App().

m_top_widgets

QList<Kwave::TopWidget *> Kwave::App::m_top_widgets

private

list of toplevel widgets

Definition at line 189 of file App.h.

Referenced by isOK(), newWindow(), openFiles(), switchGuiType(), and toplevelWindowHasClosed().

---

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

• kwave/App.h
• kwave/App.cpp