Mercurial > projects > qtd

comparison demos/browser/bookmarks.d @ 72:b149ef2cb18b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
more porting
author mandel
date Wed, 20 May 2009 22:44:31 +0000
parents 71b382c10ef6
children 7bfd46c330dc
comparison
equal deleted inserted replaced
71:9071511f7a5b 72:b149ef2cb18b
37 ** contact the sales department at qt-sales@nokia.com. 37 ** contact the sales department at qt-sales@nokia.com.
38 ** $QT_END_LICENSE$ 38 ** $QT_END_LICENSE$
39 ** 39 **
40 ****************************************************************************/ 40 ****************************************************************************/
41 41
42 import QtCore.QObject; 42 module bookmarks;
43 import QtCore.QAbstractItemModel; 43
44 44
45 import QtGui.QUndoCommand; 45 import qt.core.QObject;
46 46 import qt.core.QAbstractItemModel;
47
48 import qt.gui.QUndoCommand;
49
50 import qt.core.QBuffer;
51 import qt.core.QFile;
52 import qt.core.QMimeData;
53
54 import qt.gui.QDesktopServices;
55 import qt.gui.QDragEnterEvent;
56 import qt.gui.QFileDialog;
57 import qt.gui.QHeaderView;
58 import qt.gui.QIcon;
59 import qt.gui.QMessageBox;
60 import qt.gui.QToolButton;
61
62 import QtWebKit.QWebSettings;
63
64 import qt.core.QDebug;
47 65
48 import bookmarks; 66 import bookmarks;
49
50 import autosaver; 67 import autosaver;
51 import browserapplication; 68 import browserapplication;
52 import history; 69 import history;
53 import xbel; 70 import xbel;
54 71
55 import QtCore.QBuffer;
56 import QtCore.QFile;
57 import QtCore.QMimeData;
58
59 import QtGui.QDesktopServices;
60 import QtGui.QDragEnterEvent;
61 import QtGui.QFileDialog;
62 import QtGui.QHeaderView;
63 import QtGui.QIcon;
64 import QtGui.QMessageBox;
65 import QtGui.QToolButton;
66
67 import QtWebKit.QWebSettings;
68
69 import QtCore.QDebug;
70 72
71 const char[] BOOKMARKBAR = "Bookmarks Bar"; 73 const char[] BOOKMARKBAR = "Bookmarks Bar";
72 const char[] BOOKMARKMENU = "Bookmarks Menu"; 74 const char[] BOOKMARKMENU = "Bookmarks Menu";
73 75
74 76
75 /*! 77 /*!
76 Bookmark manager, owner of the bookmarks, loads, saves and basic tasks 78 Bookmark manager, owner of the bookmarks, loads, saves and basic tasks
77 */ 79 */
78 /* 80
79 class AutoSaver;
80 class BookmarkNode;
81 class BookmarksModel;
82 */
83 class BookmarksManager : public QObject 81 class BookmarksManager : public QObject
84 { 82 {
85 Q_OBJECT 83
86 84 mixin Signal!("entryAdded", BookmarkNode item);
87 signals: 85 mixin Signal!("entryRemoved", BookmarkNode parent, int row, BookmarkNode item);
88 void entryAdded(BookmarkNode *item); 86 mixin Signal!("entryChanged", BookmarkNode item);
89 void entryRemoved(BookmarkNode *parent, int row, BookmarkNode *item);
90 void entryChanged(BookmarkNode *item);
91 87
92 public: 88 public:
93 BookmarksManager(QObject *parent = null) 89 BookmarksManager(QObject parent = null)
94 { 90 {
95 super(parent); 91 super(parent);
96 m_loaded = false; 92 m_loaded = false;
97 m_saveTimer = new AutoSaver(this); 93 m_saveTimer = new AutoSaver(this);
98 m_bookmarkRootNode = null; 94 m_bookmarkRootNode = null;
99 m_bookmarkModel = null; 95 m_bookmarkModel = null;
100 connect(this, SIGNAL(entryAdded(BookmarkNode *)), 96 this.entryAdded.connect(&m_saveTimer.changeOccurred);
101 m_saveTimer, SLOT(changeOccurred())); 97 this.entryRemoved.connect(&m_saveTimer.changeOccurred);
102 connect(this, SIGNAL(entryRemoved(BookmarkNode *, int, BookmarkNode *)), 98 this.entryChanged.connect(&m_saveTimer.changeOccurred);
103 m_saveTimer, SLOT(changeOccurred()));
104 connect(this, SIGNAL(entryChanged(BookmarkNode *)),
105 m_saveTimer, SLOT(changeOccurred()));
106 } 99 }
107 100
108 101
109 ~this() 102 ~this()
110 { 103 {
111 m_saveTimer.saveIfNeccessary(); 104 m_saveTimer.saveIfNeccessary();
112 } 105 }
113 106
114 107
115 void addBookmark(BookmarkNode *parent, BookmarkNode *node, int row = -1) 108 void addBookmark(BookmarkNode parent, BookmarkNode node, int row = -1)
116 { 109 {
117 if (!m_loaded) 110 if (!m_loaded)
118 return; 111 return;
119 Q_ASSERT(parent); 112 assert(parent);
120 InsertBookmarksCommand *command = new InsertBookmarksCommand(this, parent, node, row); 113 InsertBookmarksCommand command = new InsertBookmarksCommand(this, parent, node, row);
121 m_commands.push(command); 114 m_commands.push(command);
122 } 115 }
123 116
124 117
125 void removeBookmark(BookmarkNode *node); 118 void removeBookmark(BookmarkNode node);
126 { 119 {
127 if (!m_loaded) 120 if (!m_loaded)
128 return; 121 return;
129 122
130 Q_ASSERT(node); 123 assert(node);
131 BookmarkNode *parent = node.parent(); 124 BookmarkNode parent = node.parent();
132 int row = parent.children().indexOf(node); 125 int row = parent.children().indexOf(node);
133 RemoveBookmarksCommand *command = new RemoveBookmarksCommand(this, parent, row); 126 RemoveBookmarksCommand command = new RemoveBookmarksCommand(this, parent, row);
134 m_commands.push(command); 127 m_commands.push(command);
135 } 128 }
136 129
137 void setTitle(BookmarkNode *node, QString &newTitle); 130 void setTitle(BookmarkNode node, QString newTitle);
138 { 131 {
139 if (!m_loaded) 132 if (!m_loaded)
140 return; 133 return;
141 134
142 Q_ASSERT(node); 135 assert(node);
143 ChangeBookmarkCommand *command = new ChangeBookmarkCommand(this, node, newTitle, true); 136 ChangeBookmarkCommand command = new ChangeBookmarkCommand(this, node, newTitle, true);
144 m_commands.push(command); 137 m_commands.push(command);
145 } 138 }
146 139
147 140
148 void setUrl(BookmarkNode *node, QString &newUrl); 141 void setUrl(BookmarkNode node, QString newUrl);
149 { 142 {
150 if (!m_loaded) 143 if (!m_loaded)
151 return; 144 return;
152 145
153 Q_ASSERT(node); 146 assert(node);
154 ChangeBookmarkCommand *command = new ChangeBookmarkCommand(this, node, newUrl, false); 147 ChangeBookmarkCommand command = new ChangeBookmarkCommand(this, node, newUrl, false);
155 m_commands.push(command); 148 m_commands.push(command);
156 } 149 }
157 150
158 151
159 void changeExpanded() 152 void changeExpanded()
160 { 153 {
161 m_saveTimer.changeOccurred(); 154 m_saveTimer.changeOccurred();
162 } 155 }
163 156
164 BookmarkNode *bookmarks(); 157 BookmarkNode bookmarks();
165 { 158 {
166 if (!m_loaded) 159 if (!m_loaded)
167 load(); 160 load();
168 return m_bookmarkRootNode; 161 return m_bookmarkRootNode;
169 } 162 }
170 163
171 BookmarkNode *menu(); 164 BookmarkNode menu();
172 { 165 {
173 if (!m_loaded) 166 if (!m_loaded)
174 load(); 167 load();
175 168
176 for (int i = m_bookmarkRootNode.children().count() - 1; i >= 0; --i) { 169 for (int i = m_bookmarkRootNode.children().count() - 1; i >= 0; --i) {
177 BookmarkNode *node = m_bookmarkRootNode.children().at(i); 170 BookmarkNode node = m_bookmarkRootNode.children().at(i);
178 if (node.title == tr(BOOKMARKMENU)) 171 if (node.title == tr(BOOKMARKMENU))
179 return node; 172 return node;
180 } 173 }
181 Q_ASSERT(false); 174 assert(false);
182 return 0; 175 return 0;
183 } 176 }
184 177
185 BookmarkNode *toolbar(); 178 BookmarkNode toolbar();
186 { 179 {
187 if (!m_loaded) 180 if (!m_loaded)
188 load(); 181 load();
189 182
190 for (int i = m_bookmarkRootNode.children().count() - 1; i >= 0; --i) { 183 for (int i = m_bookmarkRootNode.children().count() - 1; i >= 0; --i) {
191 BookmarkNode *node = m_bookmarkRootNode.children().at(i); 184 BookmarkNode node = m_bookmarkRootNode.children().at(i);
192 if (node.title == tr(BOOKMARKBAR)) 185 if (node.title == tr(BOOKMARKBAR))
193 return node; 186 return node;
194 } 187 }
195 Q_ASSERT(false); 188 assert(false);
196 return 0; 189 return 0;
197 } 190 }
198 191
199 BookmarksModel* bookmarksModel() 192 BookmarksModel bookmarksModel()
200 { 193 {
201 if (!m_bookmarkModel) 194 if (!m_bookmarkModel)
202 m_bookmarkModel = new BookmarksModel(this, this); 195 m_bookmarkModel = new BookmarksModel(this, this);
203 return m_bookmarkModel; 196 return m_bookmarkModel;
204 } 197 }
205 198
206 QUndoStack *undoRedoStack() { return &m_commands; }; 199 QUndoStack undoRedoStack() { return m_commands; };
207 200
208 public slots: 201 public slots:
209 void importBookmarks() 202 void importBookmarks()
210 { 203 {
211 QString fileName = QFileDialog::getOpenFileName(0, tr("Open File"), 204 QString fileName = QFileDialog.getOpenFileName(0, tr("Open File"),
212 QString(), 205 QString(),
213 tr("XBEL (*.xbel *.xml)")); 206 tr("XBEL (*.xbel *.xml)"));
214 if (fileName.isEmpty()) 207 if (fileName.isEmpty())
215 return; 208 return;
216 209
217 XbelReader reader; 210 XbelReader reader;
218 BookmarkNode *importRootNode = reader.read(fileName); 211 BookmarkNode importRootNode = reader.read(fileName);
219 if (reader.error() != QXmlStreamReader::NoError) { 212 if (reader.error() != QXmlStreamReader.NoError) {
220 QMessageBox::warning(0, QLatin1String("Loading Bookmark"), 213 QMessageBox.warning(0, QLatin1String("Loading Bookmark"),
221 tr("Error when loading bookmarks on line %1, column %2:\n" 214 tr("Error when loading bookmarks on line %1, column %2:\n"
222 "%3").arg(reader.lineNumber()).arg(reader.columnNumber()).arg(reader.errorString())); 215 "%3").arg(reader.lineNumber()).arg(reader.columnNumber()).arg(reader.errorString()));
223 } 216 }
224 217
225 importRootNode.setType(BookmarkNode::Folder); 218 importRootNode.setType(BookmarkNode.Folder);
226 importRootNode.title = (tr("Imported %1").arg(QDate::currentDate().toString(Qt.SystemLocaleShortDate))); 219 importRootNode.title = (tr("Imported %1").arg(QDate.currentDate().toString(Qt.SystemLocaleShortDate)));
227 addBookmark(menu(), importRootNode); 220 addBookmark(menu(), importRootNode);
228 } 221 }
229 222
230 223
231 void exportBookmarks() 224 void exportBookmarks()
232 { 225 {
233 QString fileName = QFileDialog::getSaveFileName(0, tr("Save File"), 226 QString fileName = QFileDialog.getSaveFileName(0, tr("Save File"),
234 tr("%1 Bookmarks.xbel").arg(QCoreApplication::applicationName()), 227 tr("%1 Bookmarks.xbel").arg(QCoreApplication.applicationName()),
235 tr("XBEL (*.xbel *.xml)")); 228 tr("XBEL (*.xbel *.xml)"));
236 if (fileName.isEmpty()) 229 if (fileName.isEmpty())
237 return; 230 return;
238 231
239 XbelWriter writer; 232 XbelWriter writer;
240 if (!writer.write(fileName, m_bookmarkRootNode)) 233 if (!writer.write(fileName, m_bookmarkRootNode))
241 QMessageBox::critical(0, tr("Export error"), tr("error saving bookmarks")); 234 QMessageBox.critical(0, tr("Export error"), tr("error saving bookmarks"));
242 } 235 }
243 236
244 private slots: 237 private slots:
245 void save() 238 void save()
246 { 239 {
247 if (!m_loaded) 240 if (!m_loaded)
248 return; 241 return;
249 242
250 XbelWriter writer; 243 XbelWriter writer;
251 QString dir = QDesktopServices::storageLocation(QDesktopServices::DataLocation); 244 QString dir = QDesktopServices.storageLocation(QDesktopServices.DataLocation);
252 QString bookmarkFile = dir + QLatin1String("/bookmarks.xbel"); 245 QString bookmarkFile = dir + QLatin1String("/bookmarks.xbel");
253 if (!writer.write(bookmarkFile, m_bookmarkRootNode)) 246 if (!writer.write(bookmarkFile, m_bookmarkRootNode))
254 qWarning() << "BookmarkManager: error saving to" << bookmarkFile; 247 qWarning() << "BookmarkManager: error saving to" << bookmarkFile;
255 } 248 }
256 249
259 { 252 {
260 if (m_loaded) 253 if (m_loaded)
261 return; 254 return;
262 m_loaded = true; 255 m_loaded = true;
263 256
264 QString dir = QDesktopServices::storageLocation(QDesktopServices::DataLocation); 257 QString dir = QDesktopServices.storageLocation(QDesktopServices.DataLocation);
265 QString bookmarkFile = dir + QLatin1String("/bookmarks.xbel"); 258 QString bookmarkFile = dir + QLatin1String("/bookmarks.xbel");
266 if (!QFile::exists(bookmarkFile)) 259 if (!QFile.exists(bookmarkFile))
267 bookmarkFile = QLatin1String(":defaultbookmarks.xbel"); 260 bookmarkFile = QLatin1String(":defaultbookmarks.xbel");
268 261
269 XbelReader reader; 262 XbelReader reader;
270 m_bookmarkRootNode = reader.read(bookmarkFile); 263 m_bookmarkRootNode = reader.read(bookmarkFile);
271 if (reader.error() != QXmlStreamReader::NoError) { 264 if (reader.error() != QXmlStreamReader.NoError) {
272 QMessageBox::warning(0, QLatin1String("Loading Bookmark"), 265 QMessageBox.warning(0, QLatin1String("Loading Bookmark"),
273 tr("Error when loading bookmarks on line %1, column %2:\n" 266 tr("Error when loading bookmarks on line %1, column %2:\n"
274 "%3").arg(reader.lineNumber()).arg(reader.columnNumber()).arg(reader.errorString())); 267 "%3").arg(reader.lineNumber()).arg(reader.columnNumber()).arg(reader.errorString()));
275 } 268 }
276 269
277 BookmarkNode *toolbar = null; 270 BookmarkNode toolbar = null;
278 BookmarkNode *menu = null; 271 BookmarkNode menu = null;
279 QList<BookmarkNode*> others; 272 QList<BookmarkNode> others;
280 for (int i = m_bookmarkRootNode.children().count() - 1; i >= 0; --i) { 273 for (int i = m_bookmarkRootNode.children().count() - 1; i >= 0; --i) {
281 BookmarkNode *node = m_bookmarkRootNode.children().at(i); 274 BookmarkNode node = m_bookmarkRootNode.children().at(i);
282 if (node.type() == BookmarkNode::Folder) { 275 if (node.type() == BookmarkNode.Folder) {
283 // Automatically convert 276 // Automatically convert
284 if (node.title == tr("Toolbar Bookmarks") && !toolbar) { 277 if (node.title == tr("Toolbar Bookmarks") && !toolbar) {
285 node.title = tr(BOOKMARKBAR); 278 node.title = tr(BOOKMARKBAR);
286 } 279 }
287 if (node.title == tr(BOOKMARKBAR) && !toolbar) { 280 if (node.title == tr(BOOKMARKBAR) && !toolbar) {
298 } else { 291 } else {
299 others.append(node); 292 others.append(node);
300 } 293 }
301 m_bookmarkRootNode.remove(node); 294 m_bookmarkRootNode.remove(node);
302 } 295 }
303 Q_ASSERT(m_bookmarkRootNode.children().count() == 0); 296 assert(m_bookmarkRootNode.children().count() == 0);
304 if (!toolbar) { 297 if (!toolbar) {
305 toolbar = new BookmarkNode(BookmarkNode::Folder, m_bookmarkRootNode); 298 toolbar = new BookmarkNode(BookmarkNode.Folder, m_bookmarkRootNode);
306 toolbar.title = tr(BOOKMARKBAR); 299 toolbar.title = tr(BOOKMARKBAR);
307 } else { 300 } else {
308 m_bookmarkRootNode.add(toolbar); 301 m_bookmarkRootNode.add(toolbar);
309 } 302 }
310 303
311 if (!menu) { 304 if (!menu) {
312 menu = new BookmarkNode(BookmarkNode::Folder, m_bookmarkRootNode); 305 menu = new BookmarkNode(BookmarkNode.Folder, m_bookmarkRootNode);
313 menu.title = tr(BOOKMARKMENU); 306 menu.title = tr(BOOKMARKMENU);
314 } else { 307 } else {
315 m_bookmarkRootNode.add(menu); 308 m_bookmarkRootNode.add(menu);
316 } 309 }
317 310
319 menu.add(others.at(i)); 312 menu.add(others.at(i));
320 } 313 }
321 314
322 315
323 bool m_loaded; 316 bool m_loaded;
324 AutoSaver *m_saveTimer; 317 AutoSaver m_saveTimer;
325 BookmarkNode *m_bookmarkRootNode; 318 BookmarkNode m_bookmarkRootNode;
326 BookmarksModel *m_bookmarkModel; 319 BookmarksModel m_bookmarkModel;
327 QUndoStack m_commands; 320 QUndoStack m_commands;
328 321
329 friend class RemoveBookmarksCommand; 322 friend class RemoveBookmarksCommand;
330 friend class ChangeBookmarkCommand; 323 friend class ChangeBookmarkCommand;
331 }; 324 }
332 325
333 class RemoveBookmarksCommand : public QUndoCommand 326 class RemoveBookmarksCommand : public QUndoCommand
334 { 327 {
335 328
336 public: 329 public:
337 this(BookmarksManager *m_bookmarkManagaer, BookmarkNode *parent, int row) 330 this(BookmarksManager m_bookmarkManagaer, BookmarkNode parent, int row)
338 { 331 {
339 super(BookmarksManager::tr("Remove Bookmark")) 332 super(BookmarksManager.tr("Remove Bookmark"))
340 m_row = row; 333 m_row = row;
341 m_bookmarkManagaer = m_bookmarkManagaer; 334 m_bookmarkManagaer = m_bookmarkManagaer;
342 m_node = parent.children().value(row); 335 m_node = parent.children().value(row);
343 m_parent = parent; 336 m_parent = parent;
344 m_done = false; 337 m_done = false;
365 m_done = true; 358 m_done = true;
366 } 359 }
367 360
368 protected: 361 protected:
369 int m_row; 362 int m_row;
370 BookmarksManager *m_bookmarkManagaer; 363 BookmarksManager m_bookmarkManagaer;
371 BookmarkNode *m_node; 364 BookmarkNode m_node;
372 BookmarkNode *m_parent; 365 BookmarkNode m_parent;
373 bool m_done; 366 bool m_done;
374 }; 367 };
375 368
376 class InsertBookmarksCommand : public RemoveBookmarksCommand 369 class InsertBookmarksCommand : public RemoveBookmarksCommand
377 { 370 {
378 371
379 public: 372 public:
380 this(BookmarksManager *m_bookmarkManagaer, 373 this(BookmarksManager m_bookmarkManagaer,
381 BookmarkNode *parent, BookmarkNode *node, int row) 374 BookmarkNode parent, BookmarkNode node, int row)
382 { 375 {
383 super(m_bookmarkManagaer, parent, row); 376 super(m_bookmarkManagaer, parent, row);
384 377
385 setText(BookmarksManager::tr("Insert Bookmark")); 378 setText(BookmarksManager.tr("Insert Bookmark"));
386 m_node = node; 379 m_node = node;
387 } 380 }
388 381
389 void undo() { RemoveBookmarksCommand::redo(); } 382 void undo() { RemoveBookmarksCommand.redo(); }
390 void redo() { RemoveBookmarksCommand::undo(); } 383 void redo() { RemoveBookmarksCommand.undo(); }
391 } 384 }
392 385
393 class ChangeBookmarkCommand : public QUndoCommand 386 class ChangeBookmarkCommand : public QUndoCommand
394 { 387 {
395 388
396 public: 389 public:
397 this(BookmarksManager *m_bookmarkManagaer, 390 this(BookmarksManager m_bookmarkManagaer,
398 BookmarkNode *node, QString &newValue, bool title) 391 BookmarkNode node, QString newValue, bool title)
399 { 392 {
400 super(); 393 super();
401 m_bookmarkManagaer = m_bookmarkManagaer; 394 m_bookmarkManagaer = m_bookmarkManagaer;
402 m_title = title; 395 m_title = title;
403 m_newValue = newValue; 396 m_newValue = newValue;
404 m_node = node; 397 m_node = node;
405 if (m_title) { 398 if (m_title) {
406 m_oldValue = m_node.title; 399 m_oldValue = m_node.title;
407 setText(BookmarksManager::tr("Name Change")); 400 setText(BookmarksManager.tr("Name Change"));
408 } else { 401 } else {
409 m_oldValue = m_node.url; 402 m_oldValue = m_node.url;
410 setText(BookmarksManager::tr("Address Change")); 403 setText(BookmarksManager.tr("Address Change"));
411 } 404 }
412 } 405 }
413 406
414 void undo() 407 void undo()
415 { 408 {
428 m_node.url = m_newValue; 421 m_node.url = m_newValue;
429 emit m_bookmarkManagaer.entryChanged(m_node); 422 emit m_bookmarkManagaer.entryChanged(m_node);
430 } 423 }
431 424
432 private: 425 private:
433 BookmarksManager *m_bookmarkManagaer; 426 BookmarksManager m_bookmarkManagaer;
434 bool m_title; 427 bool m_title;
435 QString m_oldValue; 428 QString m_oldValue;
436 QString m_newValue; 429 QString m_newValue;
437 BookmarkNode *m_node; 430 BookmarkNode m_node;
438 } 431 }
439 432
440 /*! 433 /*!
441 BookmarksModel is a QAbstractItemModel wrapper around the BookmarkManager 434 BookmarksModel is a QAbstractItemModel wrapper around the BookmarkManager
442 */ 435 */
443 import QtGui/QIcon; 436 import qt.gui.QIcon;
437
444 class BookmarksModel : public QAbstractItemModel 438 class BookmarksModel : public QAbstractItemModel
445 { 439 {
446 Q_OBJECT 440
447 441 public:
448 public slots: 442 void entryAdded(BookmarkNode item)
449 void entryAdded(BookmarkNode *item) 443 {
450 { 444 assert(item && item.parent());
451 Q_ASSERT(item && item.parent());
452 int row = item.parent().children().indexOf(item); 445 int row = item.parent().children().indexOf(item);
453 BookmarkNode *parent = item.parent(); 446 BookmarkNode parent = item.parent();
454 // item was already added so remove beore beginInsertRows is called 447 // item was already added so remove beore beginInsertRows is called
455 parent.remove(item); 448 parent.remove(item);
456 beginInsertRows(index(parent), row, row); 449 beginInsertRows(index(parent), row, row);
457 parent.add(item, row); 450 parent.add(item, row);
458 endInsertRows(); 451 endInsertRows();
459 } 452 }
460 453
461 454
462 void entryRemoved(BookmarkNode *parent, int row, BookmarkNode *item); 455 void entryRemoved(BookmarkNode parent, int row, BookmarkNode item);
463 { 456 {
464 // item was already removed, re-add so beginRemoveRows works 457 // item was already removed, re-add so beginRemoveRows works
465 parent.add(item, row); 458 parent.add(item, row);
466 beginRemoveRows(index(parent), row, row); 459 beginRemoveRows(index(parent), row, row);
467 parent.remove(item); 460 parent.remove(item);
468 endRemoveRows(); 461 endRemoveRows();
469 } 462 }
470 463
471 void entryChanged(BookmarkNode *item); 464 void entryChanged(BookmarkNode item);
472 { 465 {
473 QModelIndex idx = index(item); 466 QModelIndex idx = index(item);
474 emit dataChanged(idx, idx); 467 emit dataChanged(idx, idx);
475 } 468 }
476 public: 469 public:
477 enum Roles { 470 enum Roles {
478 TypeRole = Qt.UserRole + 1, 471 TypeRole = Qt.UserRole + 1,
479 UrlRole = Qt.UserRole + 2, 472 UrlRole = Qt.UserRole + 2,
480 UrlStringRole = Qt.UserRole + 3, 473 UrlStringRole = Qt.UserRole + 3,
481 SeparatorRole = Qt.UserRole + 4 474 SeparatorRole = Qt.UserRole + 4
482 }; 475 }
483 476
484 BookmarksModel(BookmarksManager *bookmarkManager, QObject *parent = null) 477 BookmarksModel(BookmarksManager bookmarkManager, QObject parent = null)
485 { 478 {
486 super(parent) 479 super(parent)
487 m_endMacro = false; 480 m_endMacro = false;
488 m_bookmarksManager = bookmarkManager; 481 m_bookmarksManager = bookmarkManager;
489 connect(bookmarkManager, SIGNAL(entryAdded(BookmarkNode *)), 482 bookmarkManager.entryAdded.connect(&this.entryAdded);
490 this, SLOT(entryAdded(BookmarkNode *))); 483 bookmarkManager.entryRemoved.connect(&this.entryRemoved);
491 connect(bookmarkManager, SIGNAL(entryRemoved(BookmarkNode *, int, BookmarkNode *)), 484 bookmarkManager.entryChanged.connect(&this.entryChanged);
492 this, SLOT(entryRemoved(BookmarkNode *, int, BookmarkNode *)));
493 connect(bookmarkManager, SIGNAL(entryChanged(BookmarkNode *)),
494 this, SLOT(entryChanged(BookmarkNode *)));
495 } 485 }
496 486
497 487
498 inline BookmarksManager *bookmarksManager() { return m_bookmarksManager; } 488 inline BookmarksManager bookmarksManager() { return m_bookmarksManager; }
499 489
500 QVariant headerData(int section, Qt.Orientation orientation, int role = Qt.DisplayRole); 490 QVariant headerData(int section, Qt.Orientation orientation, int role = Qt.DisplayRole);
501 { 491 {
502 if (orientation == Qt.Horizontal && role == Qt.DisplayRole) { 492 if (orientation == Qt.Horizontal && role == Qt.DisplayRole) {
503 switch (section) { 493 switch (section) {
504 case 0: return tr("Title"); 494 case 0: return tr("Title");
505 case 1: return tr("Address"); 495 case 1: return tr("Address");
506 } 496 }
507 } 497 }
508 return QAbstractItemModel::headerData(section, orientation, role); 498 return QAbstractItemModel.headerData(section, orientation, role);
509 } 499 }
510 500
511 501
512 QVariant data(QModelIndex &index, int role = Qt.DisplayRole) 502 QVariant data(QModelIndex index, int role = Qt.DisplayRole)
513 { 503 {
514 if (!index.isValid() || index.model() != this) 504 if (!index.isValid() || index.model() != this)
515 return QVariant(); 505 return QVariant();
516 506
517 BookmarkNode *bookmarkNode = node(index); 507 BookmarkNode bookmarkNode = node(index);
518 switch (role) { 508 switch (role) {
519 case Qt.EditRole: 509 case Qt.EditRole:
520 case Qt.DisplayRole: 510 case Qt.DisplayRole:
521 if (bookmarkNode.type() == BookmarkNode::Separator) { 511 if (bookmarkNode.type() == BookmarkNode.Separator) {
522 switch (index.column()) { 512 switch (index.column()) {
523 case 0: return QString(50, 0xB7); 513 case 0: return QString(50, 0xB7);
524 case 1: return QString(); 514 case 1: return QString();
525 } 515 }
526 } 516 }
528 switch (index.column()) { 518 switch (index.column()) {
529 case 0: return bookmarkNode.title; 519 case 0: return bookmarkNode.title;
530 case 1: return bookmarkNode.url; 520 case 1: return bookmarkNode.url;
531 } 521 }
532 break; 522 break;
533 case BookmarksModel::UrlRole: 523 case BookmarksModel.UrlRole:
534 return QUrl(bookmarkNode.url); 524 return QUrl(bookmarkNode.url);
535 break; 525 break;
536 case BookmarksModel::UrlStringRole: 526 case BookmarksModel.UrlStringRole:
537 return bookmarkNode.url; 527 return bookmarkNode.url;
538 break; 528 break;
539 case BookmarksModel::TypeRole: 529 case BookmarksModel.TypeRole:
540 return bookmarkNode.type(); 530 return bookmarkNode.type();
541 break; 531 break;
542 case BookmarksModel::SeparatorRole: 532 case BookmarksModel.SeparatorRole:
543 return (bookmarkNode.type() == BookmarkNode::Separator); 533 return (bookmarkNode.type() == BookmarkNode.Separator);
544 break; 534 break;
545 case Qt.DecorationRole: 535 case Qt.DecorationRole:
546 if (index.column() == 0) { 536 if (index.column() == 0) {
547 if (bookmarkNode.type() == BookmarkNode::Folder) 537 if (bookmarkNode.type() == BookmarkNode.Folder)
548 return QApplication::style().standardIcon(QStyle::SP_DirIcon); 538 return QApplication.style().standardIcon(QStyle.SP_DirIcon);
549 return BrowserApplication::instance().icon(bookmarkNode.url); 539 return BrowserApplication.instance().icon(bookmarkNode.url);
550 } 540 }
551 } 541 }
552 542
553 return QVariant(); 543 return QVariant();
554 } 544 }
555 545
556 int columnCount(QModelIndex &parent = QModelIndex()) 546 int columnCount(QModelIndex parent = QModelIndex())
557 { 547 {
558 return (parent.column() > 0) ? 0 : 2; 548 return (parent.column() > 0) ? 0 : 2;
559 } 549 }
560 550
561 int rowCount(QModelIndex &parent = QModelIndex()) 551 int rowCount(QModelIndex parent = QModelIndex())
562 { 552 {
563 if (parent.column() > 0) 553 if (parent.column() > 0)
564 return 0; 554 return 0;
565 555
566 if (!parent.isValid()) 556 if (!parent.isValid())
567 return m_bookmarksManager.bookmarks().children().count(); 557 return m_bookmarksManager.bookmarks().children().count();
568 558
569 const BookmarkNode *item = static_cast<BookmarkNode*>(parent.internalPointer()); 559 const BookmarkNode item = static_cast<BookmarkNode>(parent.internalPointer());
570 return item.children().count(); 560 return item.children().count();
571 } 561 }
572 562
573 QModelIndex index(int, int, QModelIndex& = QModelIndex()) 563 QModelIndex index(int, int, QModelIndex& = QModelIndex())
574 { 564 {
575 if (row < 0 || column < 0 || row >= rowCount(parent) || column >= columnCount(parent)) 565 if (row < 0 || column < 0 || row >= rowCount(parent) || column >= columnCount(parent))
576 return QModelIndex(); 566 return QModelIndex();
577 567
578 // get the parent node 568 // get the parent node
579 BookmarkNode *parentNode = node(parent); 569 BookmarkNode parentNode = node(parent);
580 return createIndex(row, column, parentNode.children().at(row)); 570 return createIndex(row, column, parentNode.children().at(row));
581 } 571 }
582 572
583 QModelIndex parent(QModelIndex& index= QModelIndex()) 573 QModelIndex parent(QModelIndex& index= QModelIndex())
584 { 574 {
585 if (!index.isValid()) 575 if (!index.isValid())
586 return QModelIndex(); 576 return QModelIndex();
587 577
588 BookmarkNode *itemNode = node(index); 578 BookmarkNode itemNode = node(index);
589 BookmarkNode *parentNode = (itemNode ? itemNode.parent() : 0); 579 BookmarkNode parentNode = (itemNode ? itemNode.parent() : 0);
590 if (!parentNode || parentNode == m_bookmarksManager.bookmarks()) 580 if (!parentNode || parentNode == m_bookmarksManager.bookmarks())
591 return QModelIndex(); 581 return QModelIndex();
592 582
593 // get the parent's row 583 // get the parent's row
594 BookmarkNode *grandParentNode = parentNode.parent(); 584 BookmarkNode grandParentNode = parentNode.parent();
595 int parentRow = grandParentNode.children().indexOf(parentNode); 585 int parentRow = grandParentNode.children().indexOf(parentNode);
596 Q_ASSERT(parentRow >= 0); 586 assert(parentRow >= 0);
597 return createIndex(parentRow, 0, parentNode); 587 return createIndex(parentRow, 0, parentNode);
598 } 588 }
599 589
600 590
601 Qt.ItemFlags flags(QModelIndex &index) 591 Qt.ItemFlags flags(QModelIndex index)
602 { 592 {
603 if (!index.isValid()) 593 if (!index.isValid())
604 return Qt.NoItemFlags; 594 return Qt.NoItemFlags;
605 595
606 Qt.ItemFlags flags = Qt.ItemIsSelectable | Qt.ItemIsEnabled; 596 Qt.ItemFlags flags = Qt.ItemIsSelectable | Qt.ItemIsEnabled;
607 597
608 BookmarkNode *bookmarkNode = node(index); 598 BookmarkNode bookmarkNode = node(index);
609 599
610 if (bookmarkNode != m_bookmarksManager.menu() 600 if (bookmarkNode != m_bookmarksManager.menu() && bookmarkNode != m_bookmarksManager.toolbar()) {
611 && bookmarkNode != m_bookmarksManager.toolbar()) {
612 flags |= Qt.ItemIsDragEnabled; 601 flags |= Qt.ItemIsDragEnabled;
613 if (bookmarkNode.type() != BookmarkNode::Separator) 602 if (bookmarkNode.type() != BookmarkNode.Separator)
614 flags |= Qt.ItemIsEditable; 603 flags |= Qt.ItemIsEditable;
615 } 604 }
616 if (hasChildren(index)) 605 if (hasChildren(index))
617 flags |= Qt.ItemIsDropEnabled; 606 flags |= Qt.ItemIsDropEnabled;
618 return flags; 607 return flags;
622 { 611 {
623 return Qt.CopyAction | Qt.MoveAction; 612 return Qt.CopyAction | Qt.MoveAction;
624 } 613 }
625 614
626 615
627 bool removeRows(int row, int count, QModelIndex &parent = QModelIndex()); 616 bool removeRows(int row, int count, QModelIndex parent = QModelIndex());
628 { 617 {
629 if (row < 0 || count <= 0 || row + count > rowCount(parent)) 618 if (row < 0 || count <= 0 || row + count > rowCount(parent))
630 return false; 619 return false;
631 620
632 BookmarkNode *bookmarkNode = node(parent); 621 BookmarkNode bookmarkNode = node(parent);
633 for (int i = row + count - 1; i >= row; --i) { 622 for (int i = row + count - 1; i >= row; --i) {
634 BookmarkNode *node = bookmarkNode.children().at(i); 623 BookmarkNode node = bookmarkNode.children().at(i);
635 if (node == m_bookmarksManager.menu() 624 if (node == m_bookmarksManager.menu()
636 || node == m_bookmarksManager.toolbar()) 625 || node == m_bookmarksManager.toolbar())
637 continue; 626 continue;
638 627
639 m_bookmarksManager.removeBookmark(node); 628 m_bookmarksManager.removeBookmark(node);
643 m_endMacro = false; 632 m_endMacro = false;
644 } 633 }
645 return true; 634 return true;
646 } 635 }
647 636
648 bool setData(QModelIndex &index, QVariant &value, int role = Qt.EditRole) 637 bool setData(QModelIndex index, QVariant value, int role = Qt.EditRole)
649 { 638 {
650 if (!index.isValid() || (flags(index) & Qt.ItemIsEditable) == 0) 639 if (!index.isValid() || (flags(index) & Qt.ItemIsEditable) == 0)
651 return false; 640 return false;
652 641
653 BookmarkNode *item = node(index); 642 BookmarkNode item = node(index);
654 643
655 switch (role) { 644 switch (role) {
656 case Qt.EditRole: 645 case Qt.EditRole:
657 case Qt.DisplayRole: 646 case Qt.DisplayRole:
658 if (index.column() == 0) { 647 if (index.column() == 0) {
662 if (index.column() == 1) { 651 if (index.column() == 1) {
663 m_bookmarksManager.setUrl(item, value.toString()); 652 m_bookmarksManager.setUrl(item, value.toString());
664 break; 653 break;
665 } 654 }
666 return false; 655 return false;
667 case BookmarksModel::UrlRole: 656 case BookmarksModel.UrlRole:
668 m_bookmarksManager.setUrl(item, value.toUrl().toString()); 657 m_bookmarksManager.setUrl(item, value.toUrl().toString());
669 break; 658 break;
670 case BookmarksModel::UrlStringRole: 659 case BookmarksModel.UrlStringRole:
671 m_bookmarksManager.setUrl(item, value.toString()); 660 m_bookmarksManager.setUrl(item, value.toString());
672 break; 661 break;
673 default: 662 default:
674 break; 663 break;
675 return false; 664 return false;
677 666
678 return true; 667 return true;
679 } 668 }
680 669
681 670
682 QMimeData *mimeData(QModelIndexList &indexes); 671 QMimeData mimeData(QModelIndexList indexes);
683 { 672 {
684 QMimeData *mimeData = new QMimeData(); 673 QMimeData mimeData = new QMimeData();
685 QByteArray data; 674 QByteArray data;
686 QDataStream stream(&data, QIODevice::WriteOnly); 675 QDataStream stream(&data, QIODevice.WriteOnly);
687 foreach (QModelIndex index, indexes) { 676 foreach (QModelIndex index, indexes) {
688 if (index.column() != 0 || !index.isValid()) 677 if (index.column() != 0 || !index.isValid())
689 continue; 678 continue;
690 QByteArray encodedData; 679 QByteArray encodedData;
691 QBuffer buffer(&encodedData); 680 QBuffer buffer(&encodedData);
692 buffer.open(QBuffer::ReadWrite); 681 buffer.open(QBuffer.ReadWrite);
693 XbelWriter writer; 682 XbelWriter writer;
694 const BookmarkNode *parentNode = node(index); 683 const BookmarkNode parentNode = node(index);
695 writer.write(&buffer, parentNode); 684 writer.write(&buffer, parentNode);
696 stream << encodedData; 685 stream << encodedData;
697 } 686 }
698 mimeData.setData(MIMETYPE, data); 687 mimeData.setData(MIMETYPE, data);
699 return mimeData; 688 return mimeData;
700 } 689 }
701 690
702 691
703 #define MIMETYPE QLatin1String("application/bookmarks.xbel") 692 const char[] MIMETYPE = QLatin1String("application/bookmarks.xbel")
704 693
705 QStringList mimeTypes() 694 QStringList mimeTypes()
706 { 695 {
707 QStringList types; 696 QStringList types;
708 types << MIMETYPE; 697 types << MIMETYPE;
709 return types; 698 return types;
710 } 699 }
711 700
712 bool dropMimeData(QMimeData *data, Qt.DropAction action, int row, int column, QModelIndex &parent) 701 bool dropMimeData(QMimeData data, Qt.DropAction action, int row, int column, QModelIndex parent)
713 { 702 {
714 if (action == Qt.IgnoreAction) 703 if (action == Qt.IgnoreAction)
715 return true; 704 return true;
716 705
717 if (!data.hasFormat(MIMETYPE) 706 if (!data.hasFormat(MIMETYPE) || column > 0)
718 || column > 0)
719 return false; 707 return false;
720 708
721 QByteArray ba = data.data(MIMETYPE); 709 QByteArray ba = data.data(MIMETYPE);
722 QDataStream stream(&ba, QIODevice::ReadOnly); 710 QDataStream stream(&ba, QIODevice.ReadOnly);
723 if (stream.atEnd()) 711 if (stream.atEnd())
724 return false; 712 return false;
725 713
726 QUndoStack *undoStack = m_bookmarksManager.undoRedoStack(); 714 QUndoStack undoStack = m_bookmarksManager.undoRedoStack();
727 undoStack.beginMacro(QLatin1String("Move Bookmarks")); 715 undoStack.beginMacro(QLatin1String("Move Bookmarks"));
728 716
729 while (!stream.atEnd()) { 717 while (!stream.atEnd()) {
730 QByteArray encodedData; 718 QByteArray encodedData;
731 stream >> encodedData; 719 stream >> encodedData;
732 QBuffer buffer(&encodedData); 720 QBuffer buffer(&encodedData);
733 buffer.open(QBuffer::ReadOnly); 721 buffer.open(QBuffer.ReadOnly);
734 722
735 XbelReader reader; 723 XbelReader reader;
736 BookmarkNode *rootNode = reader.read(&buffer); 724 BookmarkNode rootNode = reader.read(&buffer);
737 QList<BookmarkNode*> children = rootNode.children(); 725 QList<BookmarkNode> children = rootNode.children();
738 for (int i = 0; i < children.count(); ++i) { 726 for (int i = 0; i < children.count(); ++i) {
739 BookmarkNode *bookmarkNode = children.at(i); 727 BookmarkNode bookmarkNode = children.at(i);
740 rootNode.remove(bookmarkNode); 728 rootNode.remove(bookmarkNode);
741 row = qMax(0, row); 729 row = qMax(0, row);
742 BookmarkNode *parentNode = node(parent); 730 BookmarkNode parentNode = node(parent);
743 m_bookmarksManager.addBookmark(parentNode, bookmarkNode, row); 731 m_bookmarksManager.addBookmark(parentNode, bookmarkNode, row);
744 m_endMacro = true; 732 m_endMacro = true;
745 } 733 }
746 delete rootNode; 734 delete rootNode;
747 } 735 }
748 return true; 736 return true;
749 } 737 }
750 738
751 739
752 bool hasChildren(QModelIndex &parent = QModelIndex()) 740 bool hasChildren(QModelIndex parent = QModelIndex())
753 { 741 {
754 if (!parent.isValid()) 742 if (!parent.isValid())
755 return true; 743 return true;
756 const BookmarkNode *parentNode = node(parent); 744 const BookmarkNode parentNode = node(parent);
757 return (parentNode.type() == BookmarkNode::Folder); 745 return (parentNode.type() == BookmarkNode.Folder);
758 } 746 }
759 747
760 BookmarkNode *node(QModelIndex &index) 748 BookmarkNode node(QModelIndex index)
761 { 749 {
762 BookmarkNode *itemNode = static_cast<BookmarkNode*>(index.internalPointer()); 750 BookmarkNode itemNode = static_cast<BookmarkNode>(index.internalPointer());
763 if (!itemNode) 751 if (!itemNode)
764 return m_bookmarksManager.bookmarks(); 752 return m_bookmarksManager.bookmarks();
765 return itemNode; 753 return itemNode;
766 } 754 }
767 755
768 QModelIndex index(BookmarkNode *node) 756 QModelIndex index(BookmarkNode node)
769 { 757 {
770 BookmarkNode *parent = node.parent(); 758 BookmarkNode parent = node.parent();
771 if (!parent) 759 if (!parent)
772 return QModelIndex(); 760 return QModelIndex();
773 return createIndex(parent.children().indexOf(node), 0, node); 761 return createIndex(parent.children().indexOf(node), 0, node);
774 } 762 }
775 763
776 private: 764 private:
777 765
778 bool m_endMacro; 766 bool m_endMacro;
779 BookmarksManager *m_bookmarksManager; 767 BookmarksManager m_bookmarksManager;
780 } 768 }
781 769
782 // Menu that is dynamically populated from the bookmarks 770 // Menu that is dynamically populated from the bookmarks
783 import modelmenu; 771 import modelmenu;
784 class BookmarksMenu : public ModelMenu 772 class BookmarksMenu : public ModelMenu
785 { 773 {
786 Q_OBJECT 774 mixin Signal!("openUrl", QUrl url);
787
788 signals:
789 void openUrl(QUrl &url);
790 775
791 public: 776 public:
792 BookmarksMenu(QWidget *parent = null) 777 BookmarksMenu(QWidget parent = null)
793 { 778 {
794 super(parent); 779 super(parent);
795 m_bookmarksManager = 0; 780 m_bookmarksManager = 0;
796 connect(this, SIGNAL(activated(QModelIndex &)), 781 this.activated.connect(&this.activated);
797 this, SLOT(activated(QModelIndex &)));
798 setMaxRows(-1); 782 setMaxRows(-1);
799 setHoverRole(BookmarksModel::UrlStringRole); 783 setHoverRole(BookmarksModel.UrlStringRole);
800 setSeparatorRole(BookmarksModel::SeparatorRole); 784 setSeparatorRole(BookmarksModel.SeparatorRole);
801 } 785 }
802 void setInitialActions(QList<QAction*> actions); 786 void setInitialActions(QList<QAction> actions);
803 { 787 {
804 m_initialActions = actions; 788 m_initialActions = actions;
805 for (int i = 0; i < m_initialActions.count(); ++i) 789 for (int i = 0; i < m_initialActions.count(); ++i)
806 addAction(m_initialActions.at(i)); 790 addAction(m_initialActions.at(i));
807 } 791 }
808 protected: 792 protected:
809 bool prePopulated() 793 bool prePopulated()
810 { 794 {
811 m_bookmarksManager = BrowserApplication::bookmarksManager(); 795 m_bookmarksManager = BrowserApplication.bookmarksManager();
812 setModel(m_bookmarksManager.bookmarksModel()); 796 setModel(m_bookmarksManager.bookmarksModel());
813 setRootIndex(m_bookmarksManager.bookmarksModel().index(1, 0)); 797 setRootIndex(m_bookmarksManager.bookmarksModel().index(1, 0));
814 // initial actions 798 // initial actions
815 for (int i = 0; i < m_initialActions.count(); ++i) 799 for (int i = 0; i < m_initialActions.count(); ++i)
816 addAction(m_initialActions.at(i)); 800 addAction(m_initialActions.at(i));
819 createMenu(model().index(0, 0), 1, this); 803 createMenu(model().index(0, 0), 1, this);
820 return true; 804 return true;
821 } 805 }
822 806
823 private slots: 807 private slots:
824 void activated(QModelIndex &index) 808 void activated(QModelIndex index)
825 { 809 {
826 emit openUrl(index.data(BookmarksModel::UrlRole).toUrl()); 810 emit openUrl(index.data(BookmarksModel.UrlRole).toUrl());
827 } 811 }
828 812
829 private: 813 private:
830 BookmarksManager *m_bookmarksManager; 814 BookmarksManager m_bookmarksManager;
831 QList<QAction*> m_initialActions; 815 QList<QAction> m_initialActions;
832 } 816 }
833 817
834 /* 818 /*
835 Proxy model that filters out the bookmarks so only the folders 819 Proxy model that filters out the bookmarks so only the folders
836 are left behind. Used in the add bookmark dialog combobox. 820 are left behind. Used in the add bookmark dialog combobox.
837 */ 821 */
838 import QtGui/QSortFilterProxyModel; 822 import qt.gui.QSortFilterProxyModel;
823
839 class AddBookmarkProxyModel : public QSortFilterProxyModel 824 class AddBookmarkProxyModel : public QSortFilterProxyModel
840 { 825 {
841 Q_OBJECT 826 Q_OBJECT
842 public: 827 public:
843 this(QObject * parent = null) 828 this(QObject parent = null)
844 { 829 {
845 super(parent); 830 super(parent);
846 } 831 }
847 int columnCount(QModelIndex & parent = QModelIndex()) 832 int columnCount(QModelIndex parent = QModelIndex())
848 { 833 {
849 return qMin(1, QSortFilterProxyModel::columnCount(parent)); 834 return qMin(1, QSortFilterProxyModel.columnCount(parent));
850 } 835 }
851 protected: 836 protected:
852 bool filterAcceptsRow(int source_row, QModelIndex &source_parent) 837 bool filterAcceptsRow(int source_row, QModelIndex source_parent)
853 { 838 {
854 QModelIndex idx = sourceModel().index(source_row, 0, source_parent); 839 QModelIndex idx = sourceModel().index(source_row, 0, source_parent);
855 return sourceModel().hasChildren(idx); 840 return sourceModel().hasChildren(idx);
856 } 841 }
857 } 842 }
858 843
859 /*! 844 /*!
860 Add bookmark dialog 845 Add bookmark dialog
861 */ 846 */
847
862 import ui_addbookmarkdialog; 848 import ui_addbookmarkdialog;
849
863 class AddBookmarkDialog : public QDialog, public Ui_AddBookmarkDialog 850 class AddBookmarkDialog : public QDialog, public Ui_AddBookmarkDialog
864 { 851 {
865 Q_OBJECT
866 852
867 public: 853 public:
868 this(QString &url, QString &title, QWidget *parent = null, BookmarksManager *bookmarkManager = null) 854 this(QString url, QString title, QWidget parent = null, BookmarksManager bookmarkManager = null)
869 : QDialog(parent) 855 : QDialog(parent)
870
871 { 856 {
872 m_url = url; 857 m_url = url;
873 m_bookmarksManager = bookmarkManager; 858 m_bookmarksManager = bookmarkManager;
874 859
875 setWindowFlags(Qt.Sheet); 860 setWindowFlags(Qt.Sheet);
876 if (!m_bookmarksManager) 861 if (!m_bookmarksManager)
877 m_bookmarksManager = BrowserApplication::bookmarksManager(); 862 m_bookmarksManager = BrowserApplication.bookmarksManager();
878 setupUi(this); 863 setupUi(this);
879 QTreeView *view = new QTreeView(this); 864 QTreeView view = new QTreeView(this);
880 m_proxyModel = new AddBookmarkProxyModel(this); 865 m_proxyModel = new AddBookmarkProxyModel(this);
881 BookmarksModel *model = m_bookmarksManager.bookmarksModel(); 866 BookmarksModel model = m_bookmarksManager.bookmarksModel();
882 m_proxyModel.setSourceModel(model); 867 m_proxyModel.setSourceModel(model);
883 view.setModel(m_proxyModel); 868 view.setModel(m_proxyModel);
884 view.expandAll(); 869 view.expandAll();
885 view.header().setStretchLastSection(true); 870 view.header().setStretchLastSection(true);
886 view.header().hide(); 871 view.header().hide();
888 view.setRootIsDecorated(false); 873 view.setRootIsDecorated(false);
889 view.setIndentation(10); 874 view.setIndentation(10);
890 location.setModel(m_proxyModel); 875 location.setModel(m_proxyModel);
891 view.show(); 876 view.show();
892 location.setView(view); 877 location.setView(view);
893 BookmarkNode *menu = m_bookmarksManager.menu(); 878 BookmarkNode menu = m_bookmarksManager.menu();
894 QModelIndex idx = m_proxyModel.mapFromSource(model.index(menu)); 879 QModelIndex idx = m_proxyModel.mapFromSource(model.index(menu));
895 view.setCurrentIndex(idx); 880 view.setCurrentIndex(idx);
896 location.setCurrentIndex(idx.row()); 881 location.setCurrentIndex(idx.row());
897 name.setText(title); 882 name.setText(title);
898 } 883 }
899 private slots: 884
885 private:
900 886
901 void accept() 887 void accept()
902 { 888 {
903 QModelIndex index = location.view().currentIndex(); 889 QModelIndex index = location.view().currentIndex();
904 index = m_proxyModel.mapToSource(index); 890 index = m_proxyModel.mapToSource(index);
905 if (!index.isValid()) 891 if (!index.isValid())
906 index = m_bookmarksManager.bookmarksModel().index(0, 0); 892 index = m_bookmarksManager.bookmarksModel().index(0, 0);
907 BookmarkNode *parent = m_bookmarksManager.bookmarksModel().node(index); 893 BookmarkNode parent = m_bookmarksManager.bookmarksModel().node(index);
908 BookmarkNode *bookmark = new BookmarkNode(BookmarkNode::Bookmark); 894 BookmarkNode bookmark = new BookmarkNode(BookmarkNode.Bookmark);
909 bookmark.url = m_url; 895 bookmark.url = m_url;
910 bookmark.title = name.text(); 896 bookmark.title = name.text();
911 m_bookmarksManager.addBookmark(parent, bookmark); 897 m_bookmarksManager.addBookmark(parent, bookmark);
912 QDialog::accept(); 898 QDialog.accept();
913 } 899 }
914 900
915 private: 901 private:
916 QString m_url; 902 QString m_url;
917 BookmarksManager *m_bookmarksManager; 903 BookmarksManager m_bookmarksManager;
918 AddBookmarkProxyModel *m_proxyModel; 904 AddBookmarkProxyModel m_proxyModel;
919 } 905 }
920 906
921 import ui_bookmarks; 907 import ui_bookmarks;
922 908
923 //class TreeProxyModel; 909 //class TreeProxyModel;
924 class BookmarksDialog : public QDialog, public Ui_BookmarksDialog 910 class BookmarksDialog : public QDialog, public Ui_BookmarksDialog
925 { 911 {
926 Q_OBJECT 912
927 913 mixin Signal!("openUrl", QUrl url);
928 signals:
929 void openUrl(QUrl &url);
930 914
931 public: 915 public:
932 this(QWidget *parent = null, BookmarksManager *manager = null) 916 this(QWidget parent = null, BookmarksManager manager = null)
933 : QDialog(parent) 917 : QDialog(parent)
934 { 918 {
935 m_bookmarksManager = manager; 919 m_bookmarksManager = manager;
936 if (!m_bookmarksManager) 920 if (!m_bookmarksManager)
937 m_bookmarksManager = BrowserApplication::bookmarksManager(); 921 m_bookmarksManager = BrowserApplication.bookmarksManager();
938 setupUi(this); 922 setupUi(this);
939 923
940 tree.setUniformRowHeights(true); 924 tree.setUniformRowHeights(true);
941 tree.setSelectionBehavior(QAbstractItemView::SelectRows); 925 tree.setSelectionBehavior(QAbstractItemView.SelectRows);
942 tree.setSelectionMode(QAbstractItemView::ContiguousSelection); 926 tree.setSelectionMode(QAbstractItemView.ContiguousSelection);
943 tree.setTextElideMode(Qt.ElideMiddle); 927 tree.setTextElideMode(Qt.ElideMiddle);
944 m_bookmarksModel = m_bookmarksManager.bookmarksModel(); 928 m_bookmarksModel = m_bookmarksManager.bookmarksModel();
945 m_proxyModel = new TreeProxyModel(this); 929 m_proxyModel = new TreeProxyModel(this);
946 connect(search, SIGNAL(textChanged(QString)), 930 search.textChanged.connect(&m_proxyModel.setFilterFixedString);
947 m_proxyModel, SLOT(setFilterFixedString(QString))); 931 removeButton.clicked.connect(&tree.removeOne);
948 connect(removeButton, SIGNAL(clicked()), tree, SLOT(removeOne()));
949 m_proxyModel.setSourceModel(m_bookmarksModel); 932 m_proxyModel.setSourceModel(m_bookmarksModel);
950 tree.setModel(m_proxyModel); 933 tree.setModel(m_proxyModel);
951 tree.setDragDropMode(QAbstractItemView::InternalMove); 934 tree.setDragDropMode(QAbstractItemView.InternalMove);
952 tree.setExpanded(m_proxyModel.index(0, 0), true); 935 tree.setExpanded(m_proxyModel.index(0, 0), true);
953 tree.setAlternatingRowColors(true); 936 tree.setAlternatingRowColors(true);
954 QFontMetrics fm(font()); 937 auto fm = new QFontMetrics(font());
955 int header = fm.width(QLatin1Char('m')) * 40; 938 int header = fm.width(QLatin1Char('m')) * 40;
956 tree.header().resizeSection(0, header); 939 tree.header().resizeSection(0, header);
957 tree.header().setStretchLastSection(true); 940 tree.header().setStretchLastSection(true);
958 connect(tree, SIGNAL(activated(QModelIndex&)), 941 tree.activated.connect(&this.open);
959 this, SLOT(open()));
960 tree.setContextMenuPolicy(Qt.CustomContextMenu); 942 tree.setContextMenuPolicy(Qt.CustomContextMenu);
961 connect(tree, SIGNAL(customContextMenuRequested(QPoint &)), 943 tree.customContextMenuRequested.connect(&this.customContextMenuRequested);
962 this, SLOT(customContextMenuRequested(QPoint &))); 944 addFolderButton.clicked.connect(&this.newFolder);
963 connect(addFolderButton, SIGNAL(clicked()),
964 this, SLOT(newFolder()));
965 expandNodes(m_bookmarksManager.bookmarks()); 945 expandNodes(m_bookmarksManager.bookmarks());
966 setAttribute(Qt.WA_DeleteOnClose); 946 setAttribute(Qt.WA_DeleteOnClose);
967 } 947 }
968 ~this() 948 ~this()
969 { 949 {
970 if (saveExpandedNodes(tree.rootIndex())) 950 if (saveExpandedNodes(tree.rootIndex()))
971 m_bookmarksManager.changeExpanded(); 951 m_bookmarksManager.changeExpanded();
972 } 952 }
973 953
974 private slots: 954 private slots:
975 void customContextMenuRequested(QPoint &pos) 955 void customContextMenuRequested(QPoint pos)
976 { 956 {
977 QMenu menu; 957 QMenu menu;
978 QModelIndex index = tree.indexAt(pos); 958 QModelIndex index = tree.indexAt(pos);
979 index = index.sibling(index.row(), 0); 959 index = index.sibling(index.row(), 0);
980 if (index.isValid() && !tree.model().hasChildren(index)) { 960 if (index.isValid() && !tree.model().hasChildren(index)) {
981 menu.addAction(tr("Open"), this, SLOT(open())); 961 menu.addAction(tr("Open"), this, SLOT(open()));
982 menu.addSeparator(); 962 menu.addSeparator();
983 } 963 }
984 menu.addAction(tr("Delete"), tree, SLOT(removeOne())); 964 menu.addAction(tr("Delete"), tree, SLOT(removeOne()));
985 menu.exec(QCursor::pos()); 965 menu.exec(QCursor.pos());
986 } 966 }
987 void open() 967 void open()
988 { 968 {
989 QModelIndex index = tree.currentIndex(); 969 QModelIndex index = tree.currentIndex();
990 if (!index.parent().isValid()) 970 if (!index.parent().isValid())
991 return; 971 return;
992 emit openUrl(index.sibling(index.row(), 1).data(BookmarksModel::UrlRole).toUrl()); 972 emit openUrl(index.sibling(index.row(), 1).data(BookmarksModel.UrlRole).toUrl());
993 } 973 }
994 974
995 void newFolder() 975 void newFolder()
996 { 976 {
997 QModelIndex currentIndex = tree.currentIndex(); 977 QModelIndex currentIndex = tree.currentIndex();
999 if (idx.isValid() && !idx.model().hasChildren(idx)) 979 if (idx.isValid() && !idx.model().hasChildren(idx))
1000 idx = idx.parent(); 980 idx = idx.parent();
1001 if (!idx.isValid()) 981 if (!idx.isValid())
1002 idx = tree.rootIndex(); 982 idx = tree.rootIndex();
1003 idx = m_proxyModel.mapToSource(idx); 983 idx = m_proxyModel.mapToSource(idx);
1004 BookmarkNode *parent = m_bookmarksManager.bookmarksModel().node(idx); 984 BookmarkNode parent = m_bookmarksManager.bookmarksModel().node(idx);
1005 BookmarkNode *node = new BookmarkNode(BookmarkNode::Folder); 985 BookmarkNode node = new BookmarkNode(BookmarkNode.Folder);
1006 node.title = tr("New Folder"); 986 node.title = tr("New Folder");
1007 m_bookmarksManager.addBookmark(parent, node, currentIndex.row() + 1); 987 m_bookmarksManager.addBookmark(parent, node, currentIndex.row() + 1);
1008 } 988 }
1009 989
1010 private: 990 private:
1011 void expandNodes(BookmarkNode *node) 991 void expandNodes(BookmarkNode node)
1012 { 992 {
1013 for (int i = 0; i < node.children().count(); ++i) { 993 for (int i = 0; i < node.children().count(); ++i) {
1014 BookmarkNode *childNode = node.children()[i]; 994 BookmarkNode childNode = node.children()[i];
1015 if (childNode.expanded) { 995 if (childNode.expanded) {
1016 QModelIndex idx = m_bookmarksModel.index(childNode); 996 QModelIndex idx = m_bookmarksModel.index(childNode);
1017 idx = m_proxyModel.mapFromSource(idx); 997 idx = m_proxyModel.mapFromSource(idx);
1018 tree.setExpanded(idx, true); 998 tree.setExpanded(idx, true);
1019 expandNodes(childNode); 999 expandNodes(childNode);
1020 } 1000 }
1021 } 1001 }
1022 } 1002 }
1023 1003
1024 bool saveExpandedNodes(QModelIndex &parent) 1004 bool saveExpandedNodes(QModelIndex parent)
1025 { 1005 {
1026 bool changed = false; 1006 bool changed = false;
1027 for (int i = 0; i < m_proxyModel.rowCount(parent); ++i) { 1007 for (int i = 0; i < m_proxyModel.rowCount(parent); ++i) {
1028 QModelIndex child = m_proxyModel.index(i, 0, parent); 1008 QModelIndex child = m_proxyModel.index(i, 0, parent);
1029 QModelIndex sourceIndex = m_proxyModel.mapToSource(child); 1009 QModelIndex sourceIndex = m_proxyModel.mapToSource(child);
1030 BookmarkNode *childNode = m_bookmarksModel.node(sourceIndex); 1010 BookmarkNode childNode = m_bookmarksModel.node(sourceIndex);
1031 bool wasExpanded = childNode.expanded; 1011 bool wasExpanded = childNode.expanded;
1032 if (tree.isExpanded(child)) { 1012 if (tree.isExpanded(child)) {
1033 childNode.expanded = true; 1013 childNode.expanded = true;
1034 changed |= saveExpandedNodes(child); 1014 changed |= saveExpandedNodes(child);
1035 } else { 1015 } else {
1038 changed |= (wasExpanded != childNode.expanded); 1018 changed |= (wasExpanded != childNode.expanded);
1039 } 1019 }
1040 return changed; 1020 return changed;
1041 } 1021 }
1042 1022
1043 BookmarksManager *m_bookmarksManager; 1023 BookmarksManager m_bookmarksManager;
1044 BookmarksModel *m_bookmarksModel; 1024 BookmarksModel m_bookmarksModel;
1045 TreeProxyModel *m_proxyModel; 1025 TreeProxyModel m_proxyModel;
1046 }; 1026 }
1047 1027
1048 import QtGui/QToolBar; 1028 import qt.gui.QToolBar;
1029
1049 class BookmarksToolBar : public QToolBar 1030 class BookmarksToolBar : public QToolBar
1050 { 1031 {
1051 Q_OBJECT 1032 mixin Signal!("openUrl", QUrl url);
1052
1053 signals:
1054 void openUrl(QUrl &url);
1055 1033
1056 public: 1034 public:
1057 BookmarksToolBar(BookmarksModel *model, QWidget *parent = null) 1035 BookmarksToolBar(BookmarksModel model, QWidget parent = null)
1058 { 1036 {
1059 super(tr("Bookmark"), parent); 1037 super(tr("Bookmark"), parent);
1060 m_bookmarksModel = model; 1038 m_bookmarksModel = model;
1061 connect(this, SIGNAL(actionTriggered(QAction*)), this, SLOT(triggered(QAction*))); 1039 this.actionTriggered.connect(&this.triggered);
1062 setRootIndex(model.index(0, 0)); 1040 setRootIndex(model.index(0, 0));
1063 connect(m_bookmarksModel, SIGNAL(modelReset()), this, SLOT(build())); 1041 m_bookmarksModel.modelReset.connect(&this.build);
1064 connect(m_bookmarksModel, SIGNAL(rowsInserted(QModelIndex &, int, int)), this, SLOT(build())); 1042 m_bookmarksModel.rowsInserted.connect(&this.build);
1065 connect(m_bookmarksModel, SIGNAL(rowsRemoved(QModelIndex &, int, int)), this, SLOT(build())); 1043 m_bookmarksModel.rowsRemoved.connect(&this.build);
1066 connect(m_bookmarksModel, SIGNAL(dataChanged(QModelIndex &, QModelIndex &)), this, SLOT(build())); 1044 m_bookmarksModel.dataChanged.connect(&this.build);
1067 setAcceptDrops(true); 1045 setAcceptDrops(true);
1068 } 1046 }
1069 1047
1070 void setRootIndex(QModelIndex &index); 1048 void setRootIndex(QModelIndex index);
1071 { 1049 {
1072 m_root = index; 1050 m_root = index;
1073 build(); 1051 build();
1074 } 1052 }
1075 1053
1077 { 1055 {
1078 return m_root; 1056 return m_root;
1079 } 1057 }
1080 1058
1081 protected: 1059 protected:
1082 void dragEnterEvent(QDragEnterEvent *event) 1060 void dragEnterEvent(QDragEnterEvent event)
1083 { 1061 {
1084 const QMimeData *mimeData = event.mimeData(); 1062 const QMimeData mimeData = event.mimeData();
1085 if (mimeData.hasUrls()) 1063 if (mimeData.hasUrls())
1086 event.acceptProposedAction(); 1064 event.acceptProposedAction();
1087 QToolBar::dragEnterEvent(event); 1065 QToolBar.dragEnterEvent(event);
1088 } 1066 }
1089 1067
1090 void dropEvent(QDropEvent *event) 1068 void dropEvent(QDropEvent event)
1091 { 1069 {
1092 const QMimeData *mimeData = event.mimeData(); 1070 const QMimeData mimeData = event.mimeData();
1093 if (mimeData.hasUrls() && mimeData.hasText()) { 1071 if (mimeData.hasUrls() && mimeData.hasText()) {
1094 QList<QUrl> urls = mimeData.urls(); 1072 QList<QUrl> urls = mimeData.urls();
1095 QAction *action = actionAt(event.pos()); 1073 QAction action = actionAt(event.pos());
1096 QString dropText; 1074 QString dropText;
1097 if (action) 1075 if (action)
1098 dropText = action.text(); 1076 dropText = action.text();
1099 int row = -1; 1077 int row = -1;
1100 QModelIndex parentIndex = m_root; 1078 QModelIndex parentIndex = m_root;
1108 row = -1; 1086 row = -1;
1109 } 1087 }
1110 break; 1088 break;
1111 } 1089 }
1112 } 1090 }
1113 BookmarkNode *bookmark = new BookmarkNode(BookmarkNode::Bookmark); 1091 BookmarkNode bookmark = new BookmarkNode(BookmarkNode.Bookmark);
1114 bookmark.url = urls.at(0).toString(); 1092 bookmark.url = urls.at(0).toString();
1115 bookmark.title = mimeData.text(); 1093 bookmark.title = mimeData.text();
1116 1094
1117 BookmarkNode *parent = m_bookmarksModel.node(parentIndex); 1095 BookmarkNode parent = m_bookmarksModel.node(parentIndex);
1118 BookmarksManager *bookmarksManager = m_bookmarksModel.bookmarksManager(); 1096 BookmarksManager bookmarksManager = m_bookmarksModel.bookmarksManager();
1119 bookmarksManager.addBookmark(parent, bookmark, row); 1097 bookmarksManager.addBookmark(parent, bookmark, row);
1120 event.acceptProposedAction(); 1098 event.acceptProposedAction();
1121 } 1099 }
1122 QToolBar::dropEvent(event); 1100 QToolBar.dropEvent(event);
1123 } 1101 }
1124 1102
1125 private slots: 1103 private slots:
1126 void triggered(QAction *action) 1104 void triggered(QAction action)
1127 { 1105 {
1128 QVariant v = action.data(); 1106 QVariant v = action.data();
1129 if (v.canConvert<QUrl>()) { 1107 if (v.canConvert<QUrl>()) {
1130 emit openUrl(v.toUrl()); 1108 emit openUrl(v.toUrl());
1131 } 1109 }
1132 } 1110 }
1133 1111
1134 void activated(QModelIndex &index) 1112 void activated(QModelIndex index)
1135 { 1113 {
1136 emit openUrl(index.data(BookmarksModel::UrlRole).toUrl()); 1114 emit openUrl(index.data(BookmarksModel.UrlRole).toUrl());
1137 } 1115 }
1138 1116
1139 1117
1140 void build() 1118 void build()
1141 { 1119 {
1142 clear(); 1120 clear();
1143 for (int i = 0; i < m_bookmarksModel.rowCount(m_root); ++i) { 1121 for (int i = 0; i < m_bookmarksModel.rowCount(m_root); ++i) {
1144 QModelIndex idx = m_bookmarksModel.index(i, 0, m_root); 1122 QModelIndex idx = m_bookmarksModel.index(i, 0, m_root);
1145 if (m_bookmarksModel.hasChildren(idx)) { 1123 if (m_bookmarksModel.hasChildren(idx)) {
1146 QToolButton *button = new QToolButton(this); 1124 QToolButton button = new QToolButton(this);
1147 button.setPopupMode(QToolButton::InstantPopup); 1125 button.setPopupMode(QToolButton.InstantPopup);
1148 button.setArrowType(Qt.DownArrow); 1126 button.setArrowType(Qt.DownArrow);
1149 button.setText(idx.data().toString()); 1127 button.setText(idx.data().toString());
1150 ModelMenu *menu = new ModelMenu(this); 1128 ModelMenu menu = new ModelMenu(this);
1151 connect(menu, SIGNAL(activated(QModelIndex &)), 1129 menu.activated.connect(&this.activated);
1152 this, SLOT(activated(QModelIndex &)));
1153 menu.setModel(m_bookmarksModel); 1130 menu.setModel(m_bookmarksModel);
1154 menu.setRootIndex(idx); 1131 menu.setRootIndex(idx);
1155 menu.addAction(new QAction(menu)); 1132 menu.addAction(new QAction(menu));
1156 button.setMenu(menu); 1133 button.setMenu(menu);
1157 button.setToolButtonStyle(Qt.ToolButtonTextOnly); 1134 button.setToolButtonStyle(Qt.ToolButtonTextOnly);
1158 QAction *a = addWidget(button); 1135 QAction a = addWidget(button);
1159 a.setText(idx.data().toString()); 1136 a.setText(idx.data().toString());
1160 } else { 1137 } else {
1161 QAction *action = addAction(idx.data().toString()); 1138 QAction action = addAction(idx.data().toString());
1162 action.setData(idx.data(BookmarksModel::UrlRole)); 1139 action.setData(idx.data(BookmarksModel.UrlRole));
1163 } 1140 }
1164 } 1141 }
1165 } 1142 }
1166 1143
1167 private: 1144 private:
1168 BookmarksModel *m_bookmarksModel; 1145 BookmarksModel m_bookmarksModel;
1169 QPersistentModelIndex m_root; 1146 QPersistentModelIndex m_root;
1170 } 1147 }