Reformat existing documentation to qdoc.
actions, mode windows and files, just to mention the most important ones.
\row
+ \o \l{ProjectExplorer}
+ \o The project explorer plugin. Provides base classes for
+ project handling.
+
+ \row
\o \l{Find}
\o Support for searching text in arbitrary widgets, and arbitrary other things.
../../src/plugins/find \
../../src/plugins/locator \
../../src/plugins/debugger \
- ../../src/plugins/vcsbase
+ ../../src/plugins/vcsbase \
+ ../../src/plugins/projectexplorer
sourcedirs = . \
../../src/libs/aggregation \
../../src/plugins/find \
../../src/plugins/locator \
../../src/plugins/debugger \
- ../../src/plugins/vcsbase
+ ../../src/plugins/vcsbase \
+ ../../src/plugins/projectexplorer
# -- Generate complete documentation. Set this to 'false'
# to generate public API documentation only.
#include <QtCore/QStringList>
#include <QtCore/QSysInfo>
+/*!
+ \class ProjectExplorer::Abi
+
+ \brief Represents the Application Binary Interface (ABI) of a target platform.
+
+ \sa ProjectExplorer::ToolChain
+*/
+
namespace ProjectExplorer {
// --------------------------------------------------------------------------
else if (abiParts.at(1) == QLatin1String("windows"))
m_os = WindowsOS;
else
+
return;
}
namespace ProjectExplorer {
// --------------------------------------------------------------------------
-// ABI
+// ABI (documentation inside)
// --------------------------------------------------------------------------
class PROJECTEXPLORER_EXPORT Abi
using namespace ProjectExplorer;
+/*!
+ \class ProjectExplorer::AbstractProcessStep
+
+ \brief A convenience class, which can be used as a base class instead of BuildStep.
+
+ It should be used as a base class if your buildstep just needs to run a process.
+
+ Usage:
+ \list
+ \o Use processParameters() to configure the process you want to run
+ (you need to do that before calling AbstractProcessStep::init()).
+ \o Inside YourBuildStep::init() call AbstractProcessStep::init().
+ \o Inside YourBuildStep::run() call AbstractProcessStep::run(), which automatically starts the proces
+ and by default adds the output on stdOut and stdErr to the OutputWindow.
+ \o If you need to process the process output override stdOut() and/or stdErr.
+ \endlist
+
+ The two functions processStarted() and processFinished() are called after starting/finishing the process.
+ By default they add a message to the output window.
+
+ Use setEnabled() to control whether the BuildStep needs to run. (A disabled BuildStep immediately returns true,
+ from the run function.)
+
+ \sa ProjectExplorer::ProcessParameters
+*/
+
+/*!
+ \fn void ProjectExplorer::AbstractProcessStep::setEnabled(bool b)
+
+ \brief Enables or disables a BuildStep.
+
+ Disabled BuildSteps immediately return true from their run method.
+ Should be called from init()
+*/
+
+/*!
+ \fn ProcessParameters *ProjectExplorer::AbstractProcessStep::processParameters()
+
+ \brief Obtain a reference to the parameters for the actual process to run.
+
+ Should be used in init()
+*/
+
AbstractProcessStep::AbstractProcessStep(BuildStepList *bsl, const QString &id) :
BuildStep(bsl, id), m_timer(0), m_futureInterface(0),
m_enabled(true), m_ignoreReturnValue(false),
delete m_outputParserChain;
}
+/*!
+ \brief Delete all existing output parsers and start a new chain with the
+ given parser.
+
+ Derived classes need to call this function.
+*/
+
void AbstractProcessStep::setOutputParser(ProjectExplorer::IOutputParser *parser)
{
delete m_outputParserChain;
}
}
+/*!
+ \brief Append the given output parser to the existing chain of parsers.
+*/
+
void AbstractProcessStep::appendOutputParser(ProjectExplorer::IOutputParser *parser)
{
if (!parser)
return m_outputParserChain;
}
+/*!
+ \brief If ignoreReturnValue is set to true, then the abstractprocess step will
+ return success even if the return value indicates otherwise.
+
+ Should be called from init.
+*/
+
void AbstractProcessStep::setIgnoreReturnValue(bool b)
{
m_ignoreReturnValue = b;
}
+/*!
+ \brief Reimplemented from BuildStep::init(). You need to call this from
+ YourBuildStep::init()
+*/
+
bool AbstractProcessStep::init()
{
return true;
}
+/*!
+ \brief Reimplemented from BuildStep::init(). You need to call this from YourBuildStep::run()
+*/
+
void AbstractProcessStep::run(QFutureInterface<bool> &fi)
{
m_futureInterface = &fi;
return;
}
+/*!
+ \brief Called after the process is started.
+
+ The default implementation adds a process started message to the output message
+*/
+
void AbstractProcessStep::processStarted()
{
emit addOutput(tr("Starting: \"%1\" %2")
BuildStep::MessageOutput);
}
+/*!
+ \brief Called after the process Finished.
+
+ The default implementation adds a line to the output window
+*/
+
void AbstractProcessStep::processFinished(int exitCode, QProcess::ExitStatus status)
{
QString command = QDir::toNativeSeparators(m_param.effectiveCommand());
}
}
+/*!
+ \brief Called if the process could not be started.
+
+ By default adds a message to the output window.
+*/
+
void AbstractProcessStep::processStartupFailed()
{
emit addOutput(tr("Could not start process \"%1\" %2")
BuildStep::ErrorMessageOutput);
}
+/*!
+ \brief Called to test whether a prcess succeeded or not.
+*/
+
bool AbstractProcessStep::processSucceeded(int exitCode, QProcess::ExitStatus status)
{
return exitCode == 0 && status == QProcess::NormalExit;
}
}
+/*!
+ \brief Called for each line of output on stdOut().
+
+ The default implementation adds the line to the application output window.
+*/
+
void AbstractProcessStep::stdOutput(const QString &line)
{
if (m_outputParserChain)
}
}
+/*!
+ \brief Called for each line of output on StdErrror().
+
+ The default implementation adds the line to the application output window
+*/
+
void AbstractProcessStep::stdError(const QString &line)
{
if (m_outputParserChain)
namespace ProjectExplorer {
class IOutputParser;
-
-/*!
- AbstractProcessStep is a convenience class, which can be used as a base class instead of BuildStep.
- It should be used as a base class if your buildstep just needs to run a process.
-
- Usage:
- Use processParameters() to configure the process you want to run
- (you need to do that before calling AbstractProcessStep::init()).
- Inside YourBuildStep::init() call AbstractProcessStep::init().
- Inside YourBuildStep::run() call AbstractProcessStep::run(), which automatically starts the proces
- and by default adds the output on stdOut and stdErr to the OutputWindow.
- If you need to process the process output override stdOut() and/or stdErr.
- The two functions processStarted() and processFinished() are called after starting/finishing the process.
- By default they add a message to the output window.
-
- Use setEnabled() to control whether the BuildStep needs to run. (A disabled BuildStep immediately returns true,
- from the run function.)
-
-*/
-
+// Documentation inside.
class PROJECTEXPLORER_EXPORT AbstractProcessStep : public BuildStep
{
Q_OBJECT
public:
virtual ~AbstractProcessStep();
- /// reimplemented from BuildStep::init()
- /// You need to call this from YourBuildStep::init()
virtual bool init();
- /// reimplemented from BuildStep::init()
- /// You need to call this from YourBuildStep::run()
virtual void run(QFutureInterface<bool> &);
virtual BuildStepConfigWidget *createConfigWidget() = 0;
virtual bool immutable() const = 0;
- /// enables or disables a BuildStep
- /// Disabled BuildSteps immediately return true from their run method
- /// should be called from init()
void setEnabled(bool b) { m_enabled = b; }
- /// obtain a reference to the parameters for the actual process to run.
- /// should be used in init()
ProcessParameters *processParameters() { return &m_param; }
- /// If ignoreReturnValue is set to true, then the abstractprocess step will
- /// return success even if the return value indicates otherwise
- /// should be called from init
void setIgnoreReturnValue(bool b);
- // derived classes needs to call this function
- /// Delete all existing output parsers and start a new chain with the
- /// given parser.
void setOutputParser(ProjectExplorer::IOutputParser *parser);
- /// Append the given output parser to the existing chain of parsers.
void appendOutputParser(ProjectExplorer::IOutputParser *parser);
ProjectExplorer::IOutputParser *outputParser() const;
AbstractProcessStep(BuildStepList *bsl, const QString &id);
AbstractProcessStep(BuildStepList *bsl, AbstractProcessStep *bs);
- /// Called after the process is started
- /// the default implementation adds a process started message to the output message
virtual void processStarted();
- /// Called after the process Finished
- /// the default implementation adds a line to the output window
virtual void processFinished(int exitCode, QProcess::ExitStatus status);
- /// Called if the process could not be started,
- /// by default adds a message to the output window
virtual void processStartupFailed();
- /// Called to test whether a prcess succeeded or not.
virtual bool processSucceeded(int exitCode, QProcess::ExitStatus status);
- /// Called for each line of output on stdOut()
- /// the default implementation adds the line to the
- /// application output window
virtual void stdOutput(const QString &line);
- /// Called for each line of output on StdErrror()
- /// the default implementation adds the line to the
- /// application output window
virtual void stdError(const QString &line);
private slots:
namespace ProjectExplorer {
struct ApplicationLauncherPrivate;
+// Documentation inside.
class PROJECTEXPLORER_EXPORT ApplicationLauncher : public QObject
{
Q_OBJECT
#include <QtCore/QTimer>
#include <QtCore/QTextCodec>
+/*!
+ \class ProjectExplorer::ApplicationLauncher
+
+ \brief Application launcher of the ProjectExplorer plugin.
+
+ Encapsulates processes running in a console or as GUI processes,
+ captures debug output of GUI processes on Windows (outputDebugString()).
+
+ \sa Utils::ConsoleProcess
+*/
+
namespace ProjectExplorer {
struct ApplicationLauncherPrivate {
#include <QtCore/QDir>
+/*!
+ \class ProjectExplorer::BaseProjectWizardDialog
+
+ \brief Base class for project wizards.
+
+ Presents the introductory page and takes care of setting the folder choosen
+ as default projects' folder should the user wish to do that.
+*/
+
namespace ProjectExplorer {
struct BaseProjectWizardDialogPrivate {
struct BaseProjectWizardDialogPrivate;
-/* BaseProjectWizardDialog: Presents the introductory
- * page and takes care of setting the directory as default
- * should the user wish to do that. */
-
+// Documentation inside.
class PROJECTEXPLORER_EXPORT BaseProjectWizardDialog : public Utils::Wizard
{
Q_OBJECT
using namespace ProjectExplorer;
-///
-/// RunConfigurationsModel
-///
+/*!
+ \class ProjectExplorer::BuildConfigurationModel
+ \brief A model to represent the build configurations of a target.
+
+ To be used in for the drop down of comboboxes.
+ Does automatically adjust itself to added and removed BuildConfigurations
+ Very similar to the Run Configuration Model.
+ TODO might it possible to share code without making the code a complete mess.
+*/
class BuildConfigurationComparer
{
class Target;
class BuildConfiguration;
-/*! A model to represent the build configurations of a target.
- To be used in for the drop down of comboboxes
- Does automatically adjust itself to added and removed BuildConfigurations
- Very similar to the Run Configuration Model
- TOOD might it possible to share code without making the code a complete mess
-*/
+// Documentation inside.
class BuildConfigurationModel : public QAbstractListModel
{
Q_OBJECT
#include "deployconfiguration.h"
#include "target.h"
+/*!
+ \class ProjectExplorer::BuildStep
+
+ \brief BuildSteps are the primary way plugin developers can customize
+ how their projects (or projects from other plugins) are build.
+
+ Building a project, is done by taking the list of buildsteps
+ from the project and calling first init() than run() on them.
+
+ That means to change the way your project is build, reimplemnt
+ this class and add your Step to the buildStep list of the project.
+
+ Note: The projects own the buildstep, do not delete them yourself.
+
+ init() is called in the GUI thread and can be used to query the
+ project for any information you need.
+
+ run() is run via QtConccurrent in a own thread, if you need an
+ eventloop you need to create it yourself!
+*/
+
+/*!
+ \fn bool ProjectExplorer::BuildStep::init()
+
+ This function is run in the gui thread,
+ use it to retrieve any information that you need in run()
+*/
+
+/*!
+ \fn void ProjectExplorer::BuildStep::run(QFutureInterface<bool> &fi)
+
+ Reimplement this. This function is called when the target is build.
+ This function is NOT run in the gui thread. It runs in its own thread
+ If you need an event loop, you need to create one.
+
+ The absolute minimal implementation is:
+ \code
+ fi.reportResult(true);
+ \endcode
+*/
+
+/*!
+ \fn BuildStepConfigWidget *ProjectExplorer::BuildStep::createConfigWidget()
+
+ Returns the Widget shown in the target settings dialog for this buildStep;
+ ownership is transferred to the caller.
+*/
+
+/*!
+ \fn bool ProjectExplorer::BuildStep::immutable() const
+
+ If this function returns true, the user can't delete this BuildStep for this target
+ and the user is prevented from changing the order immutable steps are run
+ the default implementation returns false.
+*/
+
+/*!
+ \fn void ProjectExplorer::BuildStep::addTask(const ProjectExplorer::Task &task)
+ \brief Add a task.
+*/
+
+/*!
+ \fn void addOutput(const QString &string, ProjectExplorer::BuildStep::OutputFormat format,
+ ProjectExplorer::BuildStep::OutputNewlineSetting newlineSetting)
+
+ The string is added to the generated output, usually in the output window.
+ It should be in plain text, with the format in the parameter.
+*/
+
using namespace ProjectExplorer;
BuildStep::BuildStep(BuildStepList *bsl, const QString &id) :
class DeployConfiguration;
class Target;
-/*
-// BuildSteps are the primary way plugin developers can customize
-// how their projects (or projects from other plugins) are build.
-//
-// Building a project, is done by taking the list of buildsteps
-// from the project and calling first init() than run() on them.
-//
-// That means to change the way your project is build, reimplemnt
-// this class and add your Step to the buildStep list of the project.
-//
-// Note: The projects own the buildstep, do not delete them yourself.
-//
-// init() is called in the GUI thread and can be used to query the
-// project for any information you need.
-//
-// run() is run via QtConccurrent in a own thread, if you need an
-// eventloop you need to create it yourself!
-//
-*/
-
class BuildStepConfigWidget;
+// Documentation inside.
class PROJECTEXPLORER_EXPORT BuildStep : public ProjectConfiguration
{
Q_OBJECT
public:
virtual ~BuildStep();
- // This function is run in the gui thread,
- // use it to retrieve any information that you need in run()
virtual bool init() = 0;
- // Reimplement this. This function is called when the target is build.
- // This function is NOT run in the gui thread. It runs in its own thread
- // If you need an event loop, you need to create one.
- // The absolute minimal implementation is:
- // fi.reportResult(true);
virtual void run(QFutureInterface<bool> &fi) = 0;
- // the Widget shown in the target settings dialog for this buildStep
- // ownership is transferred to the caller
virtual BuildStepConfigWidget *createConfigWidget() = 0;
- // if this function returns true, the user can't delete this BuildStep for this target
- // and the user is prevented from changing the order immutable steps are run
- // the default implementation returns false
virtual bool immutable() const;
BuildConfiguration *buildConfiguration() const;
enum OutputNewlineSetting { DoAppendNewline, DontAppendNewline };
signals:
- // Add a task.
void addTask(const ProjectExplorer::Task &task);
- // The string is added to the generated output, usually in the output
- // window.
- // It should be in plain text, with the format in the parameter
void addOutput(const QString &string, ProjectExplorer::BuildStep::OutputFormat format,
ProjectExplorer::BuildStep::OutputNewlineSetting newlineSetting = DoAppendNewline);
};
namespace ProjectExplorer {
+/*!
+ \class ProjectExplorer::ICustomWizardFactory
+ \brief Factory for creating custom wizards extending the base class
+ (CustomWizard or CustomProjectWizard)
+
+ The factory can be registered under a name in CustomWizard. The name can
+ be specified in the \c <wizard class=''...> attribute in the \c wizard.xml file
+ and thus allows for specifying a C++ derived wizard class.
+ For example, this is currently used in Qt4ProjectManager to get Qt-specific
+ aspects into the custom wizard.
+
+ \sa ProjectExplorer::CustomWizard, ProjectExplorer::CustomProjectWizard
+*/
+
struct CustomWizardPrivate {
CustomWizardPrivate() : m_context(new Internal::CustomWizardContext) {}
int CustomWizardPrivate::verbose = 0;
+/*!
+ \class ProjectExplorer::CustomWizard
+
+ \brief Base classes for custom wizards based on file templates and a XML
+ configuration file (\c share/qtcreator/templates/wizards).
+
+ Presents CustomWizardDialog (fields page containing path control) for wizards
+ of type "class" or "file". Serves as base class for project wizards.
+*/
+
CustomWizard::CustomWizard(const Core::BaseFileWizardParameters& baseFileParameters,
QObject *parent) :
Core::BaseFileWizard(baseFileParameters, parent),
return rc;
}
-// Scan the subdirectories of the template directory for directories
-// containing valid configuration files and parse them into wizards.
+/*!
+ \brief Reads \c share/qtcreator/templates/wizards and creates all custom wizards.
+
+ As other plugins might register factories for derived
+ classes, call it in extensionsInitialized().
+
+ Scans the subdirectories of the template directory for directories
+ containing valid configuration files and parse them into wizards.
+*/
+
QList<CustomWizard*> CustomWizard::createWizards()
{
QList<CustomWizard*> rc;
return rc;
}
-// --------------- CustomProjectWizard
+/*!
+ \class ProjectExplorer::CustomProjectWizard
+ \brief A custom project wizard.
+
+ Presents a CustomProjectWizardDialog (Project intro page and fields page)
+ for wizards of type "project".
+ Overwrites postGenerateFiles() to open the project files according to the
+ file attributes. Also inserts \c '%ProjectName%' into the base
+ replacement map once the intro page is left to have it available
+ for QLineEdit-type fields' default text.
+*/
CustomProjectWizard::CustomProjectWizard(const Core::BaseFileWizardParameters& baseFileParameters,
QObject *parent) :
{
}
+/*!
+ \brief Can be reimplemented to create custom project wizards.
+
+ initProjectWizardDialog() needs to be called.
+*/
+
QWizard *CustomProjectWizard::createWizardDialog(QWidget *parent,
const QString &defaultPath,
const WizardPageList &extensionPages) const
return generatedFiles;
}
+/*!
+ \brief Utility to open the projects and editors for the files that have
+ the respective attributes set.
+*/
+
bool CustomProjectWizard::postGenerateOpen(const Core::GeneratedFiles &l, QString *errorMessage)
{
// Post-Generate: Open the project and the editors as desired
struct CustomWizardContext;
}
-// Factory for creating custom wizards derived from the base classes
-// The factory can be registered under a name in CustomWizard. The name can
-// be specified in the <wizard class=''...> attribute in the wizard.xml file
-// and thus allows for specifying a C++ derived wizard class (see Qt4ProjectManager).
-
+// Documentation inside.
class ICustomWizardFactory {
public:
virtual CustomWizard *create(const Core::BaseFileWizardParameters& baseFileParameters,
{ return new Wizard(baseFileParameters, parent); }
};
-// A custom wizard presenting CustomWizardDialog (fields page containing
-// path control) for wizards of type "class" or "file". Serves as base class
-// for project wizards.
-
+// Documentation inside.
class PROJECTEXPLORER_EXPORT CustomWizard : public Core::BaseFileWizard
{
Q_OBJECT
CustomWizardPrivate *d;
};
-// A custom project wizard presenting CustomProjectWizardDialog
-// (Project intro page and fields page) for wizards of type "project".
-// Overwrites postGenerateFiles() to open the project files according to the
-// file attributes. Also inserts '%ProjectName%' into the base
-// replacement map once the intro page is left to have it available
-// for QLineEdit-type fields' default text.
-
+// Documentation inside.
class PROJECTEXPLORER_EXPORT CustomProjectWizard : public CustomWizard
{
Q_OBJECT
explicit CustomProjectWizard(const Core::BaseFileWizardParameters& baseFileParameters,
QObject *parent = 0);
- // Can be reimplemented to create custom project wizards.
- // initProjectWizardDialog() needs to be called.
virtual QWizard *createWizardDialog(QWidget *parent,
const QString &defaultPath,
const WizardPageList &extensionPages) const;
virtual Core::GeneratedFiles generateFiles(const QWizard *w, QString *errorMessage) const;
- // Utility to open the projects and editors for the files that have
- // the respective attributes set.
static bool postGenerateOpen(const Core::GeneratedFiles &l, QString *errorMessage = 0);
signals:
namespace Internal {
// ----------- TextFieldComboBox
+
+/*!
+ \class ProjectExplorer::Internal::TextFieldComboBox
+ \brief A non-editable combo for text editing purposes that plays
+ with QWizard::registerField (providing a settable 'text' property).
+
+ Allows for a separation of values to be used for wizard fields replacement
+ and display texts.
+
+ \sa ProjectExplorer::Internal::CustomWizardFieldPage, ProjectExplorer::CustomWizard
+*/
+
TextFieldComboBox::TextFieldComboBox(QWidget *parent) :
QComboBox(parent)
{
return i >= 0 && i < count() ? itemData(i, Qt::UserRole).toString() : QString();
}
-// -------------- TextCheckBox
+/*!
+ \class ProjectExplorer::Internal::TextFieldCheckBox
+ \brief A Checkbox that plays with QWizard::registerField.
+
+ Provides a settable 'text' property containing predefined strings for 'true'/'false').
+
+ \sa ProjectExplorer::Internal::CustomWizardFieldPage, ProjectExplorer::CustomWizard
+*/
+
TextFieldCheckBox::TextFieldCheckBox(const QString &text, QWidget *parent) :
QCheckBox(text, parent),
m_trueText(QLatin1String("true")), m_falseText(QLatin1String("false"))
emit textChanged(cs == Qt::Checked ? m_trueText : m_falseText);
}
-// --------------- CustomWizardFieldPage
+/*!
+ \class ProjectExplorer::Internal::CustomWizardFieldPage
+ \brief A simple custom wizard page presenting the fields to be used
+ as page 2 of a BaseProjectWizardDialog if there are any fields.
+
+ Uses the 'field' functionality of QWizard.
+ Implements validatePage() as the field logic cannot be tied up
+ with additional validation. Performs checking of the Javascript-based
+ validation rules of the parameters and displays error messages in a red
+ warning label.
+
+ \sa ProjectExplorer::CustomWizard
+*/
CustomWizardFieldPage::LineEditData::LineEditData(QLineEdit* le, const QString &defText) :
lineEdit(le), defaultText(defText)
m_errorLabel->setVisible(false);
}
-// Create widget a control based on the control attributes map
-// and register it with the QWizard.
+/*!
+ \brief Create widget a control based on the control attributes map
+ and register it with the QWizard.
+*/
+
void CustomWizardFieldPage::addField(const CustomWizardField &field)\
{
// Register field, indicate mandatory by '*' (only when registering)
return fieldReplacementMap;
}
-// --------------- CustomWizardPage
+/*!
+ \class ProjectExplorer::Internal::CustomWizardPage
+ \brief A custom wizard page presenting the fields to be used and a path chooser
+ at the bottom (for use by "class"/"file" wizards).
+
+ Does validation on the Path chooser only (as the other fields can by validated by regexps).
+
+ \sa ProjectExplorer::CustomWizard
+*/
CustomWizardPage::CustomWizardPage(const QSharedPointer<CustomWizardContext> &ctx,
const QSharedPointer<CustomWizardParameters> ¶meters,
struct CustomWizardParameters;
struct CustomWizardContext;
-// A non-editable combo for text editing purposes that plays
-// with QWizard::registerField (providing a settable 'text' property).
-// Allows for a separation of values to be used for wizard fields replacement
-// and display texts.
+// Documentation inside.
class TextFieldComboBox : public QComboBox {
Q_PROPERTY(QString text READ text WRITE setText)
Q_OBJECT
inline QString valueAt(int) const;
};
-// A Checkbox that plays with QWizard::registerField (providing a settable
-// 'text' property containing predefined strings for 'true'/'false').
+// Documentation inside.
class TextFieldCheckBox : public QCheckBox {
Q_PROPERTY(QString text READ text WRITE setText)
Q_PROPERTY(QString trueText READ trueText WRITE setTrueText)
QString m_falseText;
};
-// A simple custom wizard page presenting the fields to be used
-// as page 2 of a BaseProjectWizardDialog if there are any fields.
-// Uses the 'field' functionality of QWizard.
-// Implements validatePage() as the field logic cannot be tied up
-// with additional validation. Performs checking of the Javascript-based
-// validation rules of the parameters and displays error messages in a red
-// warning label.
+// Documentation inside.
class CustomWizardFieldPage : public QWizardPage {
Q_OBJECT
public:
QLabel *m_errorLabel;
};
-// A custom wizard page presenting the fields to be used and a path chooser
-// at the bottom (for use by "class"/"file" wizards). Does validation on
-// the Path chooser only (as the other fields can by validated by regexps).
-
+// Documentation inside.
class CustomWizardPage : public CustomWizardFieldPage {
Q_OBJECT
public:
{
}
+/*!
+ \class ProjectExplorer::CustomWizardValidationRule
+ \brief A custom wizard validation rule based on JavaScript-expressions over
+ the field placeholders.
+
+ Placeholder replacement is performed on the condition and it is evaluated
+ using JavaScript. So, for example '"%ProjectName%" != "untitled" would block
+ default names. On failure, the message is displayed in a red warning label
+ in the wizard page. Placeholder replacement is also performed on the message
+ prior to displaying.
+
+ \sa ProjectExplorer::CustomWizard, ProjectExplorer::CustomWizardFieldPage
+*/
+
bool CustomWizardValidationRule::validateRules(const QList<CustomWizardValidationRule> &rules,
const QMap<QString, QString> &replacementMap,
QString *errorMessage)
return name;
}
+/*!
+ \class ProjectExplorer::Internal::GeneratorScriptArgument
+ \brief Argument to a custom wizard generator script.
+
+ Contains placeholders to be replaced by field values or file names
+ as in \c '--class-name=%ClassName%' or \c '--description=%Description%'.
+
+ \sa ProjectExplorer::CustomWizard
+*/
+
GeneratorScriptArgument::GeneratorScriptArgument(const QString &v) :
value(v), flags(0)
{
return nonEmptyReplacements;
}
+/*!
+ \brief Performs field replacements.
+
+ Replace field values delimited by '%' with special modifiers:
+ \list
+ \o %Field% -> simple replacement
+ \o %Field:l% -> replace with everything changed to lower case
+ \o %Field:u% -> replace with everything changed to upper case
+ \o %Field:c% -> replace with first character capitalized
+ \o %Field:h% -> replace with something usable as header guard
+ \o %Field:s% -> replace with something usable as structure or class name
+ \endlist
+
+ The return value indicates whether non-empty replacements were encountered.
+*/
+
bool CustomWizardContext::replaceFields(const FieldReplacementMap &fm, QString *s)
{
return replaceFieldHelper(passThrough, fm, s);
return name;
}
+/*!
+ \class ProjectExplorer::Internal::CustomWizardContext
+ \brief Context used for one custom wizard run.
+
+ Shared between CustomWizard and the CustomWizardPage as it is used
+ for the QLineEdit-type fields'
+ default texts as well. Contains basic replacement fields
+ like \c '%CppSourceSuffix%', \c '%CppHeaderSuffix%' (settings-dependent)
+ reset() should be called before each wizard run to refresh them.
+ CustomProjectWizard additionally inserts \c '%ProjectName%' from
+ the intro page to have it available for default texts.
+
+ \sa ProjectExplorer::CustomWizard
+*/
+
+/*!
+ \brief Special replaceFields() overload used for the arguments of a generator
+ script.
+
+ Write the expanded field values out to temporary files and
+ inserts file names instead of the expanded fields in string 's'.
+*/
+
bool CustomWizardContext::replaceFields(const FieldReplacementMap &fm, QString *s,
TemporaryFilePtrList *files)
{
bool binary;
};
-// A validation rule based on Javascript-expressions over the field placeholders.
-// Placeholder replacement is performed on the condition and it is evaluated
-// using Javascript. So, for example '"%ProjectName%" != "untitled" would block
-// default names. On failure, the message is displayed in a red warning label
-// in the wizard page. Placeholder replacement is also performed on the message
-// prior to displaying.
+// Documentation inside.
struct CustomWizardValidationRule {
// Validate a set of rules and return false + message on the first failing one.
static bool validateRules(const QList<CustomWizardValidationRule> &rules,
QString message;
};
-// Argument to the generator script containing placeholders to
-// be replaced by field values or file names
-// as in '--class-name=%ClassName%' or '--description=%Description%'.
+// Documentation inside.
struct GeneratorScriptArgument {
enum Flags {
// Omit this arguments if all field placeholders expanded to empty strings.
int firstPageId;
};
-// Context used for one wizard run, shared between CustomWizard
-// and the CustomWizardPage as it is used for the QLineEdit-type fields'
-// default texts as well. Contains basic replacement fields
-// like '%CppSourceSuffix%', '%CppHeaderSuffix%' (settings-dependent)
-// reset() should be called before each wizard run to refresh them.
-// CustomProjectWizard additionally inserts '%ProjectName%' from
-// the intro page to have it available for default texts.
-
+// Documentation inside.
struct CustomWizardContext {
typedef QMap<QString, QString> FieldReplacementMap;
typedef QSharedPointer<QTemporaryFile> TemporaryFilePtr;
void reset();
- // Replace field values delimited by '%' with special modifiers:
- // %Field% -> simple replacement
- // %Field:l% -> replace with everything changed to lower case
- // %Field:u% -> replace with everything changed to upper case
- // %Field:c% -> replace with first character capitalized
- // %Field:h% -> replace with something usable as header guard
- // %Field:s% -> replace with something usable as structure or class name
- // The return value indicates whether non-empty
- // replacements were encountered.
static bool replaceFields(const FieldReplacementMap &fm, QString *s);
-
- // Special replaceFields() overload used for the arguments of a generator
- // script: Write the expanded field values out to temporary files and
- // inserts file names instead of the expanded fields in string 's'.
static bool replaceFields(const FieldReplacementMap &fm, QString *s,
TemporaryFilePtrList *files);
*errorMessage = msgEmptyStack(l);
return false;
}
- QString expression;
+ QString expression;
bool expressionValue = false;
PreprocessStackEntry &top = m_sectionStack.back();
return true;
}
+/*!
+ \brief Custom wizard preprocessor based on JavaScript expressions.
+
+ Preprocess a string using simple syntax:
+ \code
+Text
+@if <JavaScript-expression>
+Bla...
+@elsif <JavaScript-expression2>
+Blup
+@endif
+\endcode
+
+ The JavaScript-expressions must evaluate to integers or boolean, like
+ \c '2 == 1 + 1', \c '"a" == "a"'. The variables of the custom wizard will be
+ expanded before, so , \c "%VAR%" should be used for strings and \c %VAR% for integers.
+
+ \sa ProjectExplorer::CustomWizard
+*/
+
bool customWizardPreprocess(const QString &in, QString *out, QString *errorMessage)
{
PreprocessContext context;
namespace ProjectExplorer {
namespace Internal {
-/* Preprocess a string using simple syntax: \code
-
-Text
-@if <JavaScript-expression>
-Bla...
-@elsif <JavaScript-expression2>
-Blup
-@endif
-\endcode
-
-* JavaScript-expressions must evaluate to integers or boolean, like
-* '2 == 1 + 1', '"a" == "a"'. The variables of the custom wizard will be
-* expanded beforem, so , "%VAR%" should be used for strings and %VAR% for integers.
-*/
-
bool customWizardPreprocess(const QString &in, QString *out, QString *errorMessage);
/* Helper to evaluate an expression. */
bool evaluateBooleanJavaScriptExpression(QScriptEngine &engine, const QString &expression, bool *result, QString *errorMessage);
return true;
}
-// Do a dry run of the generation script to get a list of files
+/*!
+ \brief Custom wizard script generator function (Step1) - dry run.
+
+ Do a dry run of the generation script to get a list of files
+ \sa runCustomWizardGeneratorScript, ProjectExplorer::CustomWizard
+*/
+
Core::GeneratedFiles
dryRunCustomWizardGeneratorScript(const QString &targetPath,
const QStringList &script,
return files;
}
+/*!
+ \brief Custom wizard script generator function (Step2) - actual file creation.
+
+ In addition to the <file> elements
+ that define template files in which macros are replaced, it is possible to have
+ a custom wizard call a generation script (specified in the "generatorscript"
+ attribute of the <files> element) which actually creates files.
+ The command line of the script must follow the convention
+ \code
+ script [--dry-run] [options]
+ \endcode
+
+ Options containing field placeholders are configured in the XML files
+ and will be passed with them replaced by their values.
+
+ As Qt Creator needs to know the file names before actually creates them to
+ do overwrite checking etc., this is 2-step process:
+ \list
+ \o Determine file names and attributes: The script is called with the
+ \c --dry-run option and the field values. It then prints the relative path
+ names it intends to create followed by comma-separated attributes
+ matching those of the \c <file> element, for example:
+ \c myclass.cpp,openeditor
+ \o The script is called with the parameters only in the working directory
+ and then actually creates the files. If that involves directories, the script
+ should create those, too.
+ \endlist
+
+ \sa dryRunCustomWizardGeneratorScript, ProjectExplorer::CustomWizard
+ */
+
bool runCustomWizardGeneratorScript(const QString &targetPath,
const QStringList &script,
const QList<GeneratorScriptArgument> &arguments,
struct GeneratorScriptArgument;
-/* Custom wizard script generator functions. In addition to the <file> elements
- * that define template files in which macros are replaced, it is possible to have
- * a custom wizard call a generation script (specified in the "generatorscript"
- * attribute of the <files> element) which actually creates files.
- * The command line of the script must follow the convention
- *
- * script [--dry-run] [options]
- *
- * Options containing field placeholders are configured in the XML files
- * and will be passed with them replaced by their values.
- *
- * As Qt Creator needs to know the file names before actually creates them to
- * do overwrite checking etc., this is 2-step process:
- * 1) Determine file names and attributes: The script is called with the
- * --dry-run option and the field values. It then prints the relative path
- * names it intends to create followed by comma-separated attributes
- * matching those of the <file> element, for example:
- * myclass.cpp,openeditor
- * 2) The script is called with the parameters only in the working directory
- * and then actually creates the files. If that involves directories, the script
- * should create those, too.
- */
-
// Parse the script arguments apart and expand the binary.
QStringList fixGeneratorScript(const QString &configFile, QString attributeIn);
using namespace ProjectExplorer;
-///
-/// DeployConfigurationsModel
-///
+/*!
+ \class ProjectExplorer::DeployConfigurationModel
+
+ \brief A model to represent the run configurations of a target.
+
+ To be used in for the drop down of comboboxes. Does automatically adjust
+ itself to added and removed DeployConfigurations
+*/
class DeployConfigurationComparer
{
class Target;
class DeployConfiguration;
-/*! A model to represent the run configurations of a target.
- To be used in for the drop down of comboboxes
- Does automatically adjust itself to added and removed RunConfigurations
-*/
+// Documentation inside.
class DeployConfigurationModel : public QAbstractListModel
{
Q_OBJECT
#include <utils/qtcassert.h>
+/*!
+ \class ProjectExplorer::IOutputParser
+
+ \brief Interface for an output parser that emit build issues (tasks).
+
+ \sa ProjectExplorer::Task
+*/
+
+/*!
+ \fn void ProjectExplorer::IOutputParser::appendOutputParser(IOutputParser *parser)
+
+ \brief Append a subparser to this parser, of which IOutputParser will take ownership.
+*/
+
+/*!
+ \fn IOutputParser *ProjectExplorer::IOutputParser::takeOutputParserChain()
+
+ \brief Remove the appended outputparser chain from this parser, transferring
+ ownership of the parser chain to the caller.
+*/
+
+/*!
+ \fn IOutputParser *ProjectExplorer::IOutputParser::childParser() const
+
+ \brief Return the head of this parsers output parser children, IOutputParser keeps ownership.
+*/
+
+/*!
+ \fn void ProjectExplorer::IOutputParser::stdOutput(const QString &line)
+
+ \brief Called once for each line if standard output to parse.
+*/
+
+/*!
+ \fn void ProjectExplorer::IOutputParser::stdError(const QString &line)
+
+ \brief Called once for each line if standard error to parse.
+*/
+
+/*!
+ \fn bool ProjectExplorer::IOutputParser::hasFatalErrors() const
+
+ \brief This is mainly a symbian specific quirk.
+*/
+
+/*!
+ \fn void ProjectExplorer::IOutputParser::addOutput(const QString &string, ProjectExplorer::BuildStep::OutputFormat format)
+
+ \brief Should be emitted whenever some additional information should be added to the output.
+
+ Note: This is additional information. There is no need to add each line!
+*/
+
+/*!
+ \fn void ProjectExplorer::IOutputParser::addTask(const ProjectExplorer::Task &task)
+
+ \brief Should be emitted for each task seen in the output.
+*/
+
+/*!
+ \fn void ProjectExplorer::IOutputParser::outputAdded(const QString &string, ProjectExplorer::BuildStep::OutputFormat format)
+
+ \brief Subparsers have their addOutput signal connected to this slot.
+*/
+
+/*!
+ \fn void ProjectExplorer::IOutputParser::outputAdded(const QString &string, ProjectExplorer::BuildStep::OutputFormat format)
+
+ \brief This method can be overwritten to change the string.
+*/
+
+/*!
+ \fn void ProjectExplorer::IOutputParser::taskAdded(const ProjectExplorer::Task &task)
+
+ \brief Subparsers have their addTask signal connected to this slot.
+ This method can be overwritten to change the task.
+*/
+
namespace ProjectExplorer {
IOutputParser::IOutputParser() : m_parser(0)
namespace ProjectExplorer {
class Task;
+// Documentation inside.
class PROJECTEXPLORER_EXPORT IOutputParser : public QObject
{
Q_OBJECT
IOutputParser();
virtual ~IOutputParser();
- /// Append a subparser to this parser.
- /// IOutputParser will take ownership.
virtual void appendOutputParser(IOutputParser *parser);
- /// Remove the appended outputparser chain frm this parser.
- /// This method transferes ownership of the parser chain to the caller!
IOutputParser *takeOutputParserChain();
- /// Return the head of this parsers output parser children
- /// IOutputParser keeps ownership!
IOutputParser *childParser() const;
void setChildParser(IOutputParser *parser);
- /// Called once for each line if standard output to parse.
virtual void stdOutput(const QString &line);
- /// Called once for each line if standard error to parse.
virtual void stdError(const QString &line);
- // This is mainly a symbian specific quirk
virtual bool hasFatalErrors() const;
// For GnuMakeParser
virtual void setWorkingDirectory(const QString &workingDirectory);
signals:
- /// Should be emitted whenever some additional information should be
- /// added to the output.
- /// Note: This is additional information. There is no need to add each
- /// line!
void addOutput(const QString &string, ProjectExplorer::BuildStep::OutputFormat format);
- /// Should be emitted for each task seen in the output.
void addTask(const ProjectExplorer::Task &task);
public slots:
- /// Subparsers have their addOutput signal connected to this slot.
- /// This method can be overwritten to change the string.
virtual void outputAdded(const QString &string, ProjectExplorer::BuildStep::OutputFormat format);
- /// Subparsers have their addTask signal connected to this slot.
- /// This method can be overwritten to change the task.
virtual void taskAdded(const ProjectExplorer::Task &task);
private:
using namespace ProjectExplorer;
using namespace ProjectExplorer::Internal;
+/*!
+ \class ProjectExplorer::Internal::ProjectFileFactory
+
+ \brief Factory for project files.
+*/
+
ProjectFileFactory::ProjectFileFactory(IProjectManager *manager)
: m_mimeTypes(manager->mimeType()),
m_manager(manager)
namespace Internal {
-/* Factory for project files. */
-
class ProjectFileFactory : public Core::IFileFactory
{
Q_OBJECT
#include <QtCore/QFileInfo>
#include <QtCore/QDir>
+/*!
+ \class ProjectExplorer::ProcessParameters
+
+ \brief ProcessParameters aggregates all parameters needed to start a process.
+
+ It offers a set of functions which expand macros and environment variables
+ inside the raw parameters to obtain final values for starting a process
+ or for display purposes.
+
+ \sa ProjectExplorer::AbstractProcessStep
+*/
+
using namespace ProjectExplorer;
ProcessParameters::ProcessParameters() :
{
}
+/*!
+ \brief Sets the executable to run.
+*/
+
void ProcessParameters::setCommand(const QString &cmd)
{
m_command = cmd;
m_effectiveCommand.clear();
}
+/*!
+ \brief Sets the command line arguments used by the process
+*/
+
void ProcessParameters::setArguments(const QString &arguments)
{
m_arguments = arguments;
m_effectiveArguments.clear();
}
+/*!
+ \brief Sets the workingDirectory for the process for a buildConfiguration
+ should be called from init()
+*/
+
void ProcessParameters::setWorkingDirectory(const QString &workingDirectory)
{
m_workingDirectory = workingDirectory;
m_effectiveWorkingDirectory.clear();
}
+/*!
+ \fn void ProjectExplorer::ProcessParameters::setEnvironment(const Utils::Environment &env)
+ \brief Set the Environment for running the command
+
+ Should be called from init()
+*/
+
+/*!
+ \fn void ProjectExplorer::ProcessParameters::setMacroExpander(Utils::AbstractMacroExpander *mx)
+ \brief Set the macro expander to use on the command, arguments and working dir.
+
+ Note that the caller retains ownership of the object.
+*/
+
+/*!
+ \brief Get the fully expanded working directory.
+*/
+
QString ProcessParameters::effectiveWorkingDirectory() const
{
if (m_effectiveWorkingDirectory.isEmpty()) {
return m_effectiveWorkingDirectory;
}
+/*!
+ \brief Get the fully expanded command name to run
+*/
+
QString ProcessParameters::effectiveCommand() const
{
if (m_effectiveCommand.isEmpty()) {
return m_effectiveCommand;
}
+/*!
+ \brief True if effectiveCommand() would return only a fallback.
+*/
+
bool ProcessParameters::commandMissing() const
{
effectiveCommand();
namespace ProjectExplorer {
-/*!
- ProcessParameters aggregates all parameters needed to start a process.
-
- It offers a set of functions which expand macros and environment variables
- inside the raw parameters to obtain final values for starting a process
- or for display purposes.
-*/
-
+// Documentation inside.
class PROJECTEXPLORER_EXPORT ProcessParameters
{
public:
ProcessParameters();
- /// setCommand() sets the executable to run
void setCommand(const QString &cmd);
QString command() const { return m_command; }
- /// sets the command line arguments used by the process
void setArguments(const QString &arguments);
QString arguments() const { return m_arguments; }
- /// sets the workingDirectory for the process for a buildConfiguration
- /// should be called from init()
void setWorkingDirectory(const QString &workingDirectory);
QString workingDirectory() const { return m_workingDirectory; }
- /// Set the Environment for running the command
- /// should be called from init()
void setEnvironment(const Utils::Environment &env) { m_environment = env; }
Utils::Environment environment() const { return m_environment; }
- /// Set the macro expander to use on the command, arguments and working dir.
- /// Note that the caller retains ownership of the object.
void setMacroExpander(Utils::AbstractMacroExpander *mx) { m_macroExpander = mx; }
Utils::AbstractMacroExpander *macroExpander() const { return m_macroExpander; }
#include <limits>
#include <utils/qtcassert.h>
+/*!
+ \class ProjectExplorer::Project
+
+ \brief A project.
+*/
+
+/*!
+ \fn void ProjectExplorer::Project::environmentChanged()
+
+ \brief Convenience signal emitted if the activeBuildConfiguration emits environmentChanged
+ or if the activeBuildConfiguration changes (including due to the active target changing).
+*/
+
+/*!
+ \fn void ProjectExplorer::Project::buildConfigurationEnabledChanged()
+
+ \brief Convenience signal emitted if the activeBuildConfiguration emits isEnabledChanged()
+ or if the activeBuildConfiguration changes (including due to the active target changing).
+*/
+
namespace {
const char * const ACTIVE_TARGET_KEY("ProjectExplorer.Project.ActiveTarget");
const char * const TARGET_KEY_PREFIX("ProjectExplorer.Project.Target.");
return QList<BuildConfigWidget*>();
}
+/*!
+ \brief Serialize all data into a QVariantMap.
+
+ This map is then saved in the .user file of the project.
+ Just put all your data into the map.
+
+ \note Do not forget to call your base class' toMap method.
+ \note Do not forget to call setActiveBuildConfiguration when
+ creating new BuilConfigurations.
+*/
+
QVariantMap Project::toMap() const
{
const QList<Target *> ts = targets();
class Target;
class ProjectPrivate;
+// Documentation inside.
class PROJECTEXPLORER_EXPORT Project
: public QObject
{
static QString makeUnique(const QString &preferedName, const QStringList &usedNames);
- // Serialize all data into a QVariantMap. This map is then saved
- // in the .user file of the project.
- //
- // Just put all your data into the map.
- //
- // Note: Do not forget to call your base class' toMap method.
- // Note: Do not forget to call setActiveBuildConfiguration when
- // creating new BuilConfigurations.
virtual QVariantMap toMap() const;
// The directory that holds the project file. This includes the absolute path.
void removedTarget(ProjectExplorer::Target *target);
void addedTarget(ProjectExplorer::Target *target);
- /// convenience signal emitted if the activeBuildConfiguration emits environmentChanged
- /// or if the activeBuildConfiguration changes
- /// (including due to the active target changing).
void environmentChanged();
-
- /// convenience signal emitted if the activeBuildConfiguration emits isEnabledChanged()
- /// or if the activeBuildConfiguration changes
- /// (including due to the active target changing).
void buildConfigurationEnabledChanged();
protected:
#include <QtGui/QMainWindow>
#include <QtGui/QWizard>
+/*!
+ \namespace ProjectExplorer
+ ProjectExplorer plugin namespace
+*/
+
+/*!
+ \namespace ProjectExplorer::Internal
+ Internal namespace of the ProjectExplorer plugin
+ \internal
+*/
+
+/*!
+ \class ProjectExplorer::ProjectExplorerPlugin
+
+ \brief ProjectExplorerPlugin with static accessor and utility functions to obtain
+ current project, open projects, etc.
+*/
+
Q_DECLARE_METATYPE(Core::IEditorFactory*)
Q_DECLARE_METATYPE(Core::IExternalEditor*)
struct ProjectExplorerSettings;
+// Documentation inside.
class ProjectExplorerSettingsWidget : public QWidget {
Q_OBJECT
public:
#include <QtCore/QMultiMap>
#include <QtCore/QDir>
+/*!
+ \class ProjectExplorer::Internal::ProjectFileWizardExtension
+
+ \brief Post-file generating steps of a project wizard.
+
+ Offers:
+ \list
+ \o Add to a project file (*.pri/ *.pro)
+ \o Initialize a version control repository (unless the path is already
+ managed) and do 'add' if the VCS supports it.
+ \endlist
+
+ \sa ProjectExplorer::Internal::ProjectWizardPage
+*/
+
enum { debugExtension = 0 };
namespace ProjectExplorer {
struct ProjectWizardContext;
-/* Final file wizard processing steps:
- * 1) Add to a project file (*.pri/ *.pro)
- * 2) Initialize a version control repository (unless the path is already
- * managed) and do 'add' if the VCS supports it. */
class ProjectFileWizardExtension : public Core::IFileWizardExtension
{
Q_OBJECT
using namespace ProjectExplorer;
/*!
- \class FileNode
+ \class ProjectExplorer::Node
- Base class of all nodes in the node hierarchy.
+ \brief Base class of all nodes in the node hierarchy.
- \see FileNode
- \see FolderNode
- \see ProjectNode
+ The nodes are arranged in a tree where leaves are FileNodes and non-leaves are FolderNodes
+ A Project is a special Folder that manages the files and normal folders underneath it.
+
+ The Watcher emits signals for structural changes in the hierarchy.
+ A Visitor can be used to traverse all Projects and other Folders.
+
+ \sa ProjectExplorer::FileNode, ProjectExplorer::FolderNode, ProjectExplorer::ProjectNode
+ \sa ProjectExplorer::NodesWatcher, ProjectExplorer::NodesVisitor
*/
+
Node::Node(NodeType nodeType,
const QString &filePath)
: QObject(),
}
/*!
- Project that owns & manages the node. It's the first project in list of ancestors.
+ \brief Project that owns & manages the node. It's the first project in list of ancestors.
*/
ProjectNode *Node::projectNode() const
{
}
/*!
- Parent in node hierarchy.
+ \brief Parent in node hierarchy.
*/
FolderNode *Node::parentFolderNode() const
{
}
/*!
- Path of file or folder in the filesystem the node represents.
+ \brief Path of file or folder in the filesystem the node represents.
*/
QString Node::path() const
{
}
/*!
- \class FileNode
+ \class ProjectExplorer::FileNode
- In-memory presentation of a file. All FileNode's are leaf nodes.
+ \brief In-memory presentation of a file. All FileNode's are leaf nodes.
- \see FolderNode
- \see ProjectNode
+ \sa ProjectExplorer::FolderNode, ProjectExplorer::ProjectNode
*/
FileNode::FileNode(const QString &filePath,
}
/*!
- Returns true if the file is automatically generated by a compile step.
+ \brief Returns true if the file is automatically generated by a compile step.
*/
bool FileNode::isGenerated() const
{
}
/*!
- \class FolderNode
+ \class ProjectExplorer::FolderNode
In-memory presentation of a folder. Note that the node itself + all children (files and folders) are "managed" by the owning project.
- \see FileNode
- \see ProjectNode
+ \sa ProjectExplorer::FileNode, ProjectExplorer::ProjectNode
*/
FolderNode::FolderNode(const QString &folderPath) :
Node(FolderNodeType, folderPath),
qDeleteAll(m_fileNodes);
}
-/*
- The display name that should be used in a view.
-
-
- \see setFolderName()
+/*!
+ \brief The display name that should be used in a view.
+ \sa setFolderName()
*/
+
QString FolderNode::displayName() const
{
return m_displayName;
}
-/*
- The icon that should be used in a view. Default is the directory icon (QStyle::S_PDirIcon).
- \see setIcon()
+/*!
+ \brief The icon that should be used in a view. Default is the directory icon (QStyle::S_PDirIcon).
+ s\a setIcon()
*/
QIcon FolderNode::icon() const
{
}
/*!
- \class ProjectNode
+ \class ProjectExplorer::ProjectNode
+
+ \brief In-memory presentation of a Project.
- In-memory presentation of a Project.
A concrete subclass must implement the "persistent" stuff
- \see FileNode
- \see FolderNode
+ \sa ProjectExplorer::FileNode, ProjectExplorer::FolderNode
*/
-/*
- Creates uninitialized ProjectNode object.
+/*!
+ \brief Creates uninitialized ProjectNode object.
*/
ProjectNode::ProjectNode(const QString &projectFilePath)
: FolderNode(projectFilePath)
return m_watchers;
}
-/*
- Registers a watcher for the current project & all sub projects
+/*!
+ \brief Registers a watcher for the current project & all sub projects
+
It does not take ownership of the watcher.
- */
+*/
+
void ProjectNode::registerWatcher(NodesWatcher *watcher)
{
if (!watcher)
subProject->registerWatcher(watcher);
}
-/*
- Removes a watcher for the current project & all sub projects.
+/*!
+ \brief Removes a watcher for the current project & all sub projects.
*/
void ProjectNode::unregisterWatcher(NodesWatcher *watcher)
{
}
/*!
- Adds project nodes to the hierarchy and emits the corresponding signals.
+ \brief Adds project nodes to the hierarchy and emits the corresponding signals.
*/
void ProjectNode::addProjectNodes(const QList<ProjectNode*> &subProjects)
{
}
/*!
- Remove project nodes from the hierarchy and emits the corresponding signals.
+ \brief Remove project nodes from the hierarchy and emits the corresponding signals.
+
All objects in the argument list are deleted.
- */
+*/
+
void ProjectNode::removeProjectNodes(const QList<ProjectNode*> &subProjects)
{
if (!subProjects.isEmpty()) {
}
/*!
- Adds folder nodes to the hierarchy and emits the corresponding signals.
- */
+ \brief Adds folder nodes to the hierarchy and emits the corresponding signals.
+*/
void ProjectNode::addFolderNodes(const QList<FolderNode*> &subFolders, FolderNode *parentFolder)
{
Q_ASSERT(parentFolder);
}
/*!
- Remove file nodes from the hierarchy and emits the corresponding signals.
+ \brief Remove file nodes from the hierarchy and emits the corresponding signals.
+
All objects in the subFolders list are deleted.
- */
+*/
void ProjectNode::removeFolderNodes(const QList<FolderNode*> &subFolders,
FolderNode *parentFolder)
{
}
/*!
- Adds file nodes to the internal list and emits the corresponding signals.
+ \brief Adds file nodes to the internal list and emits the corresponding signals.
+
This method should be called within an implementation of the public method addFiles.
- */
+*/
+
void ProjectNode::addFileNodes(const QList<FileNode*> &files, FolderNode *folder)
{
Q_ASSERT(folder);
}
/*!
- Remove file nodes from the internal list and emits the corresponding signals.
+ \brief Remove file nodes from the internal list and emits the corresponding signals.
+
All objects in the argument list are deleted.
This method should be called within an implementation of the public method removeFiles.
- */
+*/
+
void ProjectNode::removeFileNodes(const QList<FileNode*> &files, FolderNode *folder)
{
Q_ASSERT(folder);
}
/*!
- Sort pointers to FileNodes
- */
+ \brief Sort pointers to FileNodes
+*/
bool ProjectNode::sortNodesByPath(Node *n1, Node *n2) {
return n1->path() < n2->path();
}
/*!
- \class SessionNode
+ \class ProjectExplorer::SessionNode
*/
SessionNode::SessionNode(const QString &sessionPath, QObject *parentObject)
return m_watchers;
}
-/*
- Registers a watcher for the complete session tree.
+/*!
+ \brief Registers a watcher for the complete session tree.
It does not take ownership of the watcher.
*/
+
void SessionNode::registerWatcher(NodesWatcher *watcher)
{
if (!watcher)
project->registerWatcher(watcher);
}
-/*
- Removes a watcher from the complete session tree
+/*!
+ \brief Removes a watcher from the complete session tree
*/
+
void SessionNode::unregisterWatcher(NodesWatcher *watcher)
{
if (!watcher)
}
/*!
- \class NodesWatcher
+ \class ProjectExplorer::NodesWatcher
- NodesWatcher let you keep track of changes in the tree.
+ \brief NodesWatcher lets you keep track of changes in the tree.
Add a watcher by calling ProjectNode::registerWatcher() or
SessionNode::registerWatcher(). Whenever the tree underneath the
by calling ProjectNode::unregisterWatcher and
SessionNode::unregisterWatcher().
- The NodesWatcher is similar to the Observer in the
+ The NodesWatcher is similar to the Observer in the
well-known Observer pattern (Booch et al).
+
+ \sa ProjectExplorer::Node
*/
NodesWatcher::NodesWatcher(QObject *parent)
namespace ProjectExplorer {
-//
-// = Node hierarchy =
-//
-// The nodes are arranged in a tree where leaves are FileNodes and non-leaves are FolderNodes
-// A Project is a special Folder that manages the files and normal folders underneath it.
-//
-// The Watcher emits signals for structural changes in the hierarchy.
-// A Visitor can be used to traverse all Projects and other Folders.
-//
-
enum NodeType {
FileNodeType = 1,
FolderNodeType,
class NodesWatcher;
class NodesVisitor;
+// Documentation inside.
class PROJECTEXPLORER_EXPORT Node : public QObject {
Q_OBJECT
public:
bool m_generated;
};
+// Documentation inside.
class PROJECTEXPLORER_EXPORT FolderNode : public Node {
Q_OBJECT
public:
mutable QIcon m_icon;
};
+// Documentation inside.
class PROJECTEXPLORER_EXPORT ProjectNode : public FolderNode
{
Q_OBJECT
friend class SessionNode;
};
+// Documentation inside.
class PROJECTEXPLORER_EXPORT SessionNode : public FolderNode {
Q_OBJECT
public:
QList<NodesWatcher*> m_watchers;
};
+// Documentation inside.
class PROJECTEXPLORER_EXPORT NodesWatcher : public QObject {
Q_OBJECT
public:
# define MAX_RECENT_SESSION_ITEMS 9
#endif
+/*!
+ \class ProjectExplorer::Internal::ProjectWelcomePageWidget
+
+ \brief Welcome page listing projects and sessions.
+*/
+
using namespace ProjectExplorer::Internal;
bool ProjectWelcomePageWidget::WelcomePageData::operator==(const WelcomePageData &rhs) const
class ProjectWelcomePageWidget;
}
+// Documentation inside.
class ProjectWelcomePageWidget : public QWidget
{
Q_OBJECT
#include <QtCore/QDir>
#include <QtCore/QTextStream>
+/*!
+ \class ProjectExplorer::Internal::ProjectWizardPage
+
+ \brief Wizard page showing projects and version control to add new files to.
+
+ \sa ProjectExplorer::Internal::ProjectFileWizardExtension
+*/
+
using namespace ProjectExplorer;
using namespace Internal;
class WizardPage;
}
+// Documentation inside.
class ProjectWizardPage : public QWizardPage {
Q_OBJECT
Q_DISABLE_COPY(ProjectWizardPage)
} // namespace
-// RunConfiguration
+/*!
+ \class ProjectExplorer::RunConfiguration
+ \brief Base class for a run configuration. A run configuration specifies how a
+ target should be run, while the runner (see below) does the actual running.
+
+ Note that all RunControls and the target hold a shared pointer to the RunConfiguration.
+ That is the lifetime of the RunConfiguration might exceed the life of the target.
+ The user might still have a RunControl running (or output tab of that RunControl open)
+ and yet unloaded the target.
+
+ Also, a RunConfiguration might be already removed from the list of RunConfigurations
+ for a target, but still be runnable via the output tab.
+*/
+
RunConfiguration::RunConfiguration(Target *target, const QString &id) :
ProjectConfiguration(target, id),
m_useCppDebugger(true),
m_aspects.append(aspect);
}
+/*!
+ \brief Used to find out whether a runconfiguration works with the given buildconfiguration.
+ \note bc may be 0!
+*/
+
bool RunConfiguration::isEnabled(BuildConfiguration *bc) const
{
Q_UNUSED(bc);
return true;
}
+/*!
+ \fn virtual QWidget *ProjectExplorer::RunConfiguration::createConfigurationWidget()
+
+ \brief Returns the widget used to configure this run configuration. Ownership is transferred to the caller
+*/
+
+/*!
+ \brief Used to find out whether a runconfiguration works with the active buildconfiguration.
+*/
+
bool RunConfiguration::isEnabled() const
{
if (target()->project()->hasActiveBuildSettings()
return ProjectConfiguration::fromMap(map);
}
+/*!
+ \class ProjectExplorer::IRunConfigurationAspect
+
+ \brief Extra configuration aspect.
+
+ Aspects are a mechanism to add RunControl-specific options to a RunConfiguration without
+ subclassing the RunConfiguration for every addition, preventing a combinatorical explosion
+ of subclasses or the need to add all options to the base class.
+*/
+
+/*!
+ \brief Return extra aspects.
+
+ \sa ProjectExplorer::IRunConfigurationAspect
+*/
+
QList<IRunConfigurationAspect *> RunConfiguration::extraAspects() const
{
return m_aspects;
return new OutputFormatter();
}
+/*!
+ \class ProjectExplorer::IRunConfigurationFactory
+
+ \brief Restores RunConfigurations from settings.
+
+ The run configuration factory is used for restoring run configurations from
+ settings. And used to create new runconfigurations in the "Run Settings" Dialog.
+ For the first case, bool canRestore(Target *parent, const QString &id) and
+ RunConfiguration* create(Target *parent, const QString &id) are used.
+ For the second type, the functions QStringList availableCreationIds(Target *parent) and
+ QString displayNameForType(const QString&) are used to generate a list of creatable
+ RunConfigurations, and create(..) is used to create it.
+*/
+
+/*!
+ \fn QStringList ProjectExplorer::IRunConfigurationFactory::availableCreationIds(Target *parent) const
+
+ \brief Used to show the list of possible additons to a target, returns a list of types.
+*/
+
+/*!
+ \fn QString ProjectExplorer::IRunConfigurationFactory::displayNameForId(const QString &id) const
+ \brief Used to translate the types to names to display to the user.
+*/
+
IRunConfigurationFactory::IRunConfigurationFactory(QObject *parent) :
QObject(parent)
{
return findRunConfigurationFactory(matcher);
}
+/*!
+ \class ProjectExplorer::IRunControlFactory
+
+ \brief Creates RunControl objects matching a RunConfiguration
+*/
+
+/*!
+ \fn IRunConfigurationAspect *ProjectExplorer::IRunControlFactory::createRunConfigurationAspect()
+ \brief Return an IRunConfigurationAspect to carry options for RunControls this factory can create.
+
+ If no extra options are required it is allowed to return null like the default implementation does.
+ This is intended to be called from the RunConfiguration constructor, so passing a RunConfiguration
+ pointer makes no sense because that object is under construction at the time.
+*/
+
+/*!
+ \fn RunConfigWidget *ProjectExplorer::IRunControlFactory::createConfigurationWidget(RunConfiguration *runConfiguration)
+
+ \brief Return a widget used to configure this runner. Ownership is transferred to the caller.
+
+ Return 0 if @p runConfiguration is not suitable for RunControls from this factory, or no user-accessible
+ configuration is required.
+*/
+
IRunControlFactory::IRunControlFactory(QObject *parent)
: QObject(parent)
{
return 0;
}
+/*!
+ \class ProjectExplorer::RunControl
+ \brief Each instance of this class represents one item that is run.
+*/
+
+/*!
+ \fn bool ProjectExplorer::RunControl::promptToStop(bool *optionalPrompt = 0) const
+
+ \brief Prompt to stop. If 'optionalPrompt' is passed, a "Do not ask again"-
+ checkbox will show and the result will be returned in '*optionalPrompt'.
+*/
+
+/*!
+ \fn QIcon ProjectExplorer::RunControl::icon() const
+ \brief Eeturns the icon to be shown in the Outputwindow.
+
+ TODO the icon differs currently only per "mode", so this is more flexible then it needs to be.
+*/
+
RunControl::RunControl(RunConfiguration *runConfiguration, QString mode)
: m_runMode(mode), m_runConfiguration(runConfiguration), m_outputFormatter(0)
{
optionalPrompt);
}
-// Utility to prompt to terminate application with checkable box.
+/*!
+ \brief Utility to prompt to terminate application with checkable box.
+*/
+
bool RunControl::showPromptToStopDialog(const QString &title,
const QString &text,
const QString &stopButtonText,
class RunControl;
class Target;
-/**
- * Base class for a run configuration. A run configuration specifies how a
- * target should be run, while the runner (see below) does the actual running.
- *
- * Note that all RunControls and the target hold a shared pointer to the RunConfiguration.
- * That is the lifetime of the RunConfiguration might exceed the life of the target.
- * The user might still have a RunControl running (or output tab of that RunControl open)
- * and yet unloaded the target.
- * Also a RunConfiguration might be already removed from the list of RunConfigurations
- * for a target, but stil be runnable via the output tab.
- */
+// Documentation inside.
class PROJECTEXPLORER_EXPORT RunConfiguration : public ProjectConfiguration
{
Q_OBJECT
public:
virtual ~RunConfiguration();
- /**
- * Used to find out whether a runconfiguration works with the given
- * buildconfiguration.
- * \note bc may be 0!
- */
virtual bool isEnabled(BuildConfiguration *bc) const;
-
- /**
- * Used to find out whether a runconfiguration works with the active
- * buildconfiguration.
- */
bool isEnabled() const;
-
- /// Returns the widget used to configure this run configuration. Ownership is transferred to the caller
virtual QWidget *createConfigurationWidget() = 0;
Target *target() const;
virtual QVariantMap toMap() const;
- // aspects are a mechanism to add RunControl-specific options to a RunConfiguration without
- // subclassing the RunConfiguration for every addition, preventing a combinatorical explosion
- // of subclasses or the need to add all options to the base class.
QList<IRunConfigurationAspect *> extraAspects() const;
template <typename T> T *extraAspect() const
{
virtual bool fromMap(const QVariantMap &map) = 0;
};
-/**
- * The run configuration factory is used for restoring run configurations from
- * settings. And used to create new runconfigurations in the "Run Settings" Dialog.
- * For the first case bool canRestore(Target *parent, const QString &id) and
- * RunConfiguration* create(Target *parent, const QString &id) are used.
- * For the second type the functions QStringList availableCreationIds(Target *parent) and
- * QString displayNameForType(const QString&) are used to generate a list of creatable
- * RunConfigurations, and create(..) is used to create it.
- */
class PROJECTEXPLORER_EXPORT IRunConfigurationFactory : public QObject
{
Q_OBJECT
explicit IRunConfigurationFactory(QObject *parent = 0);
virtual ~IRunConfigurationFactory();
- /// used to show the list of possible additons to a target, returns a list of types
virtual QStringList availableCreationIds(Target *parent) const = 0;
-
- /// used to translate the types to names to display to the user
virtual QString displayNameForId(const QString &id) const = 0;
virtual bool canCreate(Target *parent, const QString &id) const = 0;
virtual QString displayName() const = 0;
- /// Return an IRunConfigurationAspect to carry options for RunControls this factory can create.
- /// If no extra options are required it is allowed to return null like the default implementation does.
- /// This is intended to be called from the RunConfiguration constructor, so passing a RunConfiguration
- /// pointer makes no sense because that object is under construction at the time.
virtual IRunConfigurationAspect *createRunConfigurationAspect();
-
- /// Return a widget used to configure this runner. Ownership is transferred to the caller.
- /// If @p runConfiguration is not suitable for RunControls from this factory, or no user-accesible
- /// configuration is required, return null.
virtual RunConfigWidget *createConfigurationWidget(RunConfiguration *runConfiguration) = 0;
};
void displayNameChanged(const QString &);
};
-/**
- * Each instance of this class represents one item that is run.
- */
class PROJECTEXPLORER_EXPORT RunControl : public QObject
{
Q_OBJECT
virtual ~RunControl();
virtual void start() = 0;
- // Prompt to stop. If 'optionalPrompt' is passed, a "Do not ask again"-
- // checkbox will show and the result will be returned in '*optionalPrompt'.
virtual bool promptToStop(bool *optionalPrompt = 0) const;
virtual StopResult stop() = 0;
virtual bool isRunning() const = 0;
virtual QString displayName() const;
- /// \returns the icon to be shown in the outputwindow
- // TODO the icon differs currently only per "mode"
- // so this is more flexibel then it needs to be
virtual QIcon icon() const = 0;
bool sameRunConfiguration(const RunControl *other) const;
void bringApplicationToForegroundInternal();
protected:
- // Utility to prompt to terminate application with checkable box.
bool showPromptToStopDialog(const QString &title, const QString &text,
const QString &stopButtonText = QString(),
const QString &cancelButtonText = QString(),
using namespace ProjectExplorer;
-///
-/// RunConfigurationsModel
-///
+/*!
+ \class ProjectExplorer::RunConfigurationModel
+
+ \brief A model to represent the run configurations of a target.
+
+ To be used in for the drop down of comboboxes.
+ Does automatically adjust itself to added and removed RunConfigurations
+*/
class RunConfigurationComparer
{
class Target;
class RunConfiguration;
-/*! A model to represent the run configurations of a target.
- To be used in for the drop down of comboboxes
- Does automatically adjust itself to added and removed RunConfigurations
-*/
+// Documentation inside.
class RunConfigurationModel : public QAbstractListModel
{
Q_OBJECT
m_failedProjects.clear();
}
-/* --------------------------------- */
+/*!
+ \class ProjectExplorer::SessionManager
+
+ \brief Session management.
+
+ TODO the interface of this class is not really great.
+ The implementation suffers that all the functions from the
+ public interface just wrap around functions which do the actual work
+ This could be improved.
+*/
SessionManager::SessionManager(QObject *parent)
: QObject(parent),
setStartupProject(m_file->m_projects.first());
}
+/*!
+ \brief Let other plugins store persistent values within the session file.
+*/
+
void SessionManager::setValue(const QString &name, const QVariant &value)
{
if (!m_file)
return m_core->userResourcePath() + '/' + session + ".qws";
}
+/*!
+ \brief Creates a new default session and switches to it.
+*/
+
void SessionManager::createAndLoadNewDefaultSession()
{
emit aboutToLoadSession();
emit sessionLoaded();
}
+/*!
+ \brief Just creates a new session (Does not actually create the file).
+*/
+
bool SessionManager::createSession(const QString &session)
{
if (sessions().contains(session))
return deleteSession(original);
}
+/*!
+ \brief Deletes session name from session list and file from disk.
+*/
+
bool SessionManager::deleteSession(const QString &session)
{
if (!m_sessions.contains(session))
return false;
}
+/*!
+ \brief Loads a session, takes a session name (not filename).
+*/
+
bool SessionManager::loadSession(const QString &session)
{
// Do nothing if we have that session already loaded,
class SessionNodeImpl;
} // namespace Internal
-// TODO the interface of this class is not really great
-
-// The implementation suffers that all the functions from the
-// public interface just wrap around functions which do the actual work
-
-// This could be improved.
class PROJECTEXPLORER_EXPORT SessionManager : public QObject
{
Q_OBJECT
QString lastSession() const;
QStringList sessions() const;
- // creates a new default session and switches to it
void createAndLoadNewDefaultSession();
-
- // Just creates a new session (Does not actually create the file)
bool createSession(const QString &session);
- // delete session name from session list
- // delete file from disk
bool deleteSession(const QString &session);
bool cloneSession(const QString &original, const QString &clone);
bool renameSession(const QString &original, const QString &newName);
- // loads a session, takes a session name (not filename)
bool loadSession(const QString &session);
bool save();
unsigned int Task::s_nextId = 1;
+/*!
+ \class ProjectExplorer::Task
+ \brief Build issue (warning or error).
+ \sa ProjectExplorer::TaskHub
+*/
+
Task::Task() : taskId(0), type(Unknown), line(-1)
{ }
namespace ProjectExplorer {
-// Build issue (warning or error).
+// Documentation inside.
class PROJECTEXPLORER_EXPORT Task
{
public:
} // namespace Internal
-// --------------------------------------------------------------------------
-// ToolChain
+/*!
+ \class ProjectExplorer::ToolChain
+ \brief Representation of a ToolChain.
+ \sa ProjectExplorer::ToolChainManager
+*/
+
// --------------------------------------------------------------------------
ToolChain::ToolChain(const QString &id, bool autodetect) :
return m_d->m_id;
}
+/*!
+ \brief Returns a list of target ids that this tool chain is restricted to.
+
+ An empty list is shows that the toolchain is compatible with all targets.
+*/
+
QStringList ToolChain::restrictedToTargets() const
{
return QStringList();
return id() == tc.id();
}
+/*!
+ \brief Used by the toolchainmanager to save user-generated tool chains.
+
+ Make sure to call this method when deriving!
+*/
+
QVariantMap ToolChain::toMap() const
{
QVariantMap result;
toolChainUpdated();
}
+/*!
+ \brief Used by the toolchainmanager to load user-generated tool chains.
+
+ Make sure to call this method when deriving!
+*/
+
bool ToolChain::fromMap(const QVariantMap &data)
{
Q_ASSERT(!isAutoDetected());
return true;
}
-// --------------------------------------------------------------------------
-// ToolChainFactory
-// --------------------------------------------------------------------------
+/*!
+ \class ProjectExplorer::ToolChainFactory
+ \brief Creates toolchains from settings or autodetects them.
+*/
+
+/*!
+ \fn QString ProjectExplorer::ToolChainFactory::displayName() const = 0
+ \brief Name used to display the name of the tool chain that will be created.
+*/
+
+/*!
+ \fn bool ProjectExplorer::ToolChainFactory::canRestore(const QVariantMap &data)
+ \brief Used by the ToolChainManager to restore user-generated tool chains.
+*/
QList<ToolChain *> ToolChainFactory::autoDetect()
{
class ToolChainManager;
// --------------------------------------------------------------------------
-// ToolChain
+// ToolChain (documentation inside)
// --------------------------------------------------------------------------
class PROJECTEXPLORER_EXPORT ToolChain
virtual bool isValid() const = 0;
- /// Returns a list of target ids that this tool chain is restricted to.
- /// An empty list is shows that the toolchain is compatible with all targets.
virtual QStringList restrictedToTargets() const;
virtual QByteArray predefinedMacros() const = 0;
friend class ToolChainFactory;
};
-// --------------------------------------------------------------------------
-// ToolChainFactory
-// --------------------------------------------------------------------------
-
class PROJECTEXPLORER_EXPORT ToolChainFactory : public QObject
{
Q_OBJECT
public:
- // Name used to display the name of the tool chain that will be created.
virtual QString displayName() const = 0;
virtual QString id() const = 0;
virtual bool canCreate();
virtual ToolChain *create();
- // Used by the ToolChainManager to restore user-generated tool chains
virtual bool canRestore(const QVariantMap &data);
virtual ToolChain *restore(const QVariantMap &data);
using namespace ProjectExplorer::Internal;
+/*!
+ \class ProjectExplorer::Internal::WinGuiProcess
+ \brief Captures the debug output of a Windows GUI application.
+
+ The output of a Windows GUI application would otherwise not be
+ visible. Uses the debug interface and emits via a signal.
+*/
+
WinGuiProcess::WinGuiProcess(QObject *parent)
: QThread(parent)
{
namespace ProjectExplorer {
namespace Internal {
-/* Captures the debug output of a Windows GUI application (which
- * would otherwise not be visible) using the debug interface and
- * emits via a signal. */
+// Documentation inside.
class WinGuiProcess : public QThread, public AbstractProcess
{
Q_OBJECT
OSDN Git Service
