Commit 65ca06e0 authored by Leandro Melo's avatar Leandro Melo

Generalized Utils::unCommentSelection; Started implementing editor details...

Generalized Utils::unCommentSelection; Started implementing editor details (configuration by highlight definition, actions).
parent c8441462
This diff is collapsed.
......@@ -32,13 +32,42 @@
#include "utils_global.h"
#include <QtCore/QString>
QT_BEGIN_NAMESPACE
class QPlainTextEdit;
QT_END_NAMESPACE
namespace Utils {
QTCREATOR_UTILS_EXPORT void unCommentSelection(QPlainTextEdit *edit);
class QTCREATOR_UTILS_EXPORT CommentDefinition
{
public:
CommentDefinition();
CommentDefinition &setAfterWhiteSpaces(const bool);
CommentDefinition &setSingleLine(const QString &singleLine);
CommentDefinition &setMultiLineStart(const QString &multiLineStart);
CommentDefinition &setMultiLineEnd(const QString &multiLineEnd);
bool isAfterWhiteSpaces() const;
const QString &singleLine() const;
const QString &multiLineStart() const;
const QString &multiLineEnd() const;
bool hasSingleLineStyle() const;
bool hasMultiLineStyle() const;
private:
bool m_afterWhiteSpaces;
QString m_singleLine;
QString m_multiLineStart;
QString m_multiLineEnd;
};
QTCREATOR_UTILS_EXPORT
void unCommentSelection(QPlainTextEdit *edit,
const CommentDefinition &definiton = CommentDefinition());
} // end of namespace Utils
......
......@@ -43,9 +43,50 @@
#include <QtCore/QSharedPointer>
#include <QtCore/QFileInfo>
#include <QDebug>
using namespace GenericEditor;
using namespace Internal;
Editor::Editor(QWidget *parent) : TextEditor::BaseTextEditor(parent)
{
connect(file(), SIGNAL(changed()), this, SLOT(configure()));
}
void Editor::unCommentSelection()
{
Utils::unCommentSelection(this, m_commentDefinition);
}
TextEditor::BaseTextEditorEditable *Editor::createEditableInterface()
{
EditorEditable *editable = new EditorEditable(this);
return editable;
}
void Editor::configure()
{
const QString &mimeType = Core::ICore::instance()->mimeDatabase()->findByFile(
QFileInfo(file()->fileName())).type();
baseTextDocument()->setMimeType(mimeType);
try {
const QString &definitionId =
GenericEditorPlugin::instance()->definitionIdByMimeType(mimeType);
QSharedPointer<HighlightDefinition> definition =
GenericEditorPlugin::instance()->definition(definitionId);
baseTextDocument()->setSyntaxHighlighter(new Highlighter(definition->initialContext()));
m_commentDefinition.setAfterWhiteSpaces(definition->isCommentAfterWhiteSpaces());
m_commentDefinition.setSingleLine(definition->singleLineComment());
m_commentDefinition.setMultiLineStart(definition->multiLineCommentStart());
m_commentDefinition.setMultiLineEnd(definition->multiLineCommentEnd());
} catch (const HighlighterException &) {
// No highlighter will be set.
}
}
EditorEditable::EditorEditable(Editor *editor) :
TextEditor::BaseTextEditorEditable(editor)
{
......@@ -68,34 +109,7 @@ bool EditorEditable::duplicateSupported() const
Core::IEditor *EditorEditable::duplicate(QWidget *parent)
{
Editor *newEditor = new Editor(editor()->mimeType(), parent);
Editor *newEditor = new Editor(parent);
newEditor->duplicateFrom(editor());
return newEditor->editableInterface();
}
bool EditorEditable::open(const QString &fileName)
{
if (TextEditor::BaseTextEditorEditable::open(fileName)) {
editor()->setMimeType(
Core::ICore::instance()->mimeDatabase()->findByFile(QFileInfo(fileName)).type());
return true;
}
return false;
}
Editor::Editor(const QString &definitionId, QWidget *parent) : TextEditor::BaseTextEditor(parent)
{
try {
QSharedPointer<HighlightDefinition> definition =
GenericEditorPlugin::instance()->definition(definitionId);
baseTextDocument()->setSyntaxHighlighter(new Highlighter(definition->initialContext()));
} catch (const HighlighterException &) {
// No highlighter will be set.
}
}
TextEditor::BaseTextEditorEditable *Editor::createEditableInterface()
{
EditorEditable *editable = new EditorEditable(this);
return editable;
}
......@@ -31,6 +31,7 @@
#define GENERICEDITOR_H
#include <texteditor/basetexteditor.h>
#include <utils/uncommentselection.h>
#include <QtCore/QList>
......@@ -41,12 +42,27 @@ QT_END_NAMESPACE
namespace GenericEditor {
namespace Internal {
class Editor;
class Editor : public TextEditor::BaseTextEditor
{
Q_OBJECT
public:
Editor(QWidget *parent = 0);
virtual void unCommentSelection();
protected:
virtual TextEditor::BaseTextEditorEditable *createEditableInterface();
private slots:
void configure();
private:
Utils::CommentDefinition m_commentDefinition;
};
class EditorEditable : public TextEditor::BaseTextEditorEditable
{
Q_OBJECT
public:
EditorEditable(Editor *editor);
......@@ -56,22 +72,12 @@ protected:
virtual bool isTemporary() const;
virtual bool duplicateSupported() const;
virtual Core::IEditor *duplicate(QWidget *parent);
virtual bool open(const QString & fileName);
private:
QList<int> m_context;
};
class Editor : public TextEditor::BaseTextEditor
{
Q_OBJECT
public:
Editor(const QString &definitionId, QWidget *parent = 0);
protected:
virtual TextEditor::BaseTextEditorEditable *createEditableInterface();
};
} // namespace Internal
} // namespace GenericEditor
......
......@@ -30,22 +30,41 @@
#include "editorfactory.h"
#include "genericeditorconstants.h"
#include "editor.h"
#include "genericeditorplugin.h"
#include <coreplugin/editormanager/editormanager.h>
using namespace GenericEditor;
using namespace Internal;
EditorFactory::EditorFactory(QObject *parent) :
Core::IEditorFactory(parent)
{}
EditorFactory::EditorFactory(QObject *parent) : Core::IEditorFactory(parent)
{
// Note: This is temporary until it is definied how definition files should be "integrated".
m_mimeTypes << QLatin1String(GenericEditor::Constants::C_HEADER_MIMETYPE)
<< QLatin1String(GenericEditor::Constants::C_SOURCE_MIMETYPE)
<< QLatin1String(GenericEditor::Constants::CPP_HEADER_MIMETYPE)
<< QLatin1String(GenericEditor::Constants::CPP_SOURCE_MIMETYPE)
<< QLatin1String(GenericEditor::Constants::CSS_MIMETYPE)
<< QLatin1String(GenericEditor::Constants::FORTRAN_MIMETYPE)
<< QLatin1String(GenericEditor::Constants::HTML_MIMETYPE)
<< QLatin1String(GenericEditor::Constants::JAVA_MIMETYPE)
<< QLatin1String(GenericEditor::Constants::JAVASCRIPT_MIMETYPE)
<< QLatin1String(GenericEditor::Constants::OBJECTIVEC_MIMETYPE)
<< QLatin1String(GenericEditor::Constants::PERL_MIMETYPE)
<< QLatin1String(GenericEditor::Constants::PHP_MIMETYPE)
<< QLatin1String(GenericEditor::Constants::PYTHON_MIMETYPE)
<< QLatin1String(GenericEditor::Constants::RUBY_MIMETYPE)
<< QLatin1String(GenericEditor::Constants::SQL_MIMETYPE)
<< QLatin1String(GenericEditor::Constants::TCL_MIMETYPE);
}
EditorFactory::~EditorFactory()
{}
Core::IEditor *EditorFactory::createEditor(QWidget *parent)
{
Editor *genericEditor = createGenericEditor(parent);
Editor *genericEditor = new Editor(parent);
GenericEditorPlugin::instance()->initializeEditor(genericEditor);
return genericEditor->editableInterface();
}
......@@ -67,6 +86,3 @@ Core::IFile *EditorFactory::open(const QString &fileName)
Core::IEditor *iface = Core::EditorManager::instance()->openEditor(fileName, id());
return iface ? iface->file() : 0;
}
void EditorFactory::addMimeType(const QString &mimeType)
{ m_mimeTypes.append(mimeType); }
......@@ -47,21 +47,13 @@ public:
EditorFactory(QObject *parent = 0);
virtual ~EditorFactory();
// Currently there are language specific factores which configure the correct highlighter.
// Would it be a good idea if the createEditor method also received the mime type? This would
// also discard the necessity of overriding the open method.
virtual Core::IEditor *createEditor(QWidget *parent);
virtual QStringList mimeTypes() const;
virtual QString id() const;
virtual QString displayName() const;
virtual Core::IFile *open(const QString &fileName);
protected:
void addMimeType(const QString &mimeType);
private:
virtual Editor *createGenericEditor(QWidget *parent) = 0;
private:
QStringList m_mimeTypes;
};
......
......@@ -8,7 +8,6 @@ CONFIG += help
HEADERS += \
genericeditorplugin.h \
progressdata.h \
languagespecificfactories.h \
specificrules.h \
rule.h \
reuse.h \
......@@ -28,7 +27,6 @@ HEADERS += \
SOURCES += \
genericeditorplugin.cpp \
progressdata.cpp \
languagespecificfactories.cpp \
specificrules.cpp \
rule.cpp \
keywordlist.cpp \
......
include(../../plugins/coreplugin/coreplugin.pri)
include(../../plugins/texteditor/texteditor.pri)
include(../../libs/utils/utils.pri)
......@@ -28,12 +28,13 @@
**************************************************************************/
#include "genericeditorplugin.h"
#include "languagespecificfactories.h"
#include "highlightdefinition.h"
#include "highlightdefinitionhandler.h"
#include "highlighter.h"
#include "highlighterexception.h"
#include "genericeditorconstants.h"
#include "editor.h"
#include "editorfactory.h"
#include <coreplugin/icore.h>
#include <coreplugin/mimedatabase.h>
......@@ -48,6 +49,7 @@
using namespace GenericEditor;
using namespace Internal;
// Todo: Temp.
const QLatin1String GenericEditorPlugin::kAlertDefinitionId(":/genericeditor/XML/alert.xml");
const QLatin1String GenericEditorPlugin::kCDefinitionId(":/genericeditor/XML/c.xml");
const QLatin1String GenericEditorPlugin::kCppDefinitionId(":/genericeditor/XML/cpp.xml");
......@@ -73,7 +75,8 @@ const QLatin1String GenericEditorPlugin::kTclDefinitionId(":/genericeditor/XML/t
GenericEditorPlugin *GenericEditorPlugin::m_instance = 0;
GenericEditorPlugin::GenericEditorPlugin()
GenericEditorPlugin::GenericEditorPlugin() :
m_actionHandler(0)
{
QTC_ASSERT(!m_instance, return);
m_instance = this;
......@@ -117,7 +120,13 @@ GenericEditorPlugin::GenericEditorPlugin()
}
GenericEditorPlugin::~GenericEditorPlugin()
{}
{
delete m_actionHandler;
m_instance = 0;
}
GenericEditorPlugin *GenericEditorPlugin::instance()
{ return m_instance; }
bool GenericEditorPlugin::initialize(const QStringList &arguments, QString *errorString)
{
......@@ -129,20 +138,12 @@ bool GenericEditorPlugin::initialize(const QStringList &arguments, QString *erro
return false;
}
addAutoReleasedObject(new CFactory(this));
addAutoReleasedObject(new CppFactory(this));
addAutoReleasedObject(new CssFactory(this));
addAutoReleasedObject(new FortranFactory(this));
addAutoReleasedObject(new HtmlFactory(this));
addAutoReleasedObject(new JavaFactory(this));
addAutoReleasedObject(new JavascriptFactory(this));
addAutoReleasedObject(new ObjectiveCFactory(this));
addAutoReleasedObject(new PerlFactory(this));
addAutoReleasedObject(new PhpFactory(this)); // Php definition file is broken.
addAutoReleasedObject(new PythonFactory(this));
addAutoReleasedObject(new RubyFactory(this));
addAutoReleasedObject(new SqlFactory(this));
addAutoReleasedObject(new TclFactory(this));
addAutoReleasedObject(new EditorFactory(this));
m_actionHandler = new TextEditor::TextEditorActionHandler(
GenericEditor::Constants::GENERIC_EDITOR,
TextEditor::TextEditorActionHandler::UnCommentSelection);
m_actionHandler->initializeActions();
return true;
}
......@@ -150,8 +151,10 @@ bool GenericEditorPlugin::initialize(const QStringList &arguments, QString *erro
void GenericEditorPlugin::extensionsInitialized()
{}
GenericEditorPlugin *GenericEditorPlugin::instance()
{ return m_instance; }
void GenericEditorPlugin::initializeEditor(Editor *editor)
{
m_actionHandler->setupActions(editor);
}
QString GenericEditorPlugin::definitionIdByName(const QString &name) const
{ return m_idByName.value(name.toLower()); }
......@@ -187,5 +190,4 @@ const QSharedPointer<HighlightDefinition> &GenericEditorPlugin::definition(const
return *m_definitions.constFind(id);
}
Q_EXPORT_PLUGIN(GenericEditorPlugin)
......@@ -31,6 +31,7 @@
#define GENERICEDITORPLUGIN_H
#include <extensionsystem/iplugin.h>
#include <texteditor/texteditoractionhandler.h>
#include <QtCore/QString>
#include <QtCore/QLatin1String>
......@@ -42,6 +43,7 @@ namespace GenericEditor {
namespace Internal {
class HighlightDefinition;
class Editor;
// Note: The general interface of this class is temporary. Still need discussing details about
// the definition files integration with Creator.
......@@ -59,9 +61,10 @@ public:
virtual bool initialize(const QStringList &arguments, QString *errorString);
virtual void extensionsInitialized();
void initializeEditor(Editor *editor);
QString definitionIdByName(const QString &name) const;
QString definitionIdByMimeType(const QString &mimeType) const;
bool isBuildingDefinition(const QString &id) const;
const QSharedPointer<HighlightDefinition> &definition(const QString &id);
......@@ -87,12 +90,14 @@ private:
GenericEditorPlugin(const GenericEditorPlugin &HighlighterPlugin);
const GenericEditorPlugin &operator=(const GenericEditorPlugin &HighlighterPlugin);
static GenericEditorPlugin *m_instance;
QSet<QString> m_isBuilding;
QHash<QString, QString> m_idByName;
QHash<QString, QString> m_idByMimeType;
QHash<QString, QSharedPointer<HighlightDefinition> > m_definitions;
static GenericEditorPlugin *m_instance;
TextEditor::TextEditorActionHandler *m_actionHandler;
};
} // namespace Internal
......
......@@ -41,7 +41,6 @@ using namespace Internal;
HighlightDefinition::HighlightDefinition() :
m_delimiters(QLatin1String(".():!+,-<=>%&/;?[]^{|}~\\*, \t")),
m_singleLineCommentPosition(0),
m_singleLineCommentAfterWhiteSpaces(false),
m_keywordCaseSensitivity(Qt::CaseSensitive)
{}
......@@ -110,22 +109,13 @@ void HighlightDefinition::setSingleLineComment(const QString &start)
const QString &HighlightDefinition::singleLineComment() const
{ return m_singleLineComment; }
void HighlightDefinition::setSingleLineCommentPosition(const QString &position)
void HighlightDefinition::setCommentAfterWhitespaces(const QString &after)
{
if (position == QLatin1String("afterwhitespace")) {
if (after == QLatin1String("afterwhitespace"))
m_singleLineCommentAfterWhiteSpaces = true;
} else {
bool ok;
m_singleLineCommentPosition = position.toInt(&ok);
if (!ok)
m_singleLineCommentPosition = 0;
}
}
int HighlightDefinition::singleLineCommentPosition() const
{ return m_singleLineCommentPosition; }
bool HighlightDefinition::isSingleLineCommentAfterWhiteSpaces() const
bool HighlightDefinition::isCommentAfterWhiteSpaces() const
{ return m_singleLineCommentAfterWhiteSpaces; }
void HighlightDefinition::setMultiLineCommentStart(const QString &start)
......
......@@ -69,9 +69,8 @@ public:
void setSingleLineComment(const QString &start);
const QString &singleLineComment() const;
void setSingleLineCommentPosition(const QString &position);
int singleLineCommentPosition() const;
bool isSingleLineCommentAfterWhiteSpaces() const;
void setCommentAfterWhitespaces(const QString &after);
bool isCommentAfterWhiteSpaces() const;
void setMultiLineCommentStart(const QString &start);
const QString &multiLineCommentStart() const;
......@@ -112,7 +111,6 @@ private:
QString m_delimiters;
QString m_singleLineComment;
int m_singleLineCommentPosition;
bool m_singleLineCommentAfterWhiteSpaces;
QString m_multiLineCommentStart;
......
......@@ -281,10 +281,10 @@ void HighlightDefinitionHandler::itemDataElementStarted(const QXmlAttributes &at
void HighlightDefinitionHandler::commentElementStarted(const QXmlAttributes &atts) const
{
const QString &commentType = atts.value(kName);
if (commentType == kSingleLine) {
if (commentType.compare(kSingleLine, Qt::CaseInsensitive) == 0) {
m_definition->setSingleLineComment(atts.value(kStart));
m_definition->setSingleLineCommentPosition(atts.value(kPosition));
} else if (commentType == kMultiLine) {
m_definition->setCommentAfterWhitespaces(atts.value(kPosition));
} else if (commentType.compare(kMultiLine, Qt::CaseInsensitive) == 0) {
m_definition->setMultiLineCommentStart(atts.value(kStart));
m_definition->setMultiLineCommentEnd(atts.value(kEnd));
m_definition->setMultiLineCommentRegion(atts.value(kRegion));
......
/**************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** Commercial Usage
**
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Nokia.
**
** GNU Lesser General Public License Usage
**
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** If you are unsure which license is appropriate for your use, please
** contact the sales department at http://qt.nokia.com/contact.
**
**************************************************************************/
#include "languagespecificfactories.h"
#include "genericeditorconstants.h"
#include "editor.h"
#include "genericeditorplugin.h"
#include <coreplugin/icore.h>
#include <coreplugin/mimedatabase.h>
using namespace GenericEditor;
using namespace Internal;
// C
CFactory::CFactory(QObject *parent) : EditorFactory(parent)
{
addMimeType(QLatin1String(GenericEditor::Constants::C_HEADER_MIMETYPE));
addMimeType(QLatin1String(GenericEditor::Constants::C_SOURCE_MIMETYPE));
}
Editor *CFactory::createGenericEditor(QWidget *parent)
{ return new Editor(GenericEditorPlugin::kCDefinitionId, parent); }
// C++
CppFactory::CppFactory(QObject *parent) : EditorFactory(parent)
{
addMimeType(QLatin1String(GenericEditor::Constants::CPP_HEADER_MIMETYPE));
addMimeType(QLatin1String(GenericEditor::Constants::CPP_SOURCE_MIMETYPE));
}
Editor *CppFactory::createGenericEditor(QWidget *parent)
{ return new Editor(GenericEditorPlugin::kCppDefinitionId, parent); }
// Css
CssFactory::CssFactory(QObject *parent) : EditorFactory(parent)
{ addMimeType(QLatin1String(GenericEditor::Constants::CSS_MIMETYPE)); }
Editor *CssFactory::createGenericEditor(QWidget *parent)
{ return new Editor(GenericEditorPlugin::kCssDefinitionId, parent); }
// Fortran
FortranFactory::FortranFactory(QObject *parent) : EditorFactory(parent)
{ addMimeType(QLatin1String(GenericEditor::Constants::FORTRAN_MIMETYPE)); }
Editor *FortranFactory::createGenericEditor(QWidget *parent)
{ return new Editor(GenericEditorPlugin::kFortranDefinitionId, parent); }
// Html
HtmlFactory::HtmlFactory(QObject *parent) : EditorFactory(parent)
{ addMimeType(QLatin1String(GenericEditor::Constants::HTML_MIMETYPE)); }
Editor *HtmlFactory::createGenericEditor(QWidget *parent)
{ return new Editor(GenericEditorPlugin::kHtmlDefinitionId, parent); }
// Java
JavaFactory::JavaFactory(QObject *parent) : EditorFactory(parent)
{ addMimeType(QLatin1String(GenericEditor::Constants::JAVA_MIMETYPE)); }
Editor *JavaFactory::createGenericEditor(QWidget *parent)
{ return new Editor(GenericEditorPlugin::kJavaDefinitionId, parent); }
// Javascript
JavascriptFactory::JavascriptFactory(QObject *parent) : EditorFactory(parent)
{ addMimeType(QLatin1String(GenericEditor::Constants::JAVASCRIPT_MIMETYPE)); }
Editor *JavascriptFactory::createGenericEditor(QWidget *parent)
{ return new Editor(GenericEditorPlugin::kJavascriptDefinitionId, parent); }
// ObjectiveC
ObjectiveCFactory::ObjectiveCFactory(QObject *parent) : EditorFactory(parent)
{ addMimeType(QLatin1String(GenericEditor::Constants::OBJECTIVEC_MIMETYPE)); }
Editor *ObjectiveCFactory::createGenericEditor(QWidget *parent)
{ return new Editor(GenericEditorPlugin::kObjectiveCDefinitionId, parent); }
// Perl
PerlFactory::PerlFactory(QObject *parent) : EditorFactory(parent)
{ addMimeType(QLatin1String(GenericEditor::Constants::PERL_MIMETYPE)); }
Editor *PerlFactory::createGenericEditor(QWidget *parent)
{ return new Editor(GenericEditorPlugin::kPerlDefinitionId, parent); }
// Php
PhpFactory::PhpFactory(QObject *parent) : EditorFactory(parent)
{ addMimeType(QLatin1String(GenericEditor::Constants::PHP_MIMETYPE)); }
Editor *PhpFactory::createGenericEditor(QWidget *parent)
{ return new Editor(GenericEditorPlugin::kPhpDefinitionId, parent); }
// Python
PythonFactory::PythonFactory(QObject *parent) : EditorFactory(parent)
{ addMimeType(QLatin1String(GenericEditor::Constants::PYTHON_MIMETYPE)); }
Editor *PythonFactory::createGenericEditor(QWidget *parent)
{ return new Editor(GenericEditorPlugin::kPythonDefinitionId, parent); }
// Ruby
RubyFactory::RubyFactory(QObject *parent) : EditorFactory(parent)
{ addMimeType(QLatin1String(GenericEditor::Constants::RUBY_MIMETYPE)); }
Editor *RubyFactory::createGenericEditor(QWidget *parent)
{ return new Editor(GenericEditorPlugin::kRubyDefinitionId, parent); }
// SQL
SqlFactory::SqlFactory(QObject *parent) : EditorFactory(parent)