refactoring qad widgets part 2

c++ cast, nullptr, forward declaration, agregate ui, connect to member functions, order and clear includes

libs/qglview/propertyeditor.cpp

@@ -1,5 +1,12 @@
 #include "propertyeditor.h"
+#include "colorbutton.h"
+#include "qpointedit.h"
+#include "qrectedit.h"
+#include "clineedit.h"
 #include <QPainter>
+#include <QCheckBox>
+#include <QSpinBox>
+#include <QApplication>
 
 
 QWidget * Delegate::widgetForProperty(QWidget * parent, const QModelIndex & index) const {
@@ -10,7 +17,6 @@ QWidget * Delegate::widgetForProperty(QWidget * parent, const QModelIndex & inde
 	if (index.data(Qt::UserRole + 1).toString() == "__flag") {
 		qulonglong key = index.data(Qt::UserRole).toULongLong();
 		value = index.parent().data(Qt::UserRole);
-		//QMetaProperty prop = index.parent().data(Qt::UserRole + 1).value<QMetaProperty>();
 		w = new QCheckBox(parent); type = 14; ((QCheckBox*)w)->setChecked(((value.toULongLong() & key) == key && key != 0) || (value.toULongLong() == 0 && key == 0));
 		((QCheckBox*)w)->setText("0x" + QString::number(key, 16).toUpper());
 		connect((QCheckBox*)w, SIGNAL(clicked(bool)), this, SLOT(changedFlag()));

libs/qglview/qglview_test/qglview_window.cpp

@@ -22,6 +22,7 @@
 #include "loader_3ds.h"
 #include "loader_obj.h"
 #include "loader_dae.h"
+#include "qad_types.h"
 #include <QGraphicsRectItem>
 #include <QImageReader>
 #include <QMessageBox>

libs/widgets/image_view.cpp

@@ -85,7 +85,7 @@ void ImageView::clear() {
 }
 
 
-void ImageView::mouseDoubleClickEvent(QMouseEvent * e) {
+void ImageView::mouseDoubleClickEvent(QMouseEvent *) {
 	autofit();
 }
 
@@ -121,7 +121,7 @@ bool ImageView::eventFilter(QObject * o, QEvent * e) {
 		break;
 	case QEvent::MouseMove:
 		if (me->buttons().testFlag(Qt::RightButton) && !autofit_ && viewInteractive()) {
-			QPointF dp = QPointF(me->pos() - prev_pos);
+			QPoint dp = QPoint(me->pos() - prev_pos);
 			horizontalScrollBar()->setValue(horizontalScrollBar()->value() - dp.x());
 			verticalScrollBar()->setValue(verticalScrollBar()->value() - dp.y());
 			prev_pos = me->pos();

libs/widgets/image_view.h

@@ -52,7 +52,7 @@ signals:
 	void clicked(QPointF, Qt::MouseButtons);
 
 private:
-	void mouseDoubleClickEvent(QMouseEvent * e) override;
+	void mouseDoubleClickEvent(QMouseEvent *) override;
 	void mousePressEvent(QMouseEvent * e) override;
 	void wheelEvent(QWheelEvent * e) override;
 	bool eventFilter(QObject * o, QEvent * e) override;

libs/widgets/mathmatrixedit.cpp

@@ -1,6 +1,7 @@
 #include "mathmatrixedit.h"
-#include "qvariantedit_custom.h"
 #include "matrixedit.h"
+#include "qvariantedit_custom.h"
+#include "qad_types.h"
 #include <QBoxLayout>
 
 
@@ -43,7 +44,7 @@ void MathMatrixEdit::setReadOnly(bool yes) {
 class MathMatrixEditFactory: public QVariantEditorFactoryBase {
 public:
 	MathMatrixEditFactory() {}
-	virtual QWidget * createEditor() {return new MathMatrixEdit();}
+	QWidget * createEditor() override {return new MathMatrixEdit();}
 };
 
 

libs/widgets/mathmatrixedit.h

@@ -20,9 +20,9 @@
 #ifndef MATH_MATRIX_EDIT_H
 #define MATH_MATRIX_EDIT_H
 
-#include <QWidget>
-#include "qad_types.h"
 #include "qad_widgets_export.h"
+#include <QWidget>
+#include <QVariant>
 
 
 class MatrixEdit;
@@ -33,22 +33,21 @@ class QAD_WIDGETS_EXPORT MathMatrixEdit: public QWidget {
 	Q_PROPERTY(QVariant value READ value WRITE setValue NOTIFY valueChanged)
 	Q_PROPERTY(bool readOnly READ isReadOnly WRITE setReadOnly)
 public:
-	explicit MathMatrixEdit(QWidget * parent = 0);
+	explicit MathMatrixEdit(QWidget * parent = nullptr);
-	~MathMatrixEdit();
+	~MathMatrixEdit() override;
 	
 	QVariant value() const;
 	bool isReadOnly() const;
-	
+
-private:
-	MatrixEdit * edit;
-	
 public slots:
 	void setValue(const QVariant & v);
 	void setReadOnly(bool yes);
 
 signals:
 	void valueChanged();
-	
+
+private:
+	MatrixEdit * edit;
 };
 
 

libs/widgets/mathvectoredit.cpp

@@ -1,5 +1,6 @@
 #include "mathvectoredit.h"
 #include "qvariantedit_custom.h"
+#include "qad_types.h"
 #include "matrixedit.h"
 #include <QBoxLayout>
 
@@ -43,11 +44,10 @@ void MathVectorEdit::setReadOnly(bool yes) {
 class MathVectorEditFactory: public QVariantEditorFactoryBase {
 public:
 	MathVectorEditFactory() {}
-	virtual QWidget * createEditor() {return new MathVectorEdit();}
+	virtual QWidget * createEditor() override {return new MathVectorEdit();}
 };
 
 
 __MathVectorEditRegistrator__::__MathVectorEditRegistrator__() {
 	QVariantEditorFactories::registerEditorFactory(qMetaTypeId<QAD::MathVector>(), new MathVectorEditFactory());
-	//__QADTypesRegistrator__::instance()->toString_funcs.insert(qMetaTypeId<QAD::IODevice>(), &QAD_IODevice_toString);
 }

libs/widgets/mathvectoredit.h

@@ -20,9 +20,9 @@
 #ifndef MATH_VECTOR_EDIT_H
 #define MATH_VECTOR_EDIT_H
 
-#include <QWidget>
-#include "qad_types.h"
 #include "qad_widgets_export.h"
+#include <QWidget>
+#include <QVariant>
 
 
 class MatrixEdit;
@@ -33,22 +33,21 @@ class QAD_WIDGETS_EXPORT MathVectorEdit: public QWidget {
 	Q_PROPERTY(QVariant value READ value WRITE setValue NOTIFY valueChanged)
 	Q_PROPERTY(bool readOnly READ isReadOnly WRITE setReadOnly)
 public:
-	explicit MathVectorEdit(QWidget * parent = 0);
+	explicit MathVectorEdit(QWidget * parent = nullptr);
-	~MathVectorEdit();
+	~MathVectorEdit() override;
 	
 	QVariant value() const;
 	bool isReadOnly() const;
 	
-private:
-	MatrixEdit * edit;
-	
 public slots:
 	void setValue(const QVariant & v);
 	void setReadOnly(bool yes);
 
 signals:
 	void valueChanged();
-	
+
+private:
+	MatrixEdit * edit;
 };
 
 

libs/widgets/matrixedit.cpp

@@ -26,13 +26,14 @@ bool MatrixEdit::isReadOnly() const {
 
 void MatrixEdit::setReadOnly(bool yes) {
 	ro = yes;
-	/// TODO
+	/// TODO : readonly not implemented
 }
 
 
 void MatrixEdit::setVectorMode(bool yes) {
-	if (yes)
+	if (yes) {
 		ui->spinCols->setValue(1);
+	}
 	ui->labelCols->setHidden(yes);
 	ui->spinCols->setHidden(yes);
 	ui->buttonIdentity->setHidden(yes);
@@ -74,7 +75,9 @@ QVector<double> MatrixEdit::vector() const {
 	ret.fill(0.);
 	for (int r = 0; r < ret.size(); ++r) {
 		QTableWidgetItem * i = ui->table->item(r, 0);
-		if (!i) continue;
+		if (!i) {
+			continue;
+		}
 		ret[r] = i->text().toDouble();
 	}
 	return ret;
@@ -91,7 +94,9 @@ QVector<QVector<double> > MatrixEdit::matrix() const {
 		ret[r].fill(0.);
 		for (int c = 0; c < cc; ++c) {
 			QTableWidgetItem * i = ui->table->item(r, c);
-			if (!i) continue;
+			if (!i) {
+				continue;
+			}
 			ret[r][c] = i->text().toDouble();
 		}
 	}

libs/widgets/matrixedit.h

@@ -20,8 +20,8 @@
 #ifndef MATRIXEDIT_H
 #define MATRIXEDIT_H
 
-#include <QWidget>
 #include "qad_widgets_export.h"
+#include <QWidget>
 
 
 namespace Ui {
@@ -32,8 +32,8 @@ namespace Ui {
 class QAD_WIDGETS_EXPORT MatrixEdit: public QWidget {
 	Q_OBJECT
 public:
-	explicit MatrixEdit(QWidget * parent = 0);
+	explicit MatrixEdit(QWidget * parent = nullptr);
-	~MatrixEdit();
+	~MatrixEdit() override;
 
 	bool isReadOnly() const;
 	void setReadOnly(bool yes);
@@ -43,14 +43,6 @@ public:
 	void setVector(const QVector<double> & v);
 	void setMatrix(const QVector<QVector<double> > & v);
 
-private:
-	void setVectorMode(bool yes);
-	void clear(bool ident = false);
-	void changeEvent(QEvent * e);
-
-	Ui::MatrixEdit * ui;
-	bool ro;
-
 private slots:
 	void on_spinRows_valueChanged(int cnt);
 	void on_spinCols_valueChanged(int cnt);
@@ -59,7 +51,14 @@ private slots:
 
 signals:
 	void changed();
-	
+
+private:
+	void setVectorMode(bool yes);
+	void clear(bool ident = false);
+	void changeEvent(QEvent * e) override;
+
+	Ui::MatrixEdit * ui;
+	bool ro;
 };
 
 

libs/widgets/propertystorage_editor.cpp

@@ -1,4 +1,5 @@
 #include "propertystorage_editor.h"
+#include "propertystorage.h"
 #include "qvariantedit.h"
 #include <QGridLayout>
 #include <QToolButton>
@@ -7,7 +8,7 @@
 PropertyStorageEditor::PropertyStorageEditor(QWidget * parent): QWidget(parent) {
 	setLayout(new QGridLayout());
 	layout()->setContentsMargins(0, 0, 0, 0);
-	storage = 0;
+	storage = nullptr;
 }
 
 
@@ -23,7 +24,7 @@ void PropertyStorageEditor::clear() {
 
 
 bool PropertyStorageEditor::isEmpty() const {
-	return ((QGridLayout*)layout())->count() == 0;
+	return static_cast<QGridLayout*>(layout())->count() == 0;
 }
 
 
@@ -32,13 +33,13 @@ void PropertyStorageEditor::setStorage(PropertyStorage * s) {
 	storage = s;
 	if (!storage) return;
 	int r = 0;
-	QGridLayout * layoutProps = (QGridLayout*)layout();
+	auto layoutProps = static_cast<QGridLayout*>(layout());
-	foreach (const PropertyStorage::Property & p, *storage) {
+	for (const PropertyStorage::Property & p : *storage) {
-		QLabel * lbl = new QLabel(p.name);
+		auto lbl = new QLabel(p.name);
 		_widgets << lbl;
 		lbl->setAlignment(Qt::AlignVCenter | Qt::AlignRight);
 		layoutProps->addWidget(lbl, r, 0);
-		QVariantEdit * ve = new QVariantEdit();
+		auto ve = new QVariantEdit();
 		ve->setValue(p.value);
 		ve->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
 		ve->setMinimumWidth(50);
@@ -54,12 +55,16 @@ void PropertyStorageEditor::setStorage(PropertyStorage * s) {
 void PropertyStorageEditor::applyProperties() {
 	if (!storage) return;
 	QList<PropertyStorage::Property> & props(storage->properties());
-	QGridLayout * layoutProps = (QGridLayout*)layout();
+	auto layoutProps = static_cast<QGridLayout*>(layout());
 	for (int r = 0; r < layoutProps->rowCount(); ++r) {
-		if (layoutProps->itemAtPosition(r, 0) == 0 || layoutProps->itemAtPosition(r, 1) == 0) continue;
+		if (layoutProps->itemAtPosition(r, 0) == nullptr || layoutProps->itemAtPosition(r, 1) == nullptr) {
+			continue;
+		}
 		QLabel * lbl = qobject_cast<QLabel * >(layoutProps->itemAtPosition(r, 0)->widget());
 		QVariantEdit * ve = qobject_cast<QVariantEdit * >(layoutProps->itemAtPosition(r, 1)->widget());
-		if (lbl == 0 || ve == 0) continue;
+		if (lbl == nullptr || ve == nullptr) {
+			continue;
+		}
 		QString pn = lbl->text();
 		for (int i = 0; i < props.size(); ++i) {
 			PropertyStorage::Property & p(props[i]);

libs/widgets/propertystorage_editor.h

@@ -21,29 +21,30 @@
 #define PROPERTYSTORAGEEDITOR_H
 
 #include <QWidget>
-#include "propertystorage.h"
 #include "qad_widgets_export.h"
 
 
+class PropertyStorage;
+
+
 class QAD_WIDGETS_EXPORT PropertyStorageEditor: public QWidget {
 	Q_OBJECT
 public:
-	explicit PropertyStorageEditor(QWidget * parent = 0);
+	explicit PropertyStorageEditor(QWidget * parent = nullptr);
-	~PropertyStorageEditor();
+	~PropertyStorageEditor() override;
 	
 	void clear();
 	bool isEmpty() const;
 	void setStorage(PropertyStorage * s);
 	void applyProperties();
 	
-private:
-	QList<QWidget*> _widgets;
-	PropertyStorage * storage;
-	
 signals:
 	void resetStorageRequest(PropertyStorage * );
 	void changed();
 
+private:
+	QList<QWidget*> _widgets;
+	PropertyStorage * storage;
 };
 
 #endif // PROPERTYSTORAGEEDITOR_H

libs/widgets/qcodeedit.cpp

@@ -1,5 +1,9 @@
 #include "qcodeedit.h"
+#include "ui_qcodeedit.h"
 #include "qcodeedit_completer_p.h"
+#include "ecombobox.h"
+#include "qad_types.h"
+#include "iconedlabel.h"
 #include <QLayout>
 #include <QBoxLayout>
 #include <QScrollBar>
@@ -13,12 +17,10 @@
 #include <QApplication>
 #include <QDesktopServices>
 #include <QPainter>
+#include <QPlainTextEdit>
 #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
 #  include <QWindow>
 #endif
-#include "ecombobox.h"
-#include "qad_types.h"
-#include "ui_qcodeedit.h"
 
 Q_DECLARE_METATYPE(QTextCursor)
 Q_DECLARE_METATYPE(QCodeEdit::ACEntry)
@@ -29,10 +31,9 @@ public:
 	_QCE_Viewport(QWidget * p = nullptr): QWidget(p) {
 		setObjectName("__qcodeedit_viewport__");
 		setMouseTracking(true);
-		//setCursor(Qt::IBeamCursor);
 	}
 
-	void paintEvent(QPaintEvent * e) override {
+	void paintEvent(QPaintEvent *) override {
 		if (!isEnabled()) return;
 		ce->drawCursor();
 	}
@@ -42,8 +43,8 @@ public:
 };
 
 
-QCodeEdit::QCodeEdit(QWidget * parent): QWidget(parent) {
+QCodeEdit::QCodeEdit(QWidget * parent): QWidget(parent), ui(new Ui::QCodeEdit) {
-	overlay = 0;
+	overlay = nullptr;
 	prev_lc = auto_comp_pl = cur_search_ind = pos_press = pos_el_press = -1;
 	timer_parse = 0;
 	_ignore_focus_out = _destructor = _replacing = cursor_state = block_sel_state = false;
@@ -51,7 +52,6 @@ QCodeEdit::QCodeEdit(QWidget * parent): QWidget(parent) {
 	comment_text = "//";
 	qRegisterMetaType<QTextCursor>();
 	qRegisterMetaType<QCodeEdit::ACEntry>();
-	ui = new Ui::QCodeEdit();
 	ui->setupUi(this);
 	overlay = new _QCE_Viewport(ui->textCode->viewport());
 	overlay->ce = this;
@@ -127,9 +127,6 @@ QCodeEdit::QCodeEdit(QWidget * parent): QWidget(parent) {
 	QTextOption to = ui->textLines->document()->defaultTextOption();
 	to.setAlignment(Qt::AlignTop | Qt::AlignRight);
 	ui->textLines->document()->setDefaultTextOption(to);
-	/*to = ui->textCode->document()->defaultTextOption();
-	to.setFlags(QTextOption::SuppressColors);
-	ui->textCode->document()->setDefaultTextOption(to);*/
 	setShowSpaces(true);
 
 	a = new QAction(this);
@@ -138,12 +135,6 @@ QCodeEdit::QCodeEdit(QWidget * parent): QWidget(parent) {
 	connect(a, SIGNAL(triggered(bool)), this, SLOT(search_triggered()));
 	addAction(a);
 
-	/*a = new QAction(this);
-	a->setShortcut(QKeySequence("Esc"));
-	a->setShortcutContext(Qt::WidgetWithChildrenShortcut);
-	connect(a, SIGNAL(triggered(bool)), this, SLOT(hideSearch()));
-	addAction(a);*/
-
 	connect(completer, SIGNAL(itemDoubleClicked(QTreeWidgetItem * ,int)), this, SLOT(commitCompletition()));
 	connect(completer, SIGNAL(commit()), this, SLOT(commitCompletition()));
 	connect(completer, SIGNAL(gotoHRef(QCodeEdit::ACEntry)), this, SLOT(gotoHelpHRef(QCodeEdit::ACEntry)));
@@ -159,7 +150,7 @@ QCodeEdit::QCodeEdit(QWidget * parent): QWidget(parent) {
 	connect(ui->comboSearch->lineEdit(), SIGNAL(returnPressed()), this, SLOT(searchNext()));
 	connect(ui->comboReplace->lineEdit(), SIGNAL(returnPressed()), this, SLOT(on_buttonReplaceSearch_clicked()));
 #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
-	connect(qApp, &QGuiApplication::focusWindowChanged, this, [this](QWindow*w){if (w == 0) {hideHelp(); completer->hide();}});
+	connect(qApp, &QGuiApplication::focusWindowChanged, this, [this](QWindow*w){if (w == nullptr) {hideHelp(); completer->hide();}});
 #endif
 	updateLines();
 	timer_blink = startTimer(QApplication::cursorFlashTime() / 2);
@@ -171,10 +162,8 @@ QCodeEdit::QCodeEdit(QWidget * parent): QWidget(parent) {
 QCodeEdit::~QCodeEdit() {
 	_destructor = true;
 	delete completer;
-	//for (int i = 0; i < 2; ++i)
-	//	delete lbl_help[i];
 	delete widget_help;
-	//delete ui;
+	delete ui;
 }
 
 
@@ -198,8 +187,8 @@ void QCodeEdit::setDocument(QTextDocument * doc) {
 	ui->textLines->setEnabled(doc);
 	documentUnset();
 	if (!doc) {
-		ui->textCode->setDocument(0);
+		ui->textCode->setDocument(nullptr);
-		documentChanged(0);
+		documentChanged(nullptr);
 		return;
 	}
 	if (!qobject_cast<QPlainTextDocumentLayout*>(doc->documentLayout()))
@@ -207,7 +196,6 @@ void QCodeEdit::setDocument(QTextDocument * doc) {
 	ui->textCode->setDocument(doc);
 	cursor_width = qMax<int>(qRound(fontHeight(this) / 10.), 1);
 	ui->textCode->setCursorWidth(0);
-	//ui->textCode->setCursorWidth(qMax<int>(qRound(fontHeight() / 10.), 1));
 	setShowSpaces(spaces_);
 	if (doc->property("_cursor").isValid()) {
 		setTextCursor(doc->property("_cursor").value<QTextCursor>());
@@ -388,45 +376,40 @@ bool QCodeEdit::eventFilter(QObject * o, QEvent * e) {
 		return QWidget::eventFilter(o, e);
 	}
 	if (ui->textLines) {
-		if (o == ui->textLines->viewport()) {/*
+		if (o == ui->textLines->viewport()) {
-			if (e->type() == QEvent::MouseButtonPress || e->type() == QEvent::MouseButtonRelease ||
-				e->type() == QEvent::MouseMove || e->type() == QEvent::MouseButtonDblClick) {
-#if (QT_VERSION < 0x050000)
-				const_cast<QPoint&>(((QMouseEvent*)e)->pos()) = QPoint(0, ((QMouseEvent*)e)->pos().y());
-#else
-				const_cast<QPointF&>(((QMouseEvent*)e)->localPos()) = QPointF(0, ((QMouseEvent*)e)->localPos().y());
-#endif
-				QApplication::sendEvent(ui->textCode->viewport(), e);
-				return true;
-			}*/
 			QTextCursor tc;
 			int tcpos = 0;
 			switch (e->type()) {
 			case QEvent::MouseButtonPress:
-				if (!isEnabled()) break;
+				if (!isEnabled()) {
-				tc = ui->textCode->cursorForPosition(((QMouseEvent*)e)->pos());
+					break;
+				}
+				tc = ui->textCode->cursorForPosition(static_cast<QMouseEvent*>(e)->pos());
 				tc.movePosition(QTextCursor::EndOfLine);
 				pos_el_press = tc.anchor();
 				tc.movePosition(QTextCursor::StartOfLine);
 				pos_press = tc.anchor();
-				if (!tc.movePosition(QTextCursor::Down, QTextCursor::KeepAnchor))
+				if (!tc.movePosition(QTextCursor::Down, QTextCursor::KeepAnchor)) {
 					tc.movePosition(QTextCursor::EndOfLine, QTextCursor::KeepAnchor);
+				}
 				ui->textCode->setFocus();
 				ui->textCode->setTextCursor(tc);
 				return true;
 			case QEvent::MouseMove:
 				if (!isEnabled()) break;
-				tc = ui->textCode->cursorForPosition(((QMouseEvent*)e)->pos());
+				tc = ui->textCode->cursorForPosition(static_cast<QMouseEvent*>(e)->pos());
 				tc.movePosition(QTextCursor::StartOfLine);
 				if (pos_press == tc.anchor()) {
-					if (!tc.movePosition(QTextCursor::Down, QTextCursor::KeepAnchor))
+					if (!tc.movePosition(QTextCursor::Down, QTextCursor::KeepAnchor)) {
 						tc.movePosition(QTextCursor::EndOfLine, QTextCursor::KeepAnchor);
+					}
 					ui->textCode->setTextCursor(tc);
 					return true;
 				}
 				if (pos_press < tc.anchor()) {
-					if (!tc.movePosition(QTextCursor::Down, QTextCursor::KeepAnchor))
+					if (!tc.movePosition(QTextCursor::Down, QTextCursor::KeepAnchor)) {
 						tc.movePosition(QTextCursor::EndOfLine, QTextCursor::KeepAnchor);
+					}
 				}
 				tcpos = tc.position();
 				tc.setPosition(pos_press < tc.anchor() ? pos_press : pos_el_press);
@@ -451,7 +434,7 @@ bool QCodeEdit::eventFilter(QObject * o, QEvent * e) {
 	if (o == ui->comboSearch || o == ui->comboReplace) {
 		//qDebug() << o << e;
 		if (e->type() == QEvent::KeyPress) {
-			if (((QKeyEvent * )e)->key() == Qt::Key_Escape) {
+			if (static_cast<QKeyEvent*>(e)->key() == Qt::Key_Escape) {
 				hideHelp();
 				if (completer->isVisible())
 					completer->hide();
@@ -469,14 +452,14 @@ bool QCodeEdit::eventFilter(QObject * o, QEvent * e) {
 				cancelBlockSelection();
 				completer->hide();
 				hideHelp();
-				QMouseEvent * me = (QMouseEvent*)e;
+				auto me = static_cast<QMouseEvent*>(e);
 				if (me->modifiers().testFlag(Qt::ControlModifier) && (me->button() == Qt::LeftButton))
 					if (!hasBlockSelection() && !ui->textCode->textCursor().hasSelection())
 						gotoLink();
 				} break;
 			case QEvent::MouseMove: {
 				if (!completer->isHidden()) break;
-				QMouseEvent * me = (QMouseEvent*)e;
+				auto me = static_cast<QMouseEvent*>(e);
 				if (me->buttons() != 0)
 					switchBlockSelection();
 				if (me->modifiers().testFlag(Qt::ControlModifier))
@@ -490,9 +473,9 @@ bool QCodeEdit::eventFilter(QObject * o, QEvent * e) {
 				if (!isEnabled()) break;
 				drag_cursor = ui->textCode->cursorForPosition(
 #if QT_VERSION_MAJOR <= 5
-							((QDragMoveEvent*)e)->pos()
+							static_cast<QDragMoveEvent*>(e)->pos()
 #else
-							((QDragMoveEvent*)e)->position().toPoint()
+							static_cast<QDragMoveEvent*>(e)->position().toPoint()
 #endif
 								);
 				repaintCursor();
@@ -512,14 +495,14 @@ bool QCodeEdit::eventFilter(QObject * o, QEvent * e) {
 			switch (e->type()) {
 			case QEvent::ToolTip:
 				if (completer->isHidden()) {
-					QTextCursor tc = ui->textCode->cursorForPosition(((QHelpEvent*)e)->pos());
+					QTextCursor tc = ui->textCode->cursorForPosition(static_cast<QHelpEvent*>(e)->pos());
 					tc.select(QTextCursor::WordUnderCursor);
 					raiseHelp(tc);
 				}
 				break;
 			case QEvent::KeyPress:
 				//qDebug() << "key" << ke;
-				if (codeKeyEvent((QKeyEvent * )e))
+				if (codeKeyEvent(static_cast<QKeyEvent*>(e)))
 					return true;
 				break;
 			case QEvent::KeyRelease:
@@ -608,10 +591,11 @@ bool QCodeEdit::codeKeyEvent(QKeyEvent * ke) {
 		break;
 	case Qt::Key_Escape:
 		hideHelp();
-		if (completer->isVisible())
+		if (completer->isVisible()) {
 			completer->hide();
-		else
+		} else {
 			hideSearch();
+		}
 		break;
 	case Qt::Key_Up:
 		switchBlockSelection(ke);
@@ -622,10 +606,11 @@ bool QCodeEdit::codeKeyEvent(QKeyEvent * ke) {
 		completer->hide();
 		hideHelp();
 		if (ke->modifiers().testFlag(Qt::AltModifier)) {
-			if (ke->modifiers().testFlag(Qt::ShiftModifier))
+			if (ke->modifiers().testFlag(Qt::ShiftModifier)) {
 				return false;
-			else
+			} else {
 				copyLineUp();
+			}
 			return true;
 		}
 		if (ke->modifiers().testFlag(Qt::ControlModifier) && ke->modifiers().testFlag(Qt::ShiftModifier)) {
@@ -642,10 +627,11 @@ bool QCodeEdit::codeKeyEvent(QKeyEvent * ke) {
 		completer->hide();
 		hideHelp();
 		if (ke->modifiers().testFlag(Qt::AltModifier)) {
-			if (ke->modifiers().testFlag(Qt::ShiftModifier))
+			if (ke->modifiers().testFlag(Qt::ShiftModifier)) {
 				return false;
-			else
+			} else {
 				copyLineDown();
+			}
 			return true;
 		}
 		if (ke->modifiers().testFlag(Qt::ControlModifier) && ke->modifiers().testFlag(Qt::ShiftModifier)) {
@@ -666,13 +652,17 @@ bool QCodeEdit::codeKeyEvent(QKeyEvent * ke) {
 	case Qt::Key_Left:
 	case Qt::Key_Right:
 		switchBlockSelection(ke);
-		if (hasBlockSelection()) break;
+		if (hasBlockSelection()) {
+			break;
+		}
 	case Qt::Key_Backspace:
 	case Qt::Key_Delete:
-		if (completer->isVisible())
+		if (completer->isVisible()) {
 			QMetaObject::invokeMethod(this, "invokeAutoCompletition", Qt::QueuedConnection, Q_ARG(bool, false));
-		if (removeBlockSelection(ke->key() == Qt::Key_Delete))
+		}
+		if (removeBlockSelection(ke->key() == Qt::Key_Delete)) {
 			return true;
+		}
 		break;
 	case Qt::Key_Return:
 		if (hasBlockSelection()) {
@@ -684,15 +674,17 @@ bool QCodeEdit::codeKeyEvent(QKeyEvent * ke) {
 			completer->hide();
 			return true;
 		}
-		if (ui->textCode->textCursor().selectedText().isEmpty())
+		if (ui->textCode->textCursor().selectedText().isEmpty()) {
 			QMetaObject::invokeMethod(this, "autoIndent", Qt::QueuedConnection);
+		}
 		break;
 	case Qt::Key_Tab:
 		if (!ui->textCode->textCursor().selectedText().isEmpty()) {
-			if (ke->modifiers().testFlag(Qt::ShiftModifier))
+			if (ke->modifiers().testFlag(Qt::ShiftModifier)) {
 				deindent();
-			else
+			} else {
 				indent();
+			}
 			return true;
 		}
 		break;
@@ -703,12 +695,14 @@ bool QCodeEdit::codeKeyEvent(QKeyEvent * ke) {
 		}
 		break;
 	case Qt::Key_Control:
-		if (!hasBlockSelection() && !ui->textCode->textCursor().hasSelection())
+		if (!hasBlockSelection() && !ui->textCode->textCursor().hasSelection()) {
 			showLink();
+		}
 		break;
 	case Qt::Key_F1:
-		if (widget_help->isVisible())
+		if (widget_help->isVisible()) {
 			gotoHelpHRef(help_entry);
+		}
 		break;
 	default: break;
 	}
@@ -723,8 +717,9 @@ bool QCodeEdit::codeKeyEvent(QKeyEvent * ke) {
 		completer->hide();
 		QMetaObject::invokeMethod(this, "invokeAutoCompletition", Qt::QueuedConnection, Q_ARG(bool, false));
 	} else {
-		if ((kc.isLetterOrNumber() || kc.toLatin1() == '_') && completer->isVisible())
+		if ((kc.isLetterOrNumber() || kc.toLatin1() == '_') && completer->isVisible()) {
 			QMetaObject::invokeMethod(this, "invokeAutoCompletition", Qt::QueuedConnection, Q_ARG(bool, false));
+		}
 	}
 	return false;
 }
@@ -733,14 +728,21 @@ bool QCodeEdit::codeKeyEvent(QKeyEvent * ke) {
 void QCodeEdit::toggleComment() {
 	QTextCursor tc = ui->textCode->textCursor();
 	tc.beginEditBlock();
-	int ss = tc.selectionStart(), ss_ = ss, se = tc.selectionEnd(), se_ = se;
+	int ss = tc.selectionStart();
+	int ss_ = ss;
+	int se = tc.selectionEnd();
 	QString st_ = tc.selection().toPlainText();
 	if (st_.endsWith("\n")) {
 		st_.chop(1);
-		se--; se_--;
+		se--;
 	}
-	tc.setPosition(ss); tc.movePosition(QTextCursor::StartOfLine); ss = tc.position();
+	int se_ = se;
-	tc.setPosition(se); tc.movePosition(QTextCursor::EndOfLine  ); se = tc.position();
+	tc.setPosition(ss);
+	tc.movePosition(QTextCursor::StartOfLine);
+	ss = tc.position();
+	tc.setPosition(se);
+	tc.movePosition(QTextCursor::EndOfLine  );
+	se = tc.position();
 	tc.setPosition(ss);
 	bool need_comment = false;
 	QMap<int, bool> comms;
@@ -754,11 +756,13 @@ void QCodeEdit::toggleComment() {
 				need_comment = true;
 				comms[line] = false;
 			}
-		} else
+		} else {
 			comms[line] = false;
+		}
 		tc.movePosition(QTextCursor::StartOfLine);
-		if (!tc.movePosition(QTextCursor::Down))
+		if (!tc.movePosition(QTextCursor::Down)) {
 			break;
+		}
 	}
 	tc.setPosition(ss);
 	bool first = true;
@@ -780,8 +784,9 @@ void QCodeEdit::toggleComment() {
 		}
 		first = false;
 		tc.movePosition(QTextCursor::StartOfLine);
-		if (!tc.movePosition(QTextCursor::Down))
+		if (!tc.movePosition(QTextCursor::Down)) {
 			break;
+		}
 	}
 	tc.setPosition(ss_);
 	tc.setPosition(se_, QTextCursor::KeepAnchor);
@@ -822,7 +827,8 @@ void QCodeEdit::highlightBrackets() {
 				es.cursor = tc;
 				es_brackets << es;
 				QTextCursor ftc = tc;
-				int bcnt = 1; char fch = antiBracket(ch);
+				int bcnt = 1;
+				char fch = antiBracket(ch);
 				while (bcnt > 0) {
 					ftc.setPosition(ftc.position());
 					if (!ftc.movePosition(mop[d], QTextCursor::KeepAnchor)) break;
@@ -836,8 +842,9 @@ void QCodeEdit::highlightBrackets() {
 					es_brackets << es;
 					es.format = es_range.format;
 					es.cursor.setPosition(tc.position(), QTextCursor::KeepAnchor);
-					if (!es.cursor.selection().isEmpty())
+					if (!es.cursor.selection().isEmpty()) {
 						es_brackets << es;
+					}
 				}
 			}
 		}
@@ -859,10 +866,18 @@ void QCodeEdit::clearSearch() {
 
 
 void QCodeEdit::moveToSearch() {
-	if (es_search_list.isEmpty()) return;
+	if (es_search_list.isEmpty()) {
-	if (cur_search_ind < 0) cur_search_ind += es_search_list.size();
+		return;
-	if (cur_search_ind >= es_search_list.size()) cur_search_ind = 0;
+	}
-	if (cur_search_ind < 0 || cur_search_ind >= es_search_list.size()) return;
+	if (cur_search_ind < 0) {
+		cur_search_ind += es_search_list.size();
+	}
+	if (cur_search_ind >= es_search_list.size()) {
+		cur_search_ind = 0;
+	}
+	if (cur_search_ind < 0 || cur_search_ind >= es_search_list.size()) {
+		return;
+	}
 	ui->textCode->setTextCursor(es_search_list[cur_search_ind].cursor);
 }
 
@@ -870,9 +885,11 @@ void QCodeEdit::moveToSearch() {
 int QCodeEdit::searchIndFromCursor() {
 	if (es_search_list.isEmpty()) return -1;
 	int ci = ui->textCode->textCursor().anchor();
-	for (int i = 0; i < es_search_list.size(); ++i)
+	for (int i = 0; i < es_search_list.size(); ++i) {
-		if (es_search_list[i].cursor.anchor() > ci)
+		if (es_search_list[i].cursor.anchor() > ci) {
 			return i - 1;
+		}
+	}
 	return -1;
 }
 
@@ -891,11 +908,8 @@ QRect QCodeEdit::cursorRect() {
 
 QRect QCodeEdit::blockSelectionRect() {
 	QTextCursor tc = ui->textCode->textCursor();
-	QPoint ps(block_start_cursor.positionInBlock(), block_start_cursor.blockNumber()),
+	QPoint ps(block_start_cursor.positionInBlock(), block_start_cursor.blockNumber());
-		   pe(tc.positionInBlock(), tc.blockNumber());
+	QPoint pe(tc.positionInBlock(), tc.blockNumber());
-	//QRect bsr(QPoint(qMin(ps.x(), pe.x()), qMin(ps.y(), pe.y())),
-	//		  QSize(qAbs(ps.x() - pe.x()), qAbs(ps.y() - pe.y()) + 1));
-	//return bsr;
 	return (ui->textCode->cursorRect(tc) | ui->textCode->cursorRect(block_start_cursor))
 			.translated(ui->textCode->horizontalScrollBar()->value(), 0);
 }
@@ -966,12 +980,16 @@ void QCodeEdit::cancelBlockSelection() {
 
 void QCodeEdit::switchBlockSelection(QKeyEvent * ke) {
 	bool alt = QApplication::keyboardModifiers().testFlag(Qt::AltModifier);
-	if (ke) alt = ke->modifiers().testFlag(Qt::AltModifier) && ke->modifiers().testFlag(Qt::ShiftModifier);
+	if (ke) {
+		alt = ke->modifiers().testFlag(Qt::AltModifier) && ke->modifiers().testFlag(Qt::ShiftModifier);
+	}
 	if (alt) {
 		startBlockSelection();
 		QTextCursor tc = ui->textCode->textCursor();
 		QTextCursor::MoveOperation op = QTextCursor::NoMove;
-		if (!ke) return;
+		if (!ke) {
+			return;
+		}
 		switch (ke->key()) {
 		case Qt::Key_Left : op = QTextCursor::Left ; break;
 		case Qt::Key_Right: op = QTextCursor::Right; break;
@@ -984,18 +1002,25 @@ void QCodeEdit::switchBlockSelection(QKeyEvent * ke) {
 			ui->textCode->setTextCursor(tc);
 		}
 		repaintCursor();
-	} else
+	} else {
 		cancelBlockSelection();
+	}
 }
 
 
 bool QCodeEdit::removeBlockSelection(bool is_del) {
-	if (!hasBlockSelection()) return false;
+	if (!hasBlockSelection()) {
+		return false;
+	}
 	QRect bsr = blockSelectionRect();
-	bool del = false, back = false;
+	bool del = false;
+	bool back = false;
 	if (bsr.width() <= 1) {
-		if (is_del) del = true;
+		if (is_del) {
-		else back = true;
+			del = true;
+		} else {
+			back = true;
+		}
 	}
 	QVector<QTextCursor> clist = blockSelectionCursors(bsr);
 	QTextCursor tc = ui->textCode->textCursor();
@@ -1008,19 +1033,24 @@ bool QCodeEdit::removeBlockSelection(bool is_del) {
 											width
 #endif
 												(" ");
-	int min_dist = nullw * 0.5;
+	int min_dist = nullw / 2;
 	int new_pos = -1;
-	foreach (QTextCursor c, clist) {
+	for (QTextCursor & c : clist) {
 		if (del || back) {
-			if (qAbs(bspx - ui->textCode->cursorRect(c).center().x()) > min_dist) continue;
+			if (qAbs(bspx - ui->textCode->cursorRect(c).center().x()) > min_dist) {
+				continue;
+			}
 			int line = c.blockNumber();
 			c.movePosition(del ? QTextCursor::Right : QTextCursor::Left, QTextCursor::KeepAnchor);
-			if (line != c.blockNumber()) continue;
+			if (line != c.blockNumber()) {
+				continue;
+			}
 			//qDebug() << qAbs(bspx - ui->textCode->cursorRect(c).center().x()) << min_dist;
 		}
 		c.removeSelectedText();
-		if (c.blockNumber() == tc.blockNumber())
+		if (c.blockNumber() == tc.blockNumber()) {
 			new_pos = c.position();
+		}
 	}
 	tc.setPosition(new_pos);
 	ui->textCode->setTextCursor(tc);
@@ -1030,7 +1060,9 @@ bool QCodeEdit::removeBlockSelection(bool is_del) {
 
 
 void QCodeEdit::insertBlockSelection(QString text) {
-	if (!hasBlockSelection()) return;
+	if (!hasBlockSelection()) {
+		return;
+	}
 	QTextCursor tc = ui->textCode->textCursor();
 	QRect bsr = blockSelectionRect();
 	//qDebug() << "___" << bsr;
@@ -1041,7 +1073,6 @@ void QCodeEdit::insertBlockSelection(QString text) {
 		//qDebug() << "del" << bsr;
 	}
 	tc.beginEditBlock();
-	//tc.joinPreviousEditBlock();
 	int nullw = ui->textCode->fontMetrics().
 #if QT_VERSION >= QT_VERSION_CHECK(5, 11, 0)
 											horizontalAdvance
@@ -1050,7 +1081,7 @@ void QCodeEdit::insertBlockSelection(QString text) {
 #endif
 												(" ");
 	QVector<QTextCursor> clist = blockSelectionCursors(bsr);
-	foreach (QTextCursor c, clist) {
+	for (QTextCursor & c : clist) {
 		c.removeSelectedText();
 		int spcnt = (bsr.left() - ui->textCode->cursorRect(c).center().x() - scrl) / nullw;
 		if (spcnt > 0) {
@@ -1058,20 +1089,20 @@ void QCodeEdit::insertBlockSelection(QString text) {
 		}
 		c.insertText(text);
 	}
-	//tc.setPosition(tc.block().position() + block_start_cursor.positionInBlock());
-	//ui->textCode->setTextCursor(tc);
 	tc.endEditBlock();
 }
 
 
 void QCodeEdit::createBlockSelection() {
-	if (!hasBlockSelection()) return;
+	if (!hasBlockSelection()) {
+		return;
+	}
 	es_blockselection.clear();
 	QTextEdit::ExtraSelection es;
 	es.format.setForeground(palette().brush(QPalette::HighlightedText));
 	es.format.setBackground(palette().brush(QPalette::Highlight));
 	QVector<QTextCursor> clist = blockSelectionCursors(blockSelectionRect());
-	foreach (QTextCursor c, clist) {
+	for (QTextCursor & c : clist) {
 		es.cursor = c;
 		es_blockselection << es;
 	}
@@ -1096,15 +1127,18 @@ void QCodeEdit::searchAll() {
 		QTextEdit::ExtraSelection es = es_search;
 		while (true) {
 			tc = ui->textCode->document()->find(st, tc, ff);
-			if (tc.isNull()) break;
+			if (tc.isNull()) {
+				break;
+			}
 			es.cursor = tc;
 			es_search_list << es;
 		}
 	}
 	applyExtraSelection();
 	QString ss;
-	if (es_search_list.isEmpty())
+	if (es_search_list.isEmpty()) {
 		ss = "color: rgb(180, 0, 0);";
+	}
 	ui->comboSearch->lineEdit()->setStyleSheet(ss);
 }
 
@@ -1117,16 +1151,15 @@ void QCodeEdit::search_triggered() {
 		st = tc.selectedText();
 	}
 	search(st);
-	//QMetaObject::invokeMethod(ui->comboSearch->lineEdit(), "returnPressed");
+	if (ui->comboSearch->findText(st) < 0) {
-	if (ui->comboSearch->findText(st) < 0)
 		ui->comboSearch->insertItem(0, st);
+	}
 }
 
 
 void QCodeEdit::syncScrolls() {
 	ui->textLines->verticalScrollBar()->setValue(ui->textCode->verticalScrollBar()->value());
 	ui->textLines->setHorizontalScrollBarPolicy(ui->textCode->horizontalScrollBar()->isVisible() ? Qt::ScrollBarAlwaysOn : Qt::ScrollBarAlwaysOff);
-	//qDebug() << "!!!";
 }
 
 
@@ -1163,23 +1196,35 @@ void QCodeEdit::deleteLine() {
 void QCodeEdit::copyLineUp() {
 	QTextCursor tc = ui->textCode->textCursor();
 	tc.beginEditBlock();
-	int ss = tc.selectionStart(), ss_ = ss, se = tc.selectionEnd(), se_ = se;
+	int ss = tc.selectionStart();
+	int ss_ = ss;
+	int se = tc.selectionEnd();
 	QString st_ = tc.selection().toPlainText();
 	if (st_.endsWith("\n")) {
 		st_.chop(1);
-		se--; se_--;
+		se--;
 	}
-	tc.setPosition(ss); tc.movePosition(QTextCursor::StartOfLine); ss = tc.position();
+	int se_ = se;
-	tc.setPosition(se); tc.movePosition(QTextCursor::EndOfLine); se = tc.position();
+	tc.setPosition(ss);
-	tc.setPosition(ss); tc.setPosition(se, QTextCursor::KeepAnchor);
+	tc.movePosition(QTextCursor::StartOfLine);
+	ss = tc.position();
+	tc.setPosition(se);
+	tc.movePosition(QTextCursor::EndOfLine);
+	se = tc.position();
+	tc.setPosition(ss);
+
+	tc.setPosition(se, QTextCursor::KeepAnchor);
 	bool ins_nl = false;
-	if (!tc.movePosition(QTextCursor::Right, QTextCursor::KeepAnchor))
+	if (!tc.movePosition(QTextCursor::Right, QTextCursor::KeepAnchor)) {
 		ins_nl = true;
+	}
 	QString l = tc.selectedText();
 	tc.beginEditBlock();
 	tc.setPosition(ss);
-	if (ins_nl)
+	if (ins_nl) {
 		l.append("\n");
+	}
+
 	tc.insertText(l);
 	tc.setPosition(ss_);
 	tc.setPosition(se_, QTextCursor::KeepAnchor);
@@ -1192,26 +1237,39 @@ void QCodeEdit::copyLineUp() {
 void QCodeEdit::copyLineDown() {
 	QTextCursor tc = ui->textCode->textCursor();
 	tc.beginEditBlock();
-	int ss = tc.selectionStart(), ss_ = ss, se = tc.selectionEnd(), se_ = se;
+	int ss = tc.selectionStart();
+	int ss_ = ss;
+	int se = tc.selectionEnd();
 	QString st_ = tc.selection().toPlainText();
 	if (st_.endsWith("\n")) {
 		st_.chop(1);
-		se--; se_--;
+		se--;
 	}
-	tc.setPosition(ss); tc.movePosition(QTextCursor::StartOfLine); ss = tc.position();
+	int se_ = se;
-	tc.setPosition(se); tc.movePosition(QTextCursor::EndOfLine); se = tc.position();
+	tc.setPosition(ss);
-	tc.setPosition(ss); tc.setPosition(se, QTextCursor::KeepAnchor);
+	tc.movePosition(QTextCursor::StartOfLine);
+	ss = tc.position();
+	tc.setPosition(se);
+	tc.movePosition(QTextCursor::EndOfLine);
+	se = tc.position();
+	tc.setPosition(ss);
+
+	tc.setPosition(se, QTextCursor::KeepAnchor);
 	bool ins_nl = false;
-	if (!tc.movePosition(QTextCursor::Right, QTextCursor::KeepAnchor))
+	if (!tc.movePosition(QTextCursor::Right, QTextCursor::KeepAnchor)) {
 		ins_nl = true;
+	}
 	QString l = tc.selectedText();
 	tc.beginEditBlock();
 	tc.setPosition(ss);
-	ss_ += l.size(); se_ += l.size();
+	ss_ += l.size();
+	se_ += l.size();
 	if (ins_nl) {
 		l.append("\n");
-		ss_++; se_++;
+		ss_++;
+		se_++;
 	}
+
 	tc.insertText(l);
 	tc.setPosition(ss_);
 	tc.setPosition(se_, QTextCursor::KeepAnchor);
@@ -1223,22 +1281,33 @@ void QCodeEdit::copyLineDown() {
 
 void QCodeEdit::moveLineUp() {
 	QTextCursor tc = ui->textCode->textCursor();
-	int ss = tc.selectionStart(), ss_ = ss, se = tc.selectionEnd(), se_ = se;
+	int ss = tc.selectionStart();
+	int ss_ = ss;
+	int se = tc.selectionEnd();
 	QString st_ = tc.selection().toPlainText();
 	if (st_.endsWith("\n")) {
 		st_.chop(1);
-		se--; se_--;
+		se--;
 	}
-	tc.setPosition(ss); tc.movePosition(QTextCursor::StartOfLine); ss = tc.position();
+	int se_ = se;
-	tc.setPosition(se); tc.movePosition(QTextCursor::EndOfLine); se = tc.position();
 	tc.setPosition(ss);
-	if (!tc.movePosition(QTextCursor::Up))
+	tc.movePosition(QTextCursor::StartOfLine);
+	ss = tc.position();
+	tc.setPosition(se);
+	tc.movePosition(QTextCursor::EndOfLine);
+	se = tc.position();
+	tc.setPosition(ss);
+
+	if (!tc.movePosition(QTextCursor::Up)) {
 		return;
+	}
 	tc.beginEditBlock();
 	tc.movePosition(QTextCursor::Down, QTextCursor::KeepAnchor);
 	QString l = tc.selectedText();
-	ss -= l.size(); se -= l.size();
+	ss -= l.size();
-	ss_ -= l.size(); se_ -= l.size();
+	se -= l.size();
+	ss_ -= l.size();
+	se_ -= l.size();
 	tc.beginEditBlock();
 	tc.removeSelectedText();
 	tc.setPosition(se);
@@ -1247,6 +1316,7 @@ void QCodeEdit::moveLineUp() {
 		l.prepend("\n");
 		de = true;
 	}
+
 	tc.insertText(l);
 	if (de) {
 		tc.movePosition(QTextCursor::End);
@@ -1263,17 +1333,26 @@ void QCodeEdit::moveLineUp() {
 
 void QCodeEdit::moveLineDown() {
 	QTextCursor tc = ui->textCode->textCursor();
-	int ss = tc.selectionStart(), ss_ = ss, se = tc.selectionEnd(), se_ = se;
+	int ss = tc.selectionStart();
+	int ss_ = ss;
+	int se = tc.selectionEnd();
 	QString st_ = tc.selection().toPlainText();
 	if (st_.endsWith("\n")) {
 		st_.chop(1);
-		se--; se_--;
+		se--;
 	}
-	tc.setPosition(ss); tc.movePosition(QTextCursor::StartOfLine); ss = tc.position();
+	int se_ = se;
-	tc.setPosition(se); tc.movePosition(QTextCursor::EndOfLine); se = tc.position();
+	tc.setPosition(ss);
+	tc.movePosition(QTextCursor::StartOfLine);
+	ss = tc.position();
 	tc.setPosition(se);
-	if (!tc.movePosition(QTextCursor::Right))
+	tc.movePosition(QTextCursor::EndOfLine);
+	se = tc.position();
+	tc.setPosition(se);
+
+	if (!tc.movePosition(QTextCursor::Right)) {
 		return;
+	}
 	tc.beginEditBlock();
 	bool de = false;
 	if (!tc.movePosition(QTextCursor::Down, QTextCursor::KeepAnchor)) {
@@ -1284,15 +1363,19 @@ void QCodeEdit::moveLineDown() {
 	tc.beginEditBlock();
 	tc.removeSelectedText();
 	tc.setPosition(ss);
-	if (de) l += "\n";
+	if (de) {
+		l += "\n";
+	}
 	tc.insertText(l);
 	if (de) {
 		tc.movePosition(QTextCursor::End);
 		tc.movePosition(QTextCursor::Left, QTextCursor::KeepAnchor);
 		tc.removeSelectedText();
 	}
-	ss += l.size(); se += l.size();
+	ss += l.size();
-	ss_ += l.size(); se_ += l.size();
+	se += l.size();
+	ss_ += l.size();
+	se_ += l.size();
 	tc.setPosition(ss_);
 	tc.setPosition(se_, QTextCursor::KeepAnchor);
 	tc.endEditBlock();
@@ -1304,21 +1387,29 @@ void QCodeEdit::moveLineDown() {
 void QCodeEdit::indent() {
 	QTextCursor tc = ui->textCode->textCursor();
 	tc.beginEditBlock();
-	int ss = tc.selectionStart(), ss_ = ss, se = tc.selectionEnd(), se_ = se;
+	int ss = tc.selectionStart();
+	int ss_ = ss;
+	int se = tc.selectionEnd();
 	QString st_ = tc.selection().toPlainText();
 	if (st_.endsWith("\n")) {
 		st_.chop(1);
-		se--; se_--;
+		se--;
 	}
-	tc.setPosition(ss); tc.movePosition(QTextCursor::StartOfLine); ss = tc.position();
+	int se_ = se;
-	tc.setPosition(se); tc.movePosition(QTextCursor::EndOfLine); se = tc.position();
+	tc.setPosition(ss);
+	tc.movePosition(QTextCursor::StartOfLine);
+	ss = tc.position();
+	tc.setPosition(se);
+	tc.movePosition(QTextCursor::EndOfLine);
+	se = tc.position();
 	tc.setPosition(ss);
 	while (tc.position() < se_) {
 		tc.insertText("\t");
 		se_++;
 		tc.movePosition(QTextCursor::StartOfLine);
-		if (!tc.movePosition(QTextCursor::Down))
+		if (!tc.movePosition(QTextCursor::Down)) {
 			break;
+		}
 	}
 	tc.setPosition(ss_ + 1);
 	tc.setPosition(se_, QTextCursor::KeepAnchor);
@@ -1330,14 +1421,21 @@ void QCodeEdit::indent() {
 void QCodeEdit::deindent() {
 	QTextCursor tc = ui->textCode->textCursor();
 	tc.beginEditBlock();
-	int ss = tc.selectionStart(), ss_ = ss, se = tc.selectionEnd(), se_ = se;
+	int ss = tc.selectionStart();
+	int ss_ = ss;
+	int se = tc.selectionEnd();
 	QString st_ = tc.selection().toPlainText();
 	if (st_.endsWith("\n")) {
 		st_.chop(1);
-		se--; se_--;
+		se--;
 	}
-	tc.setPosition(ss); tc.movePosition(QTextCursor::StartOfLine); ss = tc.position();
+	int se_ = se;
-	tc.setPosition(se); tc.movePosition(QTextCursor::EndOfLine); se = tc.position();
+	tc.setPosition(ss);
+	tc.movePosition(QTextCursor::StartOfLine);
+	ss = tc.position();
+	tc.setPosition(se);
+	tc.movePosition(QTextCursor::EndOfLine);
+	se = tc.position();
 	tc.setPosition(ss);
 	bool first = true;
 	while (tc.position() < se_) {
@@ -1374,22 +1472,29 @@ void QCodeEdit::deindent() {
 
 
 void QCodeEdit::autoIndent() {
-	QTextCursor tc = ui->textCode->textCursor(), stc = tc;
+	QTextCursor tc = ui->textCode->textCursor();
+	QTextCursor stc = tc;
 	tc.movePosition(QTextCursor::StartOfLine);
-	if (!tc.movePosition(QTextCursor::Up)) return;
+	if (!tc.movePosition(QTextCursor::Up)) {
+		return;
+	}
 	tc.movePosition(QTextCursor::Down, QTextCursor::KeepAnchor);
-	QString line = tc.selectedText(), tabs;
+	QString line = tc.selectedText();
+	QString tabs;
 	int i = 0;
 	for (; i < line.size(); ++i)
 		if (!line[i].isSpace()) {
 			tabs = line.left(i);
 			break;
 		}
-	if (i >= line.size())
+	if (i >= line.size()) {
 		tabs = line.left(line.size() - 1);
+	}
 	int nt = qMax<int>(0, line.count(QChar('{')) - line.count(QChar('}')));
 	tabs.append(QString("\t").repeated(nt));
-	if (tabs.isEmpty()) return;
+	if (tabs.isEmpty()) {
+		return;
+	}
 	stc.beginEditBlock();
 	stc.insertText(tabs);
 	ui->textCode->setTextCursor(stc);
@@ -1470,7 +1575,9 @@ void QCodeEdit::setText(const QString & t) {
 
 
 void QCodeEdit::updateLines() {
-	if (timer_parse > 0) killTimer(timer_parse);
+	if (timer_parse > 0) {
+		killTimer(timer_parse);
+	}
 	timer_parse = startTimer(500);
 #if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
 #  if QT_VERSION >= QT_VERSION_CHECK(5, 11, 0)
@@ -1482,7 +1589,9 @@ void QCodeEdit::updateLines() {
 	ui->textCode->setTabStopWidth(ui->textCode->fontMetrics().width("    "));
 #endif
 	int lc = ui->textCode->document()->lineCount();
-	if (prev_lc == lc) return;
+	if (prev_lc == lc) {
+		return;
+	}
 	prev_lc = lc;
 #if QT_VERSION >= QT_VERSION_CHECK(5, 11, 0)
 	ui->textLines->setFixedWidth(ui->textLines->fontMetrics().horizontalAdvance(QString(" %1").arg(lc)));
@@ -1490,25 +1599,38 @@ void QCodeEdit::updateLines() {
 	ui->textLines->setFixedWidth(ui->textLines->fontMetrics().width(QString(" %1").arg(lc)));
 #endif
 	ui->textLines->clear();
-	for (int i = 1; i <= lc; ++i)
+	for (int i = 1; i <= lc; ++i) {
 		ui->textLines->appendPlainText(QString("%1").arg(i));
+	}
 	ui->textLines->verticalScrollBar()->setValue(ui->textCode->verticalScrollBar()->value());
 }
 
 
 QString QCodeEdit::selectArg(QString s, int arg) {
-	if (!s.contains('(') || arg < 0) return s;
+	if (!s.contains('(') || arg < 0) {
+		return s;
+	}
 	QString ss = s.left(s.indexOf('('));
 	s.remove(0, ss.size());
-	if (s.startsWith('(')) s.remove(0, 1);
+	if (s.startsWith('(')) {
-	if (s.endsWith(')')) s.chop(1);
+		s.remove(0, 1);
+	}
+	if (s.endsWith(')')) {
+		s.chop(1);
+	}
 	QStringList al = s.split(",");
 	QString ret = ss + "(";
 	for (int i = 0; i < al.size(); ++i) {
-		if (i > 0) ret += ", ";
+		if (i > 0) {
-		if (i == arg) ret += "<span style=\"font-weight:600;\">";
+			ret += ", ";
+		}
+		if (i == arg) {
+			ret += "<span style=\"font-weight:600;\">";
+		}
 		ret += al[i].trimmed();
-		if (i == arg) ret += "</span>";
+		if (i == arg) {
+			ret += "</span>";
+		}
 	}
 	ret += ")";
 	return ret;
@@ -1518,16 +1640,20 @@ QString QCodeEdit::selectArg(QString s, int arg) {
 QCodeEdit::ACEntry QCodeEdit::findEntryOnCursor(QTextCursor tc, int arg, ACClass * acc, QPair<QStringList, QString> * scope) {
 	bool ok = false;
 	QPair<QStringList, QString> sc = getScope(tc, &ok);
-	if (scope) *scope = sc;
+	if (scope) {
+		*scope = sc;
+	}
 	QString st = tc.selectedText();
-	if (arg >= 0) st = sc.second;
+	if (arg >= 0) {
+		st = sc.second;
+	}
 	if (!ok || st.isEmpty()) {
 		return ACEntry();
 	}
 	ok = false;
 	ACList acl(autoCompletitionList(sc.first, sc.second));
-	foreach (const ACSection & i, acl) {
+	for (const ACSection & i : acl) {
-		foreach (const ACEntry & s, i.second) {
+		for (const ACEntry & s : i.second) {
 			QString ts = s.name;
 			//qDebug() << ts << st;
 			if (ts != st) {
@@ -1535,14 +1661,18 @@ QCodeEdit::ACEntry QCodeEdit::findEntryOnCursor(QTextCursor tc, int arg, ACClass
 					ts.remove(0, st.size());
 					ts = ts.trimmed();
 					if (!ts.isEmpty()) {
-						if (ts[0] != '(')
+						if (ts[0] != '(') {
 							continue;
+						}
 					}
-				} else
+				} else {
 					continue;
+				}
 			}
 			//qDebug() << s.second << st;
-			if (acc) *acc = ac_classes.value(i.first);
+			if (acc) {
+				*acc = ac_classes.value(i.first);
+			}
 			return s;
 		}
 	}
@@ -1561,8 +1691,9 @@ void QCodeEdit::raiseHelp(QTextCursor tc, int arg) {
 	lbl_help[lhMain]->setText(QString("<html><body>[%1]  %2  %3</html></body>").arg(acc.name, e.type, selectArg(e.name, arg)));
 	lbl_help[lhMain]->setIcon(acc.icon);
 	QString hint;
-	if (!e.hint.isEmpty())
+	if (!e.hint.isEmpty()) {
 		hint = QString("<span style=\"font-style:italic;\">%1</span>").arg(e.hint);
+	}
 	lbl_help[lhHint]->setText(hint);
 	lbl_help[lhHint]->setHidden(hint.isEmpty());
 	//qDebug() << "help found" << tc.selectionStart() << tc.selectionEnd();
@@ -1596,14 +1727,17 @@ void QCodeEdit::raiseHelp(QTextCursor tc, int arg) {
 
 
 void QCodeEdit::gotoHelpHRef(QCodeEdit::ACEntry e) {
-	if (e.help_href.isEmpty()) return;
+	if (e.help_href.isEmpty()) {
+		return;
+	}
 	QDesktopServices::openUrl(e.help_href);
 }
 
 
 void QCodeEdit::resizeOverlay() {
-	if (overlay)
+	if (overlay) {
 		overlay->setGeometry(ui->textCode->viewport()->geometry());
+	}
 }
 
 
@@ -1622,16 +1756,22 @@ QTextCursor QCodeEdit::functionStart(QTextCursor tc, int * arg) {
 	for (i = tc.position() - 1; i >= 0; --i) {
 		if (doc[i] == ')') bcnt++;
 		if (doc[i] == '(') {
-			if (bcnt == 0)
+			if (bcnt == 0) {
 				break;
-			else
+			} else {
 				bcnt--;
+			}
+		}
+		if (doc[i] == ',' && bcnt == 0) {
+			a++;
 		}
-		//if (doc[i] == '(') bcnt--;
-		if (doc[i] == ',' && bcnt == 0) a++;
 	}
-	if (i < 0) return QTextCursor();
+	if (i < 0) {
-	if (arg) *arg = a;
+		return QTextCursor();
+	}
+	if (arg) {
+		*arg = a;
+	}
 	QTextCursor ret(ui->textCode->document());
 	ret.setPosition(i);
 	//qDebug() << "found" << i << a;
@@ -1642,23 +1782,28 @@ QTextCursor QCodeEdit::functionStart(QTextCursor tc, int * arg) {
 QCodeEdit::ACList QCodeEdit::wordsCompletitionList(const QString & written) const {
 	QCodeEdit::ACList ret;
 	if (!written.isEmpty()) {
-		QTextCursor tc = QTextCursor(ui->textCode->document()->begin()), stc;
+		QTextCursor tc = QTextCursor(ui->textCode->document()->begin());
+		QTextCursor stc;
 		QStringList acwl;
 		tc = QTextCursor(ui->textCode->document()->begin());
 		while (true) {
 			tc = ui->textCode->document()->find(written, tc);
-			if (tc.isNull()) break;
+			if (tc.isNull()) {
+				break;
+			}
 			stc = tc;
 			stc.movePosition(QTextCursor::Left);
 			stc.select(QTextCursor::WordUnderCursor);
-			if (!stc.selectedText().isEmpty() && stc.selectedText().trimmed() != written)
+			if (!stc.selectedText().isEmpty() && stc.selectedText().trimmed() != written) {
 				acwl << stc.selectedText();
+			}
 		}
 		acwl.removeDuplicates();
 		ACSection acl;
 		acl.first = -1;
-		foreach (const QString & s, acwl)
+		for (const QString & s : acwl) {
 			acl.second << ACEntry("", s);
+		}
 		ret << acl;
 	}
 	return ret;
@@ -1670,7 +1815,9 @@ QPair<QStringList, QString> QCodeEdit::getScope(QTextCursor tc, bool * ok) {
 	QTextCursor stc = tc;
 	if (tc.isNull()) {
 		completer->hide();
-		if (ok) *ok = false;
+		if (ok) {
+			*ok = false;
+		}
 		return ret;
 	}
 	int line = tc.block().firstLineNumber();
@@ -1678,7 +1825,9 @@ QPair<QStringList, QString> QCodeEdit::getScope(QTextCursor tc, bool * ok) {
 		if (auto_comp_pl != line) {
 			completer->hide();
 			auto_comp_pl = line;
-			if (ok) *ok = false;
+			if (ok) {
+				*ok = false;
+			}
 			return ret;
 		}
 	}
@@ -1694,8 +1843,9 @@ QPair<QStringList, QString> QCodeEdit::getScope(QTextCursor tc, bool * ok) {
 		written.clear();
 	} else {
 		cpos = skipCWord(doc, spos);
-		if (cpos >= 0)
+		if (cpos >= 0) {
 			written = doc.mid(cpos, spos - cpos).trimmed();
+		}
 	}
 	while (cpos >= 0) {
 		cpos--;
@@ -1737,11 +1887,15 @@ void QCodeEdit::invokeAutoCompletition(bool force) {
 		hideHelp();
 		return;
 	}
-	if (word_complete) acl << wordsCompletitionList(scope.second);
+	if (word_complete) {
+		acl << wordsCompletitionList(scope.second);
+	}
 	QFont bf(font());
 	bf.setBold(true);
 	foreach (const ACSection & ac, acl) {
-		if (ac.second.isEmpty()) continue;
+		if (ac.second.isEmpty()) {
+			continue;
+		}
 		ACClass acc = ac_classes.value(ac.first);
 		completer->addItems(bf, acc, ac);
 	}
@@ -1750,14 +1904,13 @@ void QCodeEdit::invokeAutoCompletition(bool force) {
 
 
 void QCodeEdit::commitCompletition() {
-	if (completer->currentItem() == 0) return;
+	if (completer->currentItem() == nullptr) return;
 	if (!completer->currentItem()->flags().testFlag(Qt::ItemIsSelectable)) return;
 	QString ins = completer->currentValue(), ret = completer->currentReturn();
 	QTextCursor tc = ui->textCode->textCursor(), stc = tc;
 	tc.movePosition(QTextCursor::Right, QTextCursor::KeepAnchor);
 	bool ins_br = true, shifted = false;
 	if (!tc.selectedText().isEmpty()) {
-//		if (tc.selectedText()[0].isSpace()) {
 		if (!tc.selectedText()[0].isLetterOrNumber() && !tc.selectedText()[0].isSpace() && !(tc.selectedText()[0] == '_')) {
 			stc.movePosition(QTextCursor::Left);
 			shifted = true;
@@ -1766,20 +1919,25 @@ void QCodeEdit::commitCompletition() {
 			tc.movePosition(QTextCursor::EndOfWord);
 			tc.movePosition(QTextCursor::Right, QTextCursor::KeepAnchor);
 		}
-		if (!tc.selectedText().isEmpty())
+		if (!tc.selectedText().isEmpty()) {
-			if (tc.selectedText()[0].toLatin1() == '(')
+			if (tc.selectedText()[0].toLatin1() == '(') {
 				ins_br = false;
+			}
+		}
 	}
-	if (ins.contains("("))
+	if (ins.contains("(")) {
 		ins = ins.left(ins.indexOf("(")) + "()";
-	if (!ins_br && ins.endsWith("()"))
+	}
+	if (!ins_br && ins.endsWith("()")) {
 		ins.chop(2);
+	}
 	tc = stc;
 	tc.select(QTextCursor::WordUnderCursor);
 	if (!tc.selectedText().leftJustified(1)[0].isLetterOrNumber() && !(tc.selectedText().leftJustified(1)[0] == '_')) {
 		tc = stc;
-		if (shifted)
+		if (shifted) {
 			tc.movePosition(QTextCursor::Right);
+		}
 	}
 	ui->textCode->setTextCursor(tc);
 	ui->textCode->textCursor().insertText(ins);
@@ -1817,7 +1975,9 @@ void QCodeEdit::textEdit_cursorPositionChanged() {
 	es_line.cursor.movePosition(QTextCursor::Right, QTextCursor::KeepAnchor);
 	highlightBrackets();
 	applyExtraSelection();
-	if (timer_blink) killTimer(timer_blink);
+	if (timer_blink) {
+		killTimer(timer_blink);
+	}
 	timer_blink = startTimer(QApplication::cursorFlashTime() / 2);
 	cursor_state = true;
 	createBlockSelection();
@@ -1825,7 +1985,9 @@ void QCodeEdit::textEdit_cursorPositionChanged() {
 
 
 void QCodeEdit::textEdit_textChanged() {
-	if (_replacing) return;
+	if (_replacing) {
+		return;
+	}
 	searchAll();
 	updateLines();
 }
@@ -1863,7 +2025,9 @@ void QCodeEdit::textEdit_selectionChanged() {
 
 
 void QCodeEdit::textEdit_redoAvailable(bool available) {
-	if (available) cancelBlockSelection();
+	if (available) {
+		cancelBlockSelection();
+	}
 }
 
 
@@ -1871,8 +2035,11 @@ void QCodeEdit::setShowSpaces(bool yes) {
 	spaces_ = yes;
 	QTextOption to = ui->textCode->document()->defaultTextOption();
 	QTextOption::Flags tof = to.flags();
-	if (yes) tof |= QTextOption::ShowTabsAndSpaces;
+	if (yes) {
-	else tof &= ~QTextOption::ShowTabsAndSpaces;
+		tof |= QTextOption::ShowTabsAndSpaces;
+	} else {
+		tof &= ~QTextOption::ShowTabsAndSpaces;
+	}
 	to.setFlags(tof);
 	ui->textCode->document()->setDefaultTextOption(to);
 }
@@ -1888,22 +2055,23 @@ void QCodeEdit::search(const QString & t) {
 	ui->comboSearch->setEditText(QString());
 	ui->comboSearch->setEditText(t);
 	ui->comboSearch->setFocus();
-	//searchAll();
 	searchNext(false);
 }
 
 
 void QCodeEdit::searchNext(bool next) {
-	if (es_search_list.isEmpty())
+	if (es_search_list.isEmpty()) {
 		return;
+	}
 	cur_search_ind = searchIndFromCursor() + (next ? 1 : 0);
 	moveToSearch();
 }
 
 
 void QCodeEdit::searchPrevious() {
-	if (es_search_list.isEmpty())
+	if (es_search_list.isEmpty()) {
 		return;
+	}
 	cur_search_ind = searchIndFromCursor() - 1;
 	moveToSearch();
 }
@@ -1922,9 +2090,15 @@ void QCodeEdit::on_comboSearch_currentTextChanged(const QString & t) {
 
 
 void QCodeEdit::on_buttonReplace_clicked() {
-	if (es_search_list.isEmpty() || cur_search_ind < 0 || cur_search_ind >= es_search_list.size()) return;
+	if (es_search_list.isEmpty() || cur_search_ind < 0 || cur_search_ind >= es_search_list.size()) {
-	if (ui->textCode->textCursor() != es_search_list[cur_search_ind].cursor) return;
+		return;
-	if (ui->textCode->textCursor().selectedText().size() != es_search_list[cur_search_ind].cursor.selectedText().size()) return;
+	}
+	if (ui->textCode->textCursor() != es_search_list[cur_search_ind].cursor) {
+		return;
+	}
+	if (ui->textCode->textCursor().selectedText().size() != es_search_list[cur_search_ind].cursor.selectedText().size()) {
+		return;
+	}
 	ui->textCode->textCursor().insertText(ui->comboReplace->currentText());
 }
 
@@ -1939,8 +2113,9 @@ void QCodeEdit::on_buttonReplaceAll_clicked() {
 	_replacing = true;
 	QString rt = ui->comboReplace->currentText();
 	textCursor().beginEditBlock();
-	for (int i = es_search_list.size() - 1; i >= 0; --i)
+	for (int i = es_search_list.size() - 1; i >= 0; --i) {
 		es_search_list[i].cursor.insertText(rt);
+	}
 	_replacing = false;
 	textCursor().endEditBlock();
 	textEdit_textChanged();
@@ -1950,6 +2125,8 @@ void QCodeEdit::on_buttonReplaceAll_clicked() {
 
 
 QString QCodeEdit::ACEntry::declaration() const {
-	if (declaration_pos < 0 || declaration_file.isEmpty()) return QString();
+	if (declaration_pos < 0 || declaration_file.isEmpty()) {
+		return QString();
+	}
 	return (declaration_file + ": %1").arg(declaration_pos);
 }

libs/widgets/qcodeedit.h

@@ -20,19 +20,19 @@
 #ifndef QCODEEDIT_H
 #define QCODEEDIT_H
 
-#include <QPlainTextEdit>
-#include <QTreeWidget>
-#include <QScrollBar>
-#include <QUrl>
-#include "iconedlabel.h"
 #include "qad_widgets_export.h"
+#include <QTextEdit>
+#include <QUrl>
+#include <QIcon>
 
 
 namespace Ui {
 	class QCodeEdit;
 }
 
+class QPlainTextEdit;
 class QCodeEditCompleter;
+class IconedLabel;
 class _QCE_Viewport;
 
 
@@ -50,7 +50,7 @@ class QAD_WIDGETS_EXPORT QCodeEdit: public QWidget
 	
 public:
 	QCodeEdit(QWidget * parent = nullptr);
-	~QCodeEdit();
+	~QCodeEdit() override;
 	
 	enum ACClassType {
 		Keyword,
@@ -99,7 +99,6 @@ public:
 	QPlainTextEdit * textEdit() const;
 	
 	void registerAutoCompletitionClass(int id, ACClassType ac_class, const QString & name, const QIcon & icon = QIcon());
-	
 	bool wordCompletitionEnabled() const {return word_complete;}
 
 protected:
@@ -118,71 +117,11 @@ protected:
 	void raiseHelp(QTextCursor tc, int arg = -1);
 	QTextCursor functionStart(QTextCursor tc, int * arg);
 	ACList wordsCompletitionList(const QString & written) const;
-	QPair<QStringList, QString> getScope(QTextCursor tc, bool * ok = 0);
+	QPair<QStringList, QString> getScope(QTextCursor tc, bool * ok = nullptr);
 	static int skipRange(const QString & s, int pos, QChar oc, QChar cc, QChar sc = QChar());
 	static int skipCWord(const QString & s, int pos);
 	static bool matchWritten(QString s, QString w);
 	static QChar pairChar(QChar c);
-	
-	Ui::QCodeEdit * ui;
-
-private:
-	struct QAD_WIDGETS_EXPORT ACClass {
-		ACClass(int i = -2, ACClassType c = QCodeEdit::Keyword, const QString & n = QString(), const QIcon & ic = QIcon()): id(i), class_(c), name(n), icon(ic) {}
-		int id;
-		ACClassType class_;
-		QString name;
-		QIcon icon;
-	};
-	enum LabelHelpType {
-		lhMain,
-		lhHint,
-		lhF1,
-		lh_last
-	};
-	
-	QCodeEditCompleter * completer;
-	IconedLabel * lbl_help[3];
-	QFrame * widget_help;
-	_QCE_Viewport * overlay;
-	QTextEdit::ExtraSelection es_line, es_cursor, es_bracket, es_range, es_search, es_link;
-	QList<QTextEdit::ExtraSelection> es_selected, es_custom, es_brackets, es_search_list, es_blockselection;
-	QMap<int, ACClass> ac_classes;
-	QStringList cursor_scope;
-	QString comment_text;
-	ACEntry link_entry, help_entry;
-	QTextCursor block_start_cursor, drag_cursor;
-	int prev_lc, auto_comp_pl, timer_parse, timer_blink, cur_search_ind, pos_press, pos_el_press;
-	int cursor_width;
-	bool spaces_, _ignore_focus_out, _first, _destructor, _replacing;
-	bool word_complete, help_visible, cursor_state, block_sel_state;
-	
-	bool eventFilter(QObject * o, QEvent * e) override;
-	void showEvent(QShowEvent * ) override;
-	void timerEvent(QTimerEvent * ) override;
-	void leaveEvent(QEvent * ) override;
-	void changeEvent(QEvent * e) override;
-	bool codeKeyEvent(QKeyEvent * ke);
-	void toggleComment();
-	void highlightBrackets();
-	void applyExtraSelection();
-	void clearSearch();
-	void moveToSearch();
-	int searchIndFromCursor();
-	QRect cursorRect();
-	QRect blockSelectionRect();
-	QVector<QTextCursor> blockSelectionCursors(QRect bsr);
-	void repaintCursor();
-	void drawCursor();
-	bool hasBlockSelection() const;
-	void startBlockSelection();
-	void cancelBlockSelection();
-	void switchBlockSelection(QKeyEvent * ke = nullptr);
-	bool removeBlockSelection(bool is_del);
-	void insertBlockSelection(QString text);
-	void createBlockSelection();
-	void cancelDragCursor();
-	ACEntry findEntryOnCursor(QTextCursor tc, int arg = -1, ACClass * acc = 0, QPair<QStringList, QString> * scope = 0);
 
 private slots:
 	void _activateLink(QCodeEdit::ACEntry e) {linkClicked(e);}
@@ -236,6 +175,64 @@ signals:
 	void textChanged();
 	void parseRequest();
 	
+private:
+	struct QAD_WIDGETS_EXPORT ACClass {
+		ACClass(int i = -2, ACClassType c = QCodeEdit::Keyword, const QString & n = QString(), const QIcon & ic = QIcon()): id(i), class_(c), name(n), icon(ic) {}
+		int id;
+		ACClassType class_;
+		QString name;
+		QIcon icon;
+	};
+	enum LabelHelpType {
+		lhMain,
+		lhHint,
+		lhF1,
+		lh_last
+	};
+
+	bool eventFilter(QObject * o, QEvent * e) override;
+	void showEvent(QShowEvent * ) override;
+	void timerEvent(QTimerEvent * ) override;
+	void leaveEvent(QEvent * ) override;
+	void changeEvent(QEvent * e) override;
+	bool codeKeyEvent(QKeyEvent * ke);
+	void toggleComment();
+	void highlightBrackets();
+	void applyExtraSelection();
+	void clearSearch();
+	void moveToSearch();
+	int searchIndFromCursor();
+	QRect cursorRect();
+	QRect blockSelectionRect();
+	QVector<QTextCursor> blockSelectionCursors(QRect bsr);
+	void repaintCursor();
+	void drawCursor();
+	bool hasBlockSelection() const;
+	void startBlockSelection();
+	void cancelBlockSelection();
+	void switchBlockSelection(QKeyEvent * ke = nullptr);
+	bool removeBlockSelection(bool is_del);
+	void insertBlockSelection(QString text);
+	void createBlockSelection();
+	void cancelDragCursor();
+	ACEntry findEntryOnCursor(QTextCursor tc, int arg = -1, ACClass * acc = nullptr, QPair<QStringList, QString> * scope = nullptr);
+
+	Ui::QCodeEdit * ui;
+	QCodeEditCompleter * completer;
+	IconedLabel * lbl_help[3];
+	QFrame * widget_help;
+	_QCE_Viewport * overlay;
+	QTextEdit::ExtraSelection es_line, es_cursor, es_bracket, es_range, es_search, es_link;
+	QList<QTextEdit::ExtraSelection> es_selected, es_custom, es_brackets, es_search_list, es_blockselection;
+	QMap<int, ACClass> ac_classes;
+	QStringList cursor_scope;
+	QString comment_text;
+	ACEntry link_entry, help_entry;
+	QTextCursor block_start_cursor, drag_cursor;
+	int prev_lc, auto_comp_pl, timer_parse, timer_blink, cur_search_ind, pos_press, pos_el_press;
+	int cursor_width;
+	bool spaces_, _ignore_focus_out, _first, _destructor, _replacing;
+	bool word_complete, help_visible, cursor_state, block_sel_state;
 };
 
 

libs/widgets/qcodeedit_completer_p.cpp

@@ -1,5 +1,6 @@
 #include "qcodeedit_completer_p.h"
 #include "qad_types.h"
+#include <QKeyEvent>
 #include <QHeaderView>
 
 
@@ -22,7 +23,6 @@ QCodeEditCompleter::QCodeEditCompleter(QWidget * parent): QTreeWidget(parent) {
 #endif
 				(QHeaderView::ResizeToContents);
 	header()->setStretchLastSection(false);
-	//connect(verticalScrollBar(), SIGNAL(valueChanged(int)), this, SLOT(adjust()));
 }
 
 

libs/widgets/qcodeedit_completer_p.h

@@ -20,16 +20,16 @@
 #ifndef QCODEEDIT_COMPLETER_P_H
 #define QCODEEDIT_COMPLETER_P_H
 
-#include <QTreeWidget>
 #include "qcodeedit.h"
+#include <QTreeWidget>
 
 
 class QCodeEditCompleter: public QTreeWidget
 {
 	Q_OBJECT
 public:
-	QCodeEditCompleter(QWidget * parent = 0);
+	QCodeEditCompleter(QWidget * parent = nullptr);
-	~QCodeEditCompleter();
+	~QCodeEditCompleter() override;
 
 	void nextCompletition();
 	void previousCompletition();
@@ -39,16 +39,15 @@ public:
 	QString currentReturn() const;
 	QString currentValue() const;
 
-private:
-	void keyPressEvent(QKeyEvent * e) override;
-
 private slots:
 	void adjust();
 
 signals:
 	void commit();
 	void gotoHRef(QCodeEdit::ACEntry e);
-	
+
+private:
+	void keyPressEvent(QKeyEvent * e) override;
 };
 
 

libs/widgets/qipedit.cpp

@@ -1,4 +1,10 @@
 #include "qipedit.h"
+#include "qalgorithms.h"
+#include <QLabel>
+#include <QLineEdit>
+#include <QBoxLayout>
+#include <QIntValidator>
+
 
 QIPEdit::QIPEdit(QWidget * parent, const QString & ip): QWidget(parent) {
 	layout = new QBoxLayout(QBoxLayout::LeftToRight, this);
@@ -19,32 +25,20 @@ QIPEdit::QIPEdit(QWidget * parent, const QString & ip): QWidget(parent) {
 			layout->addWidget(dots.back());
 		}
 	}
-	//for (int i = 0; i < 3; i++) edits[i]->setTabOrder(edits[i+1], edits[i]);
+	connect(edits[0], &QLineEdit::returnPressed, this, &QIPEdit::returnPressed0);
-	connect(edits[0], SIGNAL(returnPressed()), this, SLOT(returnPressed0()));
+	connect(edits[1], &QLineEdit::returnPressed, this, &QIPEdit::returnPressed1);
-	connect(edits[1], SIGNAL(returnPressed()), this, SLOT(returnPressed1()));
+	connect(edits[2], &QLineEdit::returnPressed, this, &QIPEdit::returnPressed2);
-	connect(edits[2], SIGNAL(returnPressed()), this, SLOT(returnPressed2()));
+	connect(edits[3], &QLineEdit::returnPressed, this, &QIPEdit::returnPressed3);
-	connect(edits[3], SIGNAL(returnPressed()), this, SLOT(returnPressed3()));
+	connect(edits[0], &QLineEdit::textChanged, this, &QIPEdit::textChanged0);
-	connect(edits[0], SIGNAL(textChanged(const QString & )), this, SLOT(textChanged0(const QString & )));
+	connect(edits[1], &QLineEdit::textChanged, this, &QIPEdit::textChanged1);
-	connect(edits[1], SIGNAL(textChanged(const QString & )), this, SLOT(textChanged1(const QString & )));
+	connect(edits[2], &QLineEdit::textChanged, this, &QIPEdit::textChanged2);
-	connect(edits[2], SIGNAL(textChanged(const QString & )), this, SLOT(textChanged2(const QString & )));
+	connect(edits[3], &QLineEdit::textChanged, this, &QIPEdit::textChanged3);
-	connect(edits[3], SIGNAL(textChanged(const QString & )), this, SLOT(textChanged3(const QString & )));
 	setLayout(layout);
 	setIP(ip);
 	cind = 0;
 }
 
 
-QIPEdit::~QIPEdit() {
-	foreach (QLineEdit * i, edits)
-		delete i;
-	foreach (QLabel * i, dots)
-		delete i;
-	edits.clear();
-	dots.clear();
-	delete layout;
-}
-
-
 void QIPEdit::setIP(const QString & text) {
 	QString s, str = text;
 	s = str.left(str.indexOf('.'));
@@ -80,3 +74,11 @@ void QIPEdit::returnPress(int index) {
 		edits[index + 1]->setSelection(0, 3);
 	}
 }
+
+
+inline void QIPEdit::textChange(int index, const QString &text) {
+	if (text.length() == 3 && isVisible()) {
+		returnPress(index);
+	}
+	emit valueChanged(IP());
+}

libs/widgets/qipedit.h

@@ -20,13 +20,13 @@
 #ifndef QIPEDIT_H
 #define QIPEDIT_H
 
-#include <QVector>
-#include <QBoxLayout>
-#include <QIntValidator>
-#include <QFocusEvent>
-#include <QLineEdit>
-#include <QLabel>
 #include "qad_widgets_export.h"
+#include <QWidget>
+
+
+class QBoxLayout;
+class QLineEdit;
+class QLabel;
 
 
 class QAD_WIDGETS_EXPORT QIPEdit: public QWidget
@@ -35,19 +35,9 @@ class QAD_WIDGETS_EXPORT QIPEdit: public QWidget
 	Q_PROPERTY(QString IP READ IP WRITE setIP)
 	
 public:
-	QIPEdit(QWidget * parent = 0, const QString & ip = "");
+	QIPEdit(QWidget * parent = nullptr, const QString & ip = "");
-	~QIPEdit();
 	
 	QString IP();
-
-private:
-	void returnPress(int index);
-	inline void textChange(int index, const QString & text) {if (text.length() == 3 && isVisible()) returnPress(index); emit valueChanged(IP());}
-
-	int cind;
-	QBoxLayout * layout;
-	QVector<QLineEdit * > edits;
-	QVector<QLabel * > dots;
 	
 public slots:
 	void setIP(const QString & text);
@@ -64,6 +54,15 @@ private slots:
 	
 signals:
 	void valueChanged(QString);
+
+private:
+	void returnPress(int index);
+	void textChange(int index, const QString &text);
+
+	int cind;
+	QBoxLayout * layout;
+	QList<QLineEdit * > edits;
+	QList<QLabel * > dots;
 };
 
 #endif // QIPEDIT_H

libs/widgets/qpiconfignewdialog.cpp

@@ -24,7 +24,7 @@ void QPIConfigNewDialog::changeEvent(QEvent * e) {
 
 
 void QPIConfigNewDialog::typeChanged() {
-	foreach (QRadioButton * i, radios) {
+	for (const QRadioButton * i : radios) {
 		if (i->isChecked()) {
 			ui->widgetValue->setType(i->property("type").toString());
 			return;
@@ -34,9 +34,11 @@ void QPIConfigNewDialog::typeChanged() {
 
 
 QString QPIConfigNewDialog::type() {
-	foreach (QRadioButton * i, radios)
+	for (const QRadioButton * i : radios) {
-		if (i->isChecked())
+		if (i->isChecked()) {
 			return i->property("type").toString();
+		}
+	}
 	return " ";
 }
 

libs/widgets/qpiconfignewdialog.h

@@ -21,7 +21,6 @@
 #define QPICONFIGNEWDIALOG_H
 
 #include <QDialog>
-#include <QRadioButton>
 #include "qad_widgets_export.h"
 
 
@@ -29,13 +28,15 @@ namespace Ui {
 	class QPIConfigNewDialog;
 }
 
+class QRadioButton;
+
 
 class QAD_WIDGETS_EXPORT QPIConfigNewDialog: public QDialog
 {
 	Q_OBJECT
 	
 public:
-	QPIConfigNewDialog(QWidget * parent = 0);
+	QPIConfigNewDialog(QWidget * parent = nullptr);
 	
 	QString type();
 	QString name();
@@ -44,15 +45,14 @@ public:
 	void reset(bool node = false);
 	
 protected:
-	void changeEvent(QEvent * e);
+	void changeEvent(QEvent * e) override;
-	
-	Ui::QPIConfigNewDialog * ui;
 	
 private slots:
 	void on_lineName_textChanged(const QString & text);
 	void typeChanged();
 
 private:
+	Ui::QPIConfigNewDialog * ui;
 	QList<QRadioButton * > radios;
 	
 };

libs/widgets/qpiconfigwidget.cpp

@@ -1,15 +1,22 @@
 #include "qpiconfigwidget.h"
+#include "qalgorithms.h"
+#include "qpiconfigvaluewidget.h"
+#include <QMouseEvent>
+#include <QApplication>
+#include <QVariant>
 
 
 QPIConfigWidget::QPIConfigWidget(QWidget * parent, QPIConfig * c, bool on): QTreeWidget(parent), actionAddItem(this), actionAddNode(this),
-																			actionToItem(this), actionToNode(this), actionRemove(this),
+	actionToItem(this), actionToNode(this), actionRemove(this),
-																			actionExpandAll(this), actionCollapseAll(this) {
+	actionExpandAll(this), actionCollapseAll(this) {
 	active = on;
 	if (active) {
 		setColumnCount(4);
 		setColumnWidth(0, 150);
 		setColumnWidth(1, 200);
-	} else setColumnCount(0);
+	} else {
+		setColumnCount(0);
+	}
 	setSelectionMode(ExtendedSelection);
 	setVerticalScrollMode(ScrollPerPixel);
 	actionAddItem.setIcon(QIcon(":/icons/item-add.png"));
@@ -20,9 +27,6 @@ QPIConfigWidget::QPIConfigWidget(QWidget * parent, QPIConfig * c, bool on): QTre
 	popupMenu.addAction(&actionAddItem);
 	popupMenu.addAction(&actionAddNode);
 	popupMenu.addSeparator();
-	/*popupMenu.addAction(&actionToItem);
-	popupMenu.addAction(&actionToNode);
-	popupMenu.addSeparator();*/
 	popupMenu.addAction(&actionRemove);
 	popupMenu.addSeparator();
 	popupMenu.addAction(&actionExpandAll);
@@ -40,8 +44,6 @@ QPIConfigWidget::QPIConfigWidget(QWidget * parent, QPIConfig * c, bool on): QTre
 	pi = c_pi = 0;
 	translate();
 	setQPIConfig(c);
-	//resize(600, 400);
-	//show();
 }
 
 
@@ -62,12 +64,12 @@ bool QPIConfigWidget::eventFilter(QObject * o, QEvent * e) {
 				qApp->processEvents();
 				itemClicked(pi, 1);
 				popupMenu.popup(
-#if QT_VERSION_MAJOR <= 5
+			#if QT_VERSION_MAJOR <= 5
 							((QMouseEvent * )e)->globalPos()
-#else
+			#else
 							((QMouseEvent * )e)->globalPosition().toPoint()
-#endif
+			#endif
-								);
+							);
 			}
 		}
 	}
@@ -76,15 +78,21 @@ bool QPIConfigWidget::eventFilter(QObject * o, QEvent * e) {
 
 
 void QPIConfigWidget::itemClicked(QTreeWidgetItem * item, int column) {
-	if (item != 0) {
+	if (item) {
-		if ((column == 0 && !read_only_name) || (column == 3 && !read_only_comment)) item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable);
+		if ((column == 0 && !read_only_name) || (column == 3 && !read_only_comment)) {
-		else item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
+			item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable);
+		} else {
+			item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
+		}
 	}
 	bool node = true, ro = read_only_name || read_only_type || read_only_value;
-	if (item != 0)
+	if (item) {
-		if (itemTWidget(item) != 0)
+		if (itemTWidget(item)) {
-			if (itemTWidget(item)->isEnabled())
+			if (itemTWidget(item)->isEnabled()) {
 				node = false;
+			}
+		}
+	}
 	actionAddItem.setVisible(node && !ro);
 	actionAddNode.setVisible(node && !ro);
 	actionRemove.setVisible(!ro && !selectedItems().isEmpty());
@@ -94,24 +102,32 @@ void QPIConfigWidget::itemClicked(QTreeWidgetItem * item, int column) {
 void QPIConfigWidget::itemChanged(QTreeWidgetItem * item, int column) {
 	if (item != c_pi) {
 		c_pi = item;
-		if (item != 0) {
+		if (item) {
 			c_name = item->text(0);
 			c_comment = item->text(3);
 		}
 		return;
 	}
-	if (item == 0) return;
+	if (item == nullptr) {
-	if (c_name == item->text(0) && c_comment == item->text(3)) return;
+		return;
+	}
+	if (c_name == item->text(0) && c_comment == item->text(3)) {
+		return;
+	}
 	//qDebug() << "change" << item->text(0);
 	QPIConfig::Entry * e = itemEntry(item);
-	if (e == 0) return;
+	if (e == nullptr) {
+		return;
+	}
 	if (column == 0) {
 		buildFullNames(item);
 		e->setName(item->text(column));
 		conf->buildFullNames(e->parent());
 		//qDebug() << itemCWidget(item)->full_name;
 	}
-	if (column == 3) e->setComment(item->text(column));
+	if (column == 3) {
+		e->setComment(item->text(column));
+	}
 	c_name = item->text(0);
 	c_comment = item->text(3);
 	emit changed();
@@ -119,7 +135,7 @@ void QPIConfigWidget::itemChanged(QTreeWidgetItem * item, int column) {
 
 
 void QPIConfigWidget::typeChange(int t, UComboBox * c) {
-	ConfigValueWidget * cw = (ConfigValueWidget * )c->property("qpic_widget").toLongLong();
+	auto cw = reinterpret_cast<ConfigValueWidget *>(c->property("qpic_widget").toLongLong());
 	cw->setType(types.key(s_types[t]));
 	conf->getValue(cw->full_name).setType(types.key(s_types[t]));
 	emit changed();
@@ -133,12 +149,19 @@ void QPIConfigWidget::valueChange(ConfigValueWidget * w, QString v) {
 
 
 void QPIConfigWidget::on_actionAddItem_triggered() {
-	if (conf == 0 || !active) return;
+	if (conf == nullptr || !active) {
+		return;
+	}
 	QString fp;
-	if (pi == 0) pi = invisibleRootItem();
+	if (pi == nullptr) {
-	else fp = itemCWidget(pi)->full_name + conf->delim;
+		pi = invisibleRootItem();
+	} else {
+		fp = itemCWidget(pi)->full_name + conf->delim;
+	}
 	new_dialog.reset();
-	if (new_dialog.exec() == QDialog::Rejected) return;
+	if (new_dialog.exec() == QDialog::Rejected) {
+		return;
+	}
 	QPIConfig::Entry * e;
 	if (pi->childCount() == 0) {
 		//qDebug() << "pi empty, remove " << itemCWidget(pi)->full_name;
@@ -151,40 +174,50 @@ void QPIConfigWidget::on_actionAddItem_triggered() {
 	pi->setText(0, new_dialog.name());
 	pi->setText(3, new_dialog.comment());
 	int ind = s_types.indexOf(types[new_dialog.type()]);
-	if (ind < 0) w_types.back()->setCurrentIndex(0);
+	if (ind < 0) {
-	else w_types.back()->setCurrentIndex(ind);
+		w_types.back()->setCurrentIndex(0);
+	} else {
+		w_types.back()->setCurrentIndex(ind);
+	}
 	emit changed();
 }
 
 
 void QPIConfigWidget::on_actionAddNode_triggered() {
-	if (conf == 0 || !active) return;
+	if (conf == nullptr || !active) {
+		return;
+	}
 	QString fp;
-	if (pi == 0) pi = invisibleRootItem();
+	if (pi == nullptr) {
-	else fp = itemCWidget(pi)->full_name + conf->delim;
+		pi = invisibleRootItem();
+	} else {
+		fp = itemCWidget(pi)->full_name + conf->delim;
+	}
 	new_dialog.reset(true);
-	if (new_dialog.exec() == QDialog::Rejected) return;
+	if (new_dialog.exec() == QDialog::Rejected) {
+		return;
+	}
 	QPIConfig::Entry e;
-	//e = &(conf->addEntry(fp + new_dialog.name(), "", "", false));
 	e._full_name = fp + new_dialog.name();
 	expandItem(pi);
 	pi = addEntry(pi, &e, true);
 	pi->setText(0, new_dialog.name());
 	pi->setText(3, new_dialog.comment());
-	setItemWidget(pi, 2, 0);
+	setItemWidget(pi, 2, nullptr);
 	emit changed();
 }
 
 
 void QPIConfigWidget::on_actionRemove_triggered() {
-	//hide();
+	if (conf == nullptr || !active) {
-	if (conf == 0 || !active) return;
+		return;
+	}
 	QList<QTreeWidgetItem * > si = selectedItems();
 	conf->buildFullNames(&(conf->root));
 	QPIConfig::Entry * e;
-	foreach (QTreeWidgetItem * i, si) {
+	for (QTreeWidgetItem * i : si) {
 		e = itemEntry(i);
-		if (e == 0) continue;
+		if (e == nullptr) continue;
 		//qDebug() << "remove " + e->_full_name;
 		conf->removeEntry(e->_full_name, false);
 		deleteEntry(i);
@@ -199,10 +232,8 @@ void QPIConfigWidget::clear() {
 	bool hidden = isHidden();
 	hide();
 	QTreeWidget::clear();
-	foreach (ConfigValueWidget * i, w_values)
+	qDeleteAll(w_values);
-		delete i;
+	qDeleteAll(w_types);
-	foreach (QComboBox * i, w_types)
-		delete i;
 	w_values.clear();
 	w_types.clear();
 	if (!hidden) show();
@@ -211,7 +242,7 @@ void QPIConfigWidget::clear() {
 
 void QPIConfigWidget::buildTree() {
 	if (!active) return;
-	if (conf == 0) return;
+	if (conf == nullptr) return;
 	bool hidden = isHidden();
 	hide();
 	clear();
@@ -223,14 +254,15 @@ void QPIConfigWidget::buildTree() {
 
 void QPIConfigWidget::setReadOnlyValue(bool yes) {
 	read_only_value = yes;
-	foreach (ConfigValueWidget * i, w_values)
+	for (ConfigValueWidget * i : w_values) {
 		i->setEnabled(!yes);
+	}
 }
 
 
 void QPIConfigWidget::setReadOnlyType(bool yes) {
 	read_only_type = yes;
-	foreach (QComboBox * i, w_types) {
+	for (QComboBox * i : w_types) {
 		i->setEnabled(!yes);
 		i->setFrame(!yes);
 	}
@@ -238,32 +270,36 @@ void QPIConfigWidget::setReadOnlyType(bool yes) {
 
 
 void QPIConfigWidget::buildEntry(QTreeWidgetItem * i, QPIConfig::Entry * e) {
-	foreach (QPIConfig::Entry * j, e->children())
+	for (QPIConfig::Entry * j : e->children()) {
 		buildEntry(addEntry(i, j, !j->isLeaf()), j);
+	}
 }
 
 
 void QPIConfigWidget::buildFullNames(QTreeWidgetItem * i) {
 	ConfigValueWidget * cw, * pw;
 	cw = itemCWidget(i);
-	if (i->parent() != 0) {
+	if (i->parent()) {
 		pw = itemCWidget(i->parent());
 		cw->full_name = pw->full_name + conf->delim + i->text(0);
-	} else cw->full_name = i->text(0);
+	} else {
-	for (int j = 0; j < i->childCount(); ++j)
+		cw->full_name = i->text(0);
+	}
+	for (int j = 0; j < i->childCount(); ++j) {
 		buildFullNames(i->child(j));
+	}
 }
 
 
 QPIConfig::Entry * QPIConfigWidget::itemEntry(QTreeWidgetItem * i) {
 	ConfigValueWidget * cfw = itemCWidget(i);
-	if (cfw == 0) return 0;
+	if (!cfw) return nullptr;
 	return &(conf->getValue(cfw->full_name));
 }
 
 
 QTreeWidgetItem * QPIConfigWidget::addEntry(QTreeWidgetItem * i, QPIConfig::Entry * e, bool node) {
-	if (conf == 0) return 0;
+	if (conf == nullptr) return nullptr;
 	ti = new QTreeWidgetItem();
 	ti->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
 	ti->setSizeHint(0, QSize(26, 26));
@@ -276,7 +312,7 @@ QTreeWidgetItem * QPIConfigWidget::addEntry(QTreeWidgetItem * i, QPIConfig::Entr
 		w_types.push_back(new UComboBox());
 		w_types.back()->addItems(s_types);
 		w_types.back()->setCurrentIndex(s_types.indexOf(types[e->type().leftJustified(1).left(1)]));
-		w_types.back()->setProperty("qpic_widget", QVariant((qlonglong)w_values.back()));
+		w_types.back()->setProperty("qpic_widget", QVariant(reinterpret_cast<qlonglong>(w_values.back())));
 		w_types.back()->setEnabled(!read_only_type);
 		w_types.back()->setFrame(!read_only_type);
 		connect(w_types.back(), SIGNAL(currentIndexChanged(int, UComboBox * )), this, SLOT(typeChange(int,UComboBox * )));
@@ -286,9 +322,9 @@ QTreeWidgetItem * QPIConfigWidget::addEntry(QTreeWidgetItem * i, QPIConfig::Entr
 	setItemWidget(ti, 1, w_values.back());
 	if (!node) {
 		setItemWidget(ti, 2, w_types.back());
-		if (itemTWidget(i) != 0) { //itemTWidget(i)->setEnabled(false);
+		if (itemTWidget(i)) {
 			w_types.remove(w_types.indexOf(itemTWidget(i)));
-			setItemWidget(i, 2, 0);
+			setItemWidget(i, 2, nullptr);
 		}
 	}
 	return ti;
@@ -299,15 +335,16 @@ void QPIConfigWidget::deleteEntry(QTreeWidgetItem * i) {
 	ConfigValueWidget * vw;
 	UComboBox * cb;
 	int cc = i->childCount();
-	for (int j = 0; j < cc; ++j)
+	for (int j = 0; j < cc; ++j) {
 		deleteEntry(i->child(0));
+	}
 	vw = qobject_cast<ConfigValueWidget * >(itemWidget(i, 1));
 	cb = qobject_cast<UComboBox * >(itemWidget(i, 2));
-	if (vw != 0) {
+	if (vw) {
 		w_values.remove(w_values.indexOf(vw));
 		delete vw;
 	}
-	if (cb != 0) {
+	if (cb) {
 		w_types.remove(w_types.indexOf(cb));
 		delete cb;
 	}
@@ -316,10 +353,15 @@ void QPIConfigWidget::deleteEntry(QTreeWidgetItem * i) {
 
 
 bool QPIConfigWidget::filter(const QString & f, QTreeWidgetItem * i) {
-	if (i->childCount() == 0) return filterItem(f, i);
+	if (i->childCount() == 0) {
+		return filterItem(f, i);
+	}
 	bool found = false;
-	for (int j = 0; j < i->childCount(); ++j)
+	for (int j = 0; j < i->childCount(); ++j) {
-		if (filter(f, i->child(j))) found = true;
+		if (filter(f, i->child(j))) {
+			found = true;
+		}
+	}
 	i->setHidden(!found);
 	return found;
 }
@@ -331,10 +373,11 @@ bool QPIConfigWidget::filterItem(const QString & f, QTreeWidgetItem * i) {
 		return true;
 	}
 	bool ret = (!isColumnHidden(0) && i->text(0).indexOf(f, 0, Qt::CaseInsensitive) >= 0) ||
-			   (!isColumnHidden(1) && itemCWidget(i)->value.indexOf(f, 0, Qt::CaseInsensitive) >= 0) ||
+			(!isColumnHidden(1) && itemCWidget(i)->value.indexOf(f, 0, Qt::CaseInsensitive) >= 0) ||
-			   (!isColumnHidden(3) && i->text(3).indexOf(f, 0, Qt::CaseInsensitive) >= 0);
+			(!isColumnHidden(3) && i->text(3).indexOf(f, 0, Qt::CaseInsensitive) >= 0);
-	if (itemTWidget(i) != 0)
+	if (itemTWidget(i)) {
 		ret = ret || (!isColumnHidden(2) && itemTWidget(i)->currentText().indexOf(f, 0, Qt::CaseInsensitive) >= 0);
+	}
 	i->setHidden(!ret);
 	return ret;
 }
@@ -364,21 +407,121 @@ void QPIConfigWidget::translate() {
 	actionRemove.setText(tr("Remove"));
 	actionExpandAll.setText(tr("Expand all"));
 	actionCollapseAll.setText(tr("Collapse all"));
-	if (!active) return;
+	if (!active) {
-	for (int i = 0; i < 4; ++i)
+		return;
+	}
+	for (int i = 0; i < 4; ++i) {
 		setColumnHidden(i, c_hidden[i]);
+	}
 }
 
 
 QString QPIConfigWidget::writeToString() {
-	if (conf == 0) return QString();
+	if (conf == nullptr) {
+		return QString();
+	}
 	conf->buildFullNames(&(conf->root));
 	return conf->writeAllToString();
 }
 
 
 void QPIConfigWidget::readFromString(QString str) {
-	if (conf == 0) return;
+	if (conf == nullptr) {
+		return;
+	}
 	conf->readAllFromString(str);
 	buildTree();
 }
+
+
+UComboBox::UComboBox(QWidget *parent) : QComboBox(parent) {
+	connect(this, SIGNAL(currentIndexChanged(int)), this, SLOT(indexChange(int)));
+}
+
+
+void QPIConfigWidget::filter(const QString &f) {
+	if (!active) {
+		return;
+	}
+	filter(f, invisibleRootItem());
+}
+
+
+void QPIConfigWidget::write() {
+	if (conf == nullptr) {
+		return;
+	}
+	conf->buildFullNames(&(conf->root));
+	conf->writeAll();
+}
+
+
+void QPIConfigWidget::parse() {
+	if (conf == nullptr) {
+		clear();
+	} else {
+		conf->readAll();
+	}
+}
+
+
+void QPIConfigWidget::setColumnNameVisible(bool yes) {
+	setColumnHidden(0, !yes);
+	c_hidden[0] = !yes;
+}
+
+
+void QPIConfigWidget::setColumnValueVisible(bool yes) {
+	setColumnHidden(1, !yes);
+	c_hidden[1] = !yes;
+}
+
+
+void QPIConfigWidget::setColumnCommentVisible(bool yes) {
+	setColumnHidden(3, !yes);
+	c_hidden[3] = !yes;
+}
+
+
+void QPIConfigWidget::setColumnTypeVisible(bool yes) {
+	setColumnHidden(2, !yes);
+	c_hidden[2] = !yes;
+}
+
+
+void QPIConfigWidget::setReadOnlyComment(bool yes) {
+	read_only_comment = yes;
+}
+
+
+void QPIConfigWidget::setReadOnlyName(bool yes) {
+	read_only_name = yes;
+}
+
+
+ConfigValueWidget *QPIConfigWidget::itemCWidget(QTreeWidgetItem *i) {
+	return qobject_cast<ConfigValueWidget *>(itemWidget(i, 1));
+}
+
+
+UComboBox *QPIConfigWidget::itemTWidget(QTreeWidgetItem *i) {
+	return qobject_cast<UComboBox *>(itemWidget(i, 2));
+}
+
+
+void QPIConfigWidget::addTrEntry(const QString &s, const QString &f) {
+	types.insert(s, f);
+	s_types << f;
+}
+
+
+void QPIConfigWidget::setQPIConfig(QPIConfig *c) {
+	conf = c;
+	buildTree();
+}
+
+
+void UComboBox::indexChange(int i) {
+	emit currentIndexChanged(i, this);
+}
+

libs/widgets/qpiconfigwidget.h

@@ -20,26 +20,28 @@
 #ifndef QPICONFIGWIDGET_H
 #define QPICONFIGWIDGET_H
 
-#include <QTreeWidget>
+#include "qad_widgets_export.h"
-#include <QComboBox>
-#include <QEvent>
-#include <QBoxLayout>
-#include <QAction>
-#include <QMenu>
 #include "qpiconfig.h"
 #include "qpiconfignewdialog.h"
-#include "qpiconfigvaluewidget.h"
+#include <QComboBox>
-#include "qad_widgets_export.h"
+#include <QTreeWidget>
+#include <QAction>
+#include <QMenu>
+
+
+class ConfigValueWidget;
 
 
 class QAD_WIDGETS_EXPORT UComboBox: public QComboBox
 {
 	Q_OBJECT
 public:
-	UComboBox(QWidget * parent = 0): QComboBox(parent) {connect(this, SIGNAL(currentIndexChanged(int)), this, SLOT(indexChange(int)));}
+	UComboBox(QWidget *parent = nullptr);
+
 private slots:
-	void indexChange(int i) {emit currentIndexChanged(i, this);}
+	void indexChange(int i);
 signals:
+
 	void currentIndexChanged(int, UComboBox * );
 };
 
@@ -56,10 +58,10 @@ class QAD_WIDGETS_EXPORT QPIConfigWidget: public QTreeWidget
 	Q_PROPERTY(bool columnTypeVisible READ columnTypeVisible WRITE setColumnTypeVisible)
 	Q_PROPERTY(bool columnCommentVisible READ columnCommentVisible WRITE setColumnCommentVisible)
 public:
-	QPIConfigWidget(QWidget * parent = 0, QPIConfig * c = 0, bool on = true);
+	QPIConfigWidget(QWidget * parent = nullptr, QPIConfig * c = nullptr, bool on = true);
-	~QPIConfigWidget() {clear();}
+	~QPIConfigWidget() override {clear();}
-	
+
-	void setQPIConfig(QPIConfig * c) {conf = c; buildTree();}
+	void setQPIConfig(QPIConfig *c);
 	bool readOnlyName() {return read_only_name;}
 	bool readOnlyValue() {return read_only_value;}
 	bool readOnlyType() {return read_only_type;}
@@ -71,21 +73,48 @@ public:
 	QString writeToString();
 	void readFromString(QString str);
 	
+public slots:
+	void parse();
+	void write();
+	void clear();
+	void buildTree();
+	void filter(const QString &f);
+	void setReadOnlyName(bool yes);
+	void setReadOnlyValue(bool yes);
+	void setReadOnlyType(bool yes);
+	void setReadOnlyComment(bool yes);
+	void setColumnNameVisible(bool yes);
+	void setColumnValueVisible(bool yes);
+	void setColumnTypeVisible(bool yes);
+	void setColumnCommentVisible(bool yes);
+
+private slots:
+	void itemClicked(QTreeWidgetItem * item, int column);
+	void itemChanged(QTreeWidgetItem * item, int column);
+	void typeChange(int t, UComboBox * c);
+	void valueChange(ConfigValueWidget * w, QString v);
+	void on_actionAddItem_triggered();
+	void on_actionAddNode_triggered();
+	void on_actionRemove_triggered();
+	
+signals:
+	void changed();
+
 private:
-	void changeEvent(QEvent * e);
+	void changeEvent(QEvent * e) override;
-	bool eventFilter(QObject * o, QEvent * e);
+	bool eventFilter(QObject * o, QEvent * e) override;
 	void buildEntry(QTreeWidgetItem * i, QPIConfig::Entry * e);
 	void buildFullNames(QTreeWidgetItem * i);
 	QPIConfig::Entry * itemEntry(QTreeWidgetItem * i);
-	ConfigValueWidget * itemCWidget(QTreeWidgetItem * i) {return qobject_cast<ConfigValueWidget * >(itemWidget(i, 1));}
+	ConfigValueWidget *itemCWidget(QTreeWidgetItem *i);
-	UComboBox * itemTWidget(QTreeWidgetItem * i) {return qobject_cast<UComboBox * >(itemWidget(i, 2));}
+	UComboBox *itemTWidget(QTreeWidgetItem *i);
 	QTreeWidgetItem * addEntry(QTreeWidgetItem * i, QPIConfig::Entry * e, bool node = false);
 	void deleteEntry(QTreeWidgetItem * i);
 	bool filter(const QString & f, QTreeWidgetItem * i);
 	bool filterItem(const QString & f, QTreeWidgetItem * i);
 	void translate();
-	void addTrEntry(const QString & s, const QString & f) {types.insert(s, f); s_types << f;}
+	void addTrEntry(const QString &s, const QString &f);
-	
+
 	QPIConfig * conf;
 	QPIConfigNewDialog new_dialog;
 	QAction actionAddItem, actionAddNode, actionToItem, actionToNode, actionRemove, actionExpandAll, actionCollapseAll;
@@ -98,34 +127,6 @@ private:
 	QVector<UComboBox * > w_types;
 	QVector<bool> c_hidden;
 	bool active, read_only_name, read_only_value, read_only_type, read_only_comment;
-	
-public slots:
-	void parse() {if (conf == 0) clear(); else conf->readAll();}
-	void write() {if (conf == 0) return; conf->buildFullNames(&(conf->root)); conf->writeAll();}
-	void clear();
-	void buildTree();
-	void filter(const QString & f) {if (!active) return; filter(f, invisibleRootItem());}
-	void setReadOnlyName(bool yes) {read_only_name = yes;}
-	void setReadOnlyValue(bool yes);
-	void setReadOnlyType(bool yes);
-	void setReadOnlyComment(bool yes) {read_only_comment = yes;}
-	void setColumnNameVisible(bool yes) {setColumnHidden(0, !yes); c_hidden[0] = !yes;}
-	void setColumnValueVisible(bool yes) {setColumnHidden(1, !yes); c_hidden[1] = !yes;}
-	void setColumnTypeVisible(bool yes) {setColumnHidden(2, !yes); c_hidden[2] = !yes;}
-	void setColumnCommentVisible(bool yes) {setColumnHidden(3, !yes); c_hidden[3] = !yes;}
-	
-private slots:
-	void itemClicked(QTreeWidgetItem * item, int column);
-	void itemChanged(QTreeWidgetItem * item, int column);
-	void typeChange(int t, UComboBox * c);
-	void valueChange(ConfigValueWidget * w, QString v);
-	void on_actionAddItem_triggered();
-	void on_actionAddNode_triggered();
-	void on_actionRemove_triggered();
-	
-signals:
-	void changed();
-	
 };
 
 #endif // QPICONFIGWIDGET_H

libs/widgets/qvariantedit_custom.h

@@ -33,6 +33,7 @@ class QAD_WIDGETS_EXPORT QVariantEditorFactoryBase {
 	friend class QVariantEdit;
 public:
 	QVariantEditorFactoryBase() {}
+	virtual ~QVariantEditorFactoryBase() {}
 	virtual QWidget * createEditor() = 0;
 private: