Qt 解析xml并高亮显示模式校验错误部分

admin

1. #ifndef XMLSYNTAXHIGHLIGHTER_H
   
2. #define XMLSYNTAXHIGHLIGHTER_H
   
3. 
   
4. #include <QtCore/QRegExp>
   
5. #include <QtGui/QSyntaxHighlighter>
   
6. 
   
7. class XmlSyntaxHighlighter : public QSyntaxHighlighter
   
8. {
   
9.     public:
   
10.         explicit XmlSyntaxHighlighter(QTextDocument *parent = nullptr);
    
11. 
    
12.     protected:
    
13.         virtual void highlightBlock(const QString &text);
    
14. 
    
15.     private:
    
16.         struct HighlightingRule
    
17.         {
    
18.             QRegExp pattern;
    
19.             QTextCharFormat format;
    
20.         };
    
21.         QVector<HighlightingRule> highlightingRules;
    
22. 
    
23.         QRegExp commentStartExpression;
    
24.         QRegExp commentEndExpression;
    
25. 
    
26.         QTextCharFormat tagFormat;
    
27.         QTextCharFormat attributeFormat;
    
28.         QTextCharFormat attributeContentFormat;
    
29.         QTextCharFormat commentFormat;
    
30. };
    
31. 
    
32. #endif
    
33. #ifndef MAINWINDOW_H
    
34. #define MAINWINDOW_H
    
35. 
    
36. #include <QMainWindow>
    
37. 
    
38. #include "ui_schema.h"
    
39. 
    
40. //! [0]
    
41. class MainWindow : public QMainWindow,
    
42.                    private Ui::SchemaMainWindow
    
43. {
    
44.     Q_OBJECT
    
45. 
    
46. public:
    
47.     MainWindow();
    
48. 
    
49. private Q_SLOTS:
    
50.     void schemaSelected(int index);
    
51.     void instanceSelected(int index);
    
52.     void validate();
    
53.     void textChanged();
    
54. 
    
55. private:
    
56.     void moveCursor(int line, int column);
    
57. };
    
58. //! [0]
    
59. #endif
    
60. #include "xmlsyntaxhighlighter.h"
    
61. 
    
62. XmlSyntaxHighlighter::XmlSyntaxHighlighter(QTextDocument *parent)
    
63.     : QSyntaxHighlighter(parent)
    
64. {
    
65.     HighlightingRule rule;
    
66. 
    
67.     // tag format
    
68.     tagFormat.setForeground(Qt::darkBlue);
    
69.     tagFormat.setFontWeight(QFont::Bold);
    
70.     rule.pattern = QRegExp("(<[a-zA-Z:]+\\b|<\\?[a-zA-Z:]+\\b|\\?>|>|/>|</[a-zA-Z:]+>)");
    
71.     rule.format = tagFormat;
    
72.     highlightingRules.append(rule);
    
73. 
    
74.     // attribute format
    
75.     attributeFormat.setForeground(Qt::darkGreen);
    
76.     rule.pattern = QRegExp("[a-zA-Z:]+=");
    
77.     rule.format = attributeFormat;
    
78.     highlightingRules.append(rule);
    
79. 
    
80.     // attribute content format
    
81.     attributeContentFormat.setForeground(Qt::red);
    
82.     rule.pattern = QRegExp("("[^"]*"|'[^']*')");
    
83.     rule.format = attributeContentFormat;
    
84.     highlightingRules.append(rule);
    
85. 
    
86.     commentFormat.setForeground(Qt::lightGray);
    
87.     commentFormat.setFontItalic(true);
    
88. 
    
89.     commentStartExpression = QRegExp("<!--");
    
90.     commentEndExpression = QRegExp("-->");
    
91. }
    
92. 
    
93. void XmlSyntaxHighlighter::highlightBlock(const QString &text)
    
94. {
    
95.      for (const HighlightingRule &rule : qAsConst(highlightingRules)) {
    
96.          QRegExp expression(rule.pattern);
    
97.          int index = text.indexOf(expression);
    
98.          while (index >= 0) {
    
99.              int length = expression.matchedLength();
    
100.              setFormat(index, length, rule.format);
     
101.              index = text.indexOf(expression, index + length);
     
102.          }
     
103.      }
     
104.      setCurrentBlockState(0);
     
105. 
     
106.      int startIndex = 0;
     
107.      if (previousBlockState() != 1)
     
108.          startIndex = text.indexOf(commentStartExpression);
     
109. 
     
110.      while (startIndex >= 0) {
     
111.          int endIndex = text.indexOf(commentEndExpression, startIndex);
     
112.          int commentLength;
     
113.          if (endIndex == -1) {
     
114.              setCurrentBlockState(1);
     
115.              commentLength = text.length() - startIndex;
     
116.          } else {
     
117.              commentLength = endIndex - startIndex
     
118.                              + commentEndExpression.matchedLength();
     
119.          }
     
120.          setFormat(startIndex, commentLength, commentFormat);
     
121.          startIndex = text.indexOf(commentStartExpression,
     
122.                                                  startIndex + commentLength);
     
123.      }
     
124. }
     
125. 
     
126. #include <QtGui>
     
127. #include <QtXmlPatterns>
     
128. 
     
129. #include "mainwindow.h"
     
130. #include "xmlsyntaxhighlighter.h"
     
131. 
     
132. //! [4]
     
133. class MessageHandler : public QAbstractMessageHandler
     
134. {
     
135. public:
     
136.     MessageHandler()
     
137.         : QAbstractMessageHandler(0)
     
138.     {
     
139.     }
     
140. 
     
141.     QString statusMessage() const
     
142.     {
     
143.         return m_description;
     
144.     }
     
145. 
     
146.     int line() const
     
147.     {
     
148.         return m_sourceLocation.line();
     
149.     }
     
150. 
     
151.     int column() const
     
152.     {
     
153.         return m_sourceLocation.column();
     
154.     }
     
155. 
     
156. protected:
     
157.     virtual void handleMessage(QtMsgType type, const QString &description,
     
158.                                const QUrl &identifier, const QSourceLocation &sourceLocation)
     
159.     {
     
160.         Q_UNUSED(type);
     
161.         Q_UNUSED(identifier);
     
162. 
     
163.         m_description = description;
     
164.         m_sourceLocation = sourceLocation;
     
165.     }
     
166. 
     
167. private:
     
168.     QString m_description;
     
169.     QSourceLocation m_sourceLocation;
     
170. };
     
171. //! [4]
     
172. 
     
173. //! [0]
     
174. MainWindow::MainWindow()
     
175. {
     
176.     setupUi(this);
     
177. 
     
178.     new XmlSyntaxHighlighter(schemaView->document());
     
179.     new XmlSyntaxHighlighter(instanceEdit->document());
     
180. 
     
181.     schemaSelection->addItem(tr("Contact Schema"));
     
182.     schemaSelection->addItem(tr("Recipe Schema"));
     
183.     schemaSelection->addItem(tr("Order Schema"));
     
184. 
     
185.     instanceSelection->addItem(tr("Valid Contact Instance"));
     
186.     instanceSelection->addItem(tr("Invalid Contact Instance"));
     
187. 
     
188.     connect(schemaSelection, SIGNAL(currentIndexChanged(int)), SLOT(schemaSelected(int)));
     
189.     connect(instanceSelection, SIGNAL(currentIndexChanged(int)), SLOT(instanceSelected(int)));
     
190.     connect(validateButton, SIGNAL(clicked()), SLOT(validate()));
     
191.     connect(instanceEdit, SIGNAL(textChanged()), SLOT(textChanged()));
     
192. 
     
193.     validationStatus->setAlignment(Qt::AlignCenter | Qt::AlignVCenter);
     
194. 
     
195.     schemaSelected(0);
     
196.     instanceSelected(0);
     
197. }
     
198. //! [0]
     
199. 
     
200. //! [1]
     
201. void MainWindow::schemaSelected(int index)
     
202. {
     
203.     instanceSelection->clear();
     
204.     if (index == 0) {
     
205.         instanceSelection->addItem(tr("Valid Contact Instance"));
     
206.         instanceSelection->addItem(tr("Invalid Contact Instance"));
     
207.     } else if (index == 1) {
     
208.         instanceSelection->addItem(tr("Valid Recipe Instance"));
     
209.         instanceSelection->addItem(tr("Invalid Recipe Instance"));
     
210.     } else if (index == 2) {
     
211.         instanceSelection->addItem(tr("Valid Order Instance"));
     
212.         instanceSelection->addItem(tr("Invalid Order Instance"));
     
213.     }
     
214.     textChanged();
     
215. 
     
216.     const QString fileName = QStringLiteral(":/schema_")
     
217.         + QString::number(index) + QStringLiteral(".xsd");
     
218.     QFile schemaFile(fileName);
     
219.     if (!schemaFile.open(QIODevice::ReadOnly)) {
     
220.         qWarning() << "Cannot open" << QDir::toNativeSeparators(fileName)
     
221.             << ':' << schemaFile.errorString();
     
222.         return;
     
223.     }
     
224. 
     
225.     const QString schemaText(QString::fromUtf8(schemaFile.readAll()));
     
226.     schemaView->setPlainText(schemaText);
     
227. 
     
228.     validate();
     
229. }
     
230. //! [1]
     
231. 
     
232. //! [2]
     
233. void MainWindow::instanceSelected(int index)
     
234. {
     
235.     if (index < 0) {
     
236.         instanceEdit->setPlainText(QString());
     
237.         return;
     
238.     }
     
239.     const QString fileName = QStringLiteral(":/instance_")
     
240.         + QString::number(2 * schemaSelection->currentIndex() + index)
     
241.         + QStringLiteral(".xml");
     
242.     QFile instanceFile(fileName);
     
243.     if (!instanceFile.open(QIODevice::ReadOnly)) {
     
244.         qWarning() << "Cannot open" << QDir::toNativeSeparators(fileName)
     
245.             << ':' << instanceFile.errorString();
     
246.         return;
     
247.     }
     
248.     const QString instanceText(QString::fromUtf8(instanceFile.readAll()));
     
249.     instanceEdit->setPlainText(instanceText);
     
250. 
     
251.     validate();
     
252. }
     
253. //! [2]
     
254. 
     
255. //! [3]
     
256. void MainWindow::validate()
     
257. {
     
258.     const QByteArray schemaData = schemaView->toPlainText().toUtf8();
     
259.     const QByteArray instanceData = instanceEdit->toPlainText().toUtf8();
     
260. 
     
261.     MessageHandler messageHandler;
     
262. 
     
263.     QXmlSchema schema;
     
264.     schema.setMessageHandler(&messageHandler);
     
265. 
     
266.     schema.load(schemaData);
     
267. 
     
268.     bool errorOccurred = false;
     
269.     if (!schema.isValid()) {
     
270.         errorOccurred = true;
     
271.     } else {
     
272.         QXmlSchemaValidator validator(schema);
     
273.         if (!validator.validate(instanceData))
     
274.             errorOccurred = true;
     
275.     }
     
276. 
     
277.     if (errorOccurred) {
     
278.         validationStatus->setText(messageHandler.statusMessage());
     
279.         moveCursor(messageHandler.line(), messageHandler.column());
     
280.     } else {
     
281.         validationStatus->setText(tr("validation successful"));
     
282.     }
     
283. 
     
284.     const QString styleSheet = QString("QLabel {background: %1; padding: 3px}")
     
285.                                       .arg(errorOccurred ? QColor(Qt::red).lighter(160).name() :
     
286.                                                            QColor(Qt::green).lighter(160).name());
     
287.     validationStatus->setStyleSheet(styleSheet);
     
288. }
     
289. //! [3]
     
290. 
     
291. void MainWindow::textChanged()
     
292. {
     
293.     instanceEdit->setExtraSelections(QList<QTextEdit::ExtraSelection>());
     
294. }
     
295. 
     
296. void MainWindow::moveCursor(int line, int column)
     
297. {
     
298.     instanceEdit->moveCursor(QTextCursor::Start);
     
299.     for (int i = 1; i < line; ++i)
     
300.         instanceEdit->moveCursor(QTextCursor::Down);
     
301. 
     
302.     for (int i = 1; i < column; ++i)
     
303.         instanceEdit->moveCursor(QTextCursor::Right);
     
304. 
     
305.     QList<QTextEdit::ExtraSelection> extraSelections;
     
306.     QTextEdit::ExtraSelection selection;
     
307. 
     
308.     const QColor lineColor = QColor(Qt::red).lighter(160);
     
309.     selection.format.setBackground(lineColor);
     
310.     selection.format.setProperty(QTextFormat::FullWidthSelection, true);
     
311.     selection.cursor = instanceEdit->textCursor();
     
312.     selection.cursor.clearSelection();
     
313.     extraSelections.append(selection);
     
314. 
     
315.     instanceEdit->setExtraSelections(extraSelections);
     
316. 
     
317.     instanceEdit->setFocus();
     
318. }
     
319. #include <QtGui>
     
320. #include "mainwindow.h"
     
321. 
     
322. //! [0]
     
323. int main(int argc, char* argv[])
     
324. {
     
325.     Q_INIT_RESOURCE(schema);
     
326.     QApplication app(argc, argv);
     
327.     MainWindow* const window = new MainWindow;
     
328.     window->show();
     
329.     return app.exec();
     
330. }

复制代码