193 	def __init__(self, task, param=None, parent=None):  argument
194 		super(Thread, self).__init__(parent)
195 		self.task = task
196 		self.param = param
198 	def run(self):  argument
200 			if self.param is None:
201 				done, result = self.task()
203 				done, result = self.task(self.param)
204 			self.done.emit(result)
212 	def __init__(self, glb, params, parent=None):  argument
213 		super(TreeModel, self).__init__(parent)
214 		self.glb = glb
215 		self.params = params
216 		self.root = self.GetRoot()
217 		self.last_row_read = 0
219 	def Item(self, parent):  argument
223 			return self.root
225 	def rowCount(self, parent):  argument
226 		result = self.Item(parent).childCount()
229 			self.dataChanged.emit(parent, parent)
232 	def hasChildren(self, parent):  argument
233 		return self.Item(parent).hasChildren()
235 	def headerData(self, section, orientation, role):  argument
237 			return self.columnAlignment(section)
242 		return self.columnHeader(section)
244 	def parent(self, child):  argument
246 		if child_item is self.root:
249 		return self.createIndex(parent_item.getRow(), 0, parent_item)
251 	def index(self, row, column, parent):  argument
252 		child_item = self.Item(parent).getChildItem(row)
253 		return self.createIndex(row, column, child_item)
255 	def DisplayData(self, item, index):  argument
258 	def FetchIfNeeded(self, row):  argument
259 		if row > self.last_row_read:
260 			self.last_row_read = row
261 			if row + 10 >= self.root.child_count:
262 				self.fetcher.Fetch(glb_chunk_sz)
264 	def columnAlignment(self, column):  argument
267 	def columnFont(self, column):  argument
270 	def data(self, index, role):  argument
272 			return self.columnAlignment(index.column())
274 			return self.columnFont(index.column())
278 		return self.DisplayData(item, index)
284 	def __init__(self, parent=None):  argument
285 		super(TableModel, self).__init__(parent)
286 		self.child_count = 0
287 		self.child_items = []
288 		self.last_row_read = 0
290 	def Item(self, parent):  argument
294 			return self
296 	def rowCount(self, parent):  argument
297 		return self.child_count
299 	def headerData(self, section, orientation, role):  argument
301 			return self.columnAlignment(section)
306 		return self.columnHeader(section)
308 	def index(self, row, column, parent):  argument
309 		return self.createIndex(row, column, self.child_items[row])
311 	def DisplayData(self, item, index):  argument
314 	def FetchIfNeeded(self, row):  argument
315 		if row > self.last_row_read:
316 			self.last_row_read = row
317 			if row + 10 >= self.child_count:
318 				self.fetcher.Fetch(glb_chunk_sz)
320 	def columnAlignment(self, column):  argument
323 	def columnFont(self, column):  argument
326 	def data(self, index, role):  argument
328 			return self.columnAlignment(index.column())
330 			return self.columnFont(index.column())
334 		return self.DisplayData(item, index)
366 	def __init__(self, parent, finder, is_reg_expr=False):  argument
367 		self.finder = finder
368 		self.context = []
369 		self.last_value = None
370 		self.last_pattern = None
375 		self.textbox = QComboBox()
376 		self.textbox.setEditable(True)
377 		self.textbox.currentIndexChanged.connect(self.ValueChanged)
379 		self.progress = QProgressBar()
380 		self.progress.setRange(0, 0)
381 		self.progress.hide()
384 			self.pattern = QCheckBox("Regular Expression")
386 			self.pattern = QCheckBox("Pattern")
387 		self.pattern.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
389 		self.next_button = QToolButton()
390 		self.next_button.setIcon(parent.style().standardIcon(QStyle.SP_ArrowDown))
391 		self.next_button.released.connect(lambda: self.NextPrev(1))
393 		self.prev_button = QToolButton()
394 		self.prev_button.setIcon(parent.style().standardIcon(QStyle.SP_ArrowUp))
395 		self.prev_button.released.connect(lambda: self.NextPrev(-1))
397 		self.close_button = QToolButton()
398 		self.close_button.setIcon(parent.style().standardIcon(QStyle.SP_DockWidgetCloseButton))
399 		self.close_button.released.connect(self.Deactivate)
401 		self.hbox = QHBoxLayout()
402 		self.hbox.setContentsMargins(0, 0, 0, 0)
404 		self.hbox.addWidget(label)
405 		self.hbox.addWidget(self.textbox)
406 		self.hbox.addWidget(self.progress)
407 		self.hbox.addWidget(self.pattern)
408 		self.hbox.addWidget(self.next_button)
409 		self.hbox.addWidget(self.prev_button)
410 		self.hbox.addWidget(self.close_button)
412 		self.bar = QWidget()
413 		self.bar.setLayout(self.hbox)
414 		self.bar.hide()
416 	def Widget(self):  argument
417 		return self.bar
419 	def Activate(self):  argument
420 		self.bar.show()
421 		self.textbox.lineEdit().selectAll()
422 		self.textbox.setFocus()
424 	def Deactivate(self):  argument
425 		self.bar.hide()
427 	def Busy(self):  argument
428 		self.textbox.setEnabled(False)
429 		self.pattern.hide()
430 		self.next_button.hide()
431 		self.prev_button.hide()
432 		self.progress.show()
434 	def Idle(self):  argument
435 		self.textbox.setEnabled(True)
436 		self.progress.hide()
437 		self.pattern.show()
438 		self.next_button.show()
439 		self.prev_button.show()
441 	def Find(self, direction):  argument
442 		value = self.textbox.currentText()
443 		pattern = self.pattern.isChecked()
444 		self.last_value = value
445 		self.last_pattern = pattern
446 		self.finder.Find(value, direction, pattern, self.context)
448 	def ValueChanged(self):  argument
449 		value = self.textbox.currentText()
450 		pattern = self.pattern.isChecked()
451 		index = self.textbox.currentIndex()
452 		data = self.textbox.itemData(index)
455 			self.textbox.setItemData(index, pattern)
457 			self.pattern.setChecked(data)
458 		self.Find(0)
460 	def NextPrev(self, direction):  argument
461 		value = self.textbox.currentText()
462 		pattern = self.pattern.isChecked()
463 		if value != self.last_value:
464 			index = self.textbox.findText(value)
467 				index = self.textbox.count()
468 				self.textbox.addItem(value, pattern)
469 				self.textbox.setCurrentIndex(index)
472 				self.textbox.setItemData(index, pattern)
473 		elif pattern != self.last_pattern:
475 			index = self.textbox.currentIndex()
476 			self.textbox.setItemData(index, pattern)
477 		self.Find(direction)
479 	def NotFound(self):  argument
480 		QMessageBox.information(self.bar, "Find", "'" + self.textbox.currentText() + "' not found")
486 	def __init__(self, glb, params, row, parent_item):  argument
487 		self.glb = glb
488 		self.params = params
489 		self.row = row
490 		self.parent_item = parent_item
491 		self.query_done = False
492 		self.child_count = 0
493 		self.child_items = []
495 			self.level = parent_item.level + 1
497 			self.level = 0
499 	def getChildItem(self, row):  argument
500 		return self.child_items[row]
502 	def getParentItem(self):  argument
503 		return self.parent_item
505 	def getRow(self):  argument
506 		return self.row
508 	def childCount(self):  argument
509 		if not self.query_done:
510 			self.Select()
511 			if not self.child_count:
513 		return self.child_count
515 	def hasChildren(self):  argument
516 		if not self.query_done:
518 		return self.child_count > 0
520 	def getData(self, column):  argument
521 		return self.data[column]
527 …def __init__(self, glb, params, row, comm_id, thread_id, call_path_id, time, insn_cnt, cyc_cnt, br…  argument
528 		super(CallGraphLevelTwoPlusItemBase, self).__init__(glb, params, row, parent_item)
529 		self.comm_id = comm_id
530 		self.thread_id = thread_id
531 		self.call_path_id = call_path_id
532 		self.insn_cnt = insn_cnt
533 		self.cyc_cnt = cyc_cnt
534 		self.branch_count = branch_count
535 		self.time = time
537 	def Select(self):  argument
538 		self.query_done = True
539 		query = QSqlQuery(self.glb.db)
540 		if self.params.have_ipc:
549 					" WHERE parent_call_path_id = " + str(self.call_path_id) +
550 					" AND comm_id = " + str(self.comm_id) +
551 					" AND thread_id = " + str(self.thread_id) +
555 			if self.params.have_ipc:
563 …self.glb, self.params, self.child_count, self.comm_id, self.thread_id, query.value(0), query.value…
564 			self.child_items.append(child_item)
565 			self.child_count += 1
571 …def __init__(self, glb, params, row, comm_id, thread_id, call_path_id, name, dso, count, time, ins…  argument
572 …super(CallGraphLevelThreeItem, self).__init__(glb, params, row, comm_id, thread_id, call_path_id, …
574 		if self.params.have_ipc:
579 …self.data = [ name, dso, str(count), str(time), PercentToOneDP(time, parent_item.time), str(insn_c…
581 …self.data = [ name, dso, str(count), str(time), PercentToOneDP(time, parent_item.time), str(branch…
582 		self.dbid = call_path_id
588 	def __init__(self, glb, params, row, comm_id, thread_id, pid, tid, parent_item):  argument
589 …super(CallGraphLevelTwoItem, self).__init__(glb, params, row, comm_id, thread_id, 1, 0, 0, 0, 0, p…
590 		if self.params.have_ipc:
591 			self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", "", "", "", "", "", ""]
593 			self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", ""]
594 		self.dbid = thread_id
596 	def Select(self):  argument
597 		super(CallGraphLevelTwoItem, self).Select()
598 		for child_item in self.child_items:
599 			self.time += child_item.time
600 			self.insn_cnt += child_item.insn_cnt
601 			self.cyc_cnt += child_item.cyc_cnt
602 			self.branch_count += child_item.branch_count
603 		for child_item in self.child_items:
604 			child_item.data[4] = PercentToOneDP(child_item.time, self.time)
605 			if self.params.have_ipc:
606 				child_item.data[6] = PercentToOneDP(child_item.insn_cnt, self.insn_cnt)
607 				child_item.data[8] = PercentToOneDP(child_item.cyc_cnt, self.cyc_cnt)
608 				child_item.data[11] = PercentToOneDP(child_item.branch_count, self.branch_count)
610 				child_item.data[6] = PercentToOneDP(child_item.branch_count, self.branch_count)
616 	def __init__(self, glb, params, row, comm_id, comm, parent_item):  argument
617 		super(CallGraphLevelOneItem, self).__init__(glb, params, row, parent_item)
618 		if self.params.have_ipc:
619 			self.data = [comm, "", "", "", "", "", "", "", "", "", "", ""]
621 			self.data = [comm, "", "", "", "", "", ""]
622 		self.dbid = comm_id
624 	def Select(self):  argument
625 		self.query_done = True
626 		query = QSqlQuery(self.glb.db)
630 					" WHERE comm_id = " + str(self.dbid))
632 …= CallGraphLevelTwoItem(self.glb, self.params, self.child_count, self.dbid, query.value(0), query.…
633 			self.child_items.append(child_item)
634 			self.child_count += 1
640 	def __init__(self, glb, params):  argument
641 		super(CallGraphRootItem, self).__init__(glb, params, 0, None)
642 		self.dbid = 0
643 		self.query_done = True
652 …child_item = CallGraphLevelOneItem(glb, params, self.child_count, query.value(0), query.value(1), …
653 			self.child_items.append(child_item)
654 			self.child_count += 1
660 	def __init__(self, glb, parent=None):  argument
661 		self.have_ipc = IsSelectable(glb.db, "calls", columns = "insn_count, cyc_count")
667 	def __init__(self, glb, parent=None):  argument
668 		super(CallGraphModelBase, self).__init__(glb, CallGraphModelParams(glb), parent)
670 	def FindSelect(self, value, pattern, query):  argument
677 			if not self.glb.dbref.is_sqlite3:
688 		self.DoFindSelect(query, match)
690 	def Found(self, query, found):  argument
692 			return self.FindPath(query)
695 	def FindValue(self, value, pattern, query, last_value, last_pattern):  argument
699 			self.FindSelect(value, pattern, query)
701 		return self.Found(query, found)
703 	def FindNext(self, query):  argument
707 		return self.Found(query, found)
709 	def FindPrev(self, query):  argument
713 		return self.Found(query, found)
715 	def FindThread(self, c):  argument
717 			ids = self.FindValue(c.value, c.pattern, c.query, c.last_value, c.last_pattern)
719 			ids = self.FindNext(c.query)
721 			ids = self.FindPrev(c.query)
724 	def Find(self, value, direction, pattern, context, callback):  argument
726 			def __init__(self, *x):  argument
727 				self.value, self.direction, self.pattern, self.query, self.last_value, self.last_pattern = x
728 			def Update(self, *x):  argument
729 …self.value, self.direction, self.pattern, self.last_value, self.last_pattern = x + (self.value, se…
733 			context.append(Context(value, direction, pattern, QSqlQuery(self.glb.db), None, None))
735 		thread = Thread(self.FindThread, context[0])
736 …thread.done.connect(lambda ids, t=thread, c=callback: self.FindDone(t, c, ids), Qt.QueuedConnectio…
739 	def FindDone(self, thread, callback, ids):  argument
746 	def __init__(self, glb, parent=None):  argument
747 		super(CallGraphModel, self).__init__(glb, parent)
749 	def GetRoot(self):  argument
750 		return CallGraphRootItem(self.glb, self.params)
752 	def columnCount(self, parent=None):  argument
753 		if self.params.have_ipc:
758 	def columnHeader(self, column):  argument
759 		if self.params.have_ipc:
765 	def columnAlignment(self, column):  argument
766 		if self.params.have_ipc:
772 	def DoFindSelect(self, query, match):  argument
782 	def FindPath(self, query):  argument
789 			q2 = QSqlQuery(self.glb.db)
807 …def __init__(self, glb, params, row, comm_id, thread_id, calls_id, call_time, time, insn_cnt, cyc_…  argument
808 		super(CallTreeLevelTwoPlusItemBase, self).__init__(glb, params, row, parent_item)
809 		self.comm_id = comm_id
810 		self.thread_id = thread_id
811 		self.calls_id = calls_id
812 		self.call_time = call_time
813 		self.time = time
814 		self.insn_cnt = insn_cnt
815 		self.cyc_cnt = cyc_cnt
816 		self.branch_count = branch_count
818 	def Select(self):  argument
819 		self.query_done = True
820 		if self.calls_id == 0:
821 			comm_thread = " AND comm_id = " + str(self.comm_id) + " AND thread_id = " + str(self.thread_id)
824 		if self.params.have_ipc:
828 		query = QSqlQuery(self.glb.db)
834 					" WHERE calls.parent_id = " + str(self.calls_id) + comm_thread +
837 			if self.params.have_ipc:
845 …self.glb, self.params, self.child_count, self.comm_id, self.thread_id, query.value(0), query.value…
846 			self.child_items.append(child_item)
847 			self.child_count += 1
853 …def __init__(self, glb, params, row, comm_id, thread_id, calls_id, name, dso, call_time, time, ins…  argument
854 …super(CallTreeLevelThreeItem, self).__init__(glb, params, row, comm_id, thread_id, calls_id, call_…
856 		if self.params.have_ipc:
861 …self.data = [ name, dso, str(call_time), str(time), PercentToOneDP(time, parent_item.time), str(in…
863 …self.data = [ name, dso, str(call_time), str(time), PercentToOneDP(time, parent_item.time), str(br…
864 		self.dbid = calls_id
870 	def __init__(self, glb, params, row, comm_id, thread_id, pid, tid, parent_item):  argument
871 …super(CallTreeLevelTwoItem, self).__init__(glb, params, row, comm_id, thread_id, 0, 0, 0, 0, 0, 0,…
872 		if self.params.have_ipc:
873 			self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", "", "", "", "", "", ""]
875 			self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", ""]
876 		self.dbid = thread_id
878 	def Select(self):  argument
879 		super(CallTreeLevelTwoItem, self).Select()
880 		for child_item in self.child_items:
881 			self.time += child_item.time
882 			self.insn_cnt += child_item.insn_cnt
883 			self.cyc_cnt += child_item.cyc_cnt
884 			self.branch_count += child_item.branch_count
885 		for child_item in self.child_items:
886 			child_item.data[4] = PercentToOneDP(child_item.time, self.time)
887 			if self.params.have_ipc:
888 				child_item.data[6] = PercentToOneDP(child_item.insn_cnt, self.insn_cnt)
889 				child_item.data[8] = PercentToOneDP(child_item.cyc_cnt, self.cyc_cnt)
890 				child_item.data[11] = PercentToOneDP(child_item.branch_count, self.branch_count)
892 				child_item.data[6] = PercentToOneDP(child_item.branch_count, self.branch_count)
898 	def __init__(self, glb, params, row, comm_id, comm, parent_item):  argument
899 		super(CallTreeLevelOneItem, self).__init__(glb, params, row, parent_item)
900 		if self.params.have_ipc:
901 			self.data = [comm, "", "", "", "", "", "", "", "", "", "", ""]
903 			self.data = [comm, "", "", "", "", "", ""]
904 		self.dbid = comm_id
906 	def Select(self):  argument
907 		self.query_done = True
908 		query = QSqlQuery(self.glb.db)
912 					" WHERE comm_id = " + str(self.dbid))
914 … = CallTreeLevelTwoItem(self.glb, self.params, self.child_count, self.dbid, query.value(0), query.…
915 			self.child_items.append(child_item)
916 			self.child_count += 1
922 	def __init__(self, glb, params):  argument
923 		super(CallTreeRootItem, self).__init__(glb, params, 0, None)
924 		self.dbid = 0
925 		self.query_done = True
934 …child_item = CallTreeLevelOneItem(glb, params, self.child_count, query.value(0), query.value(1), s…
935 			self.child_items.append(child_item)
936 			self.child_count += 1
942 	def __init__(self, glb, parent=None):  argument
943 		super(CallTreeModel, self).__init__(glb, parent)
945 	def GetRoot(self):  argument
946 		return CallTreeRootItem(self.glb, self.params)
948 	def columnCount(self, parent=None):  argument
949 		if self.params.have_ipc:
954 	def columnHeader(self, column):  argument
955 		if self.params.have_ipc:
961 	def columnAlignment(self, column):  argument
962 		if self.params.have_ipc:
968 	def DoFindSelect(self, query, match):  argument
977 	def FindPath(self, query):  argument
984 			q2 = QSqlQuery(self.glb.db)
999 	def __init__(self, *children):  argument
1000 		super(HBoxLayout, self).__init__()
1002 		self.layout().setContentsMargins(0, 0, 0, 0)
1005 				self.layout().addWidget(child)
1007 				self.layout().addLayout(child)
1013 	def __init__(self, *children):  argument
1014 		super(VBoxLayout, self).__init__()
1016 		self.layout().setContentsMargins(0, 0, 0, 0)
1019 				self.layout().addWidget(child)
1021 				self.layout().addLayout(child)
1027 	def __init__(self, *children):  argument
1028 		self.vbox = QWidget()
1029 		self.vbox.setLayout(VBoxLayout(*children))
1031 	def Widget(self):  argument
1032 		return self.vbox
1038 	def __init__(self, parent=None):  argument
1039 		super(TreeWindowBase, self).__init__(parent)
1041 		self.model = None
1042 		self.find_bar = None
1044 		self.view = QTreeView()
1045 		self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
1046 		self.view.CopyCellsToClipboard = CopyTreeCellsToClipboard
1048 		self.context_menu = TreeContextMenu(self.view)
1050 	def DisplayFound(self, ids):  argument
1056 			n = self.model.rowCount(parent)
1058 				child = self.model.index(row, 0, parent)
1061 					self.view.setExpanded(parent, True)
1062 					self.view.setCurrentIndex(child)
1069 	def Find(self, value, direction, pattern, context):  argument
1070 		self.view.setFocus()
1071 		self.find_bar.Busy()
1072 		self.model.Find(value, direction, pattern, context, self.FindDone)
1074 	def FindDone(self, ids):  argument
1076 		if not self.DisplayFound(ids):
1078 		self.find_bar.Idle()
1080 			self.find_bar.NotFound()
1087 	def __init__(self, glb, parent=None):  argument
1088 		super(CallGraphWindow, self).__init__(parent)
1090 		self.model = LookupCreateModel("Context-Sensitive Call Graph", lambda x=glb: CallGraphModel(x))
1092 		self.view.setModel(self.model)
1095 			self.view.setColumnWidth(c, w)
1097 		self.find_bar = FindBar(self, self)
1099 		self.vbox = VBox(self.view, self.find_bar.Widget())
1101 		self.setWidget(self.vbox.Widget())
1103 		AddSubWindow(glb.mainwindow.mdi_area, self, "Context-Sensitive Call Graph")
1109 	def __init__(self, glb, parent=None, thread_at_time=None):  argument
1110 		super(CallTreeWindow, self).__init__(parent)
1112 		self.model = LookupCreateModel("Call Tree", lambda x=glb: CallTreeModel(x))
1114 		self.view.setModel(self.model)
1117 			self.view.setColumnWidth(c, w)
1119 		self.find_bar = FindBar(self, self)
1121 		self.vbox = VBox(self.view, self.find_bar.Widget())
1123 		self.setWidget(self.vbox.Widget())
1125 		AddSubWindow(glb.mainwindow.mdi_area, self, "Call Tree")
1128 			self.DisplayThreadAtTime(*thread_at_time)
1130 	def DisplayThreadAtTime(self, comm_id, thread_id, time):  argument
1134 			n = self.model.rowCount(parent)
1136 				child = self.model.index(row, 0, parent)
1139 					self.view.setExpanded(parent, True)
1140 					self.view.setCurrentIndex(child)
1147 			n = self.model.rowCount(parent)
1152 				self.view.setExpanded(parent, True)
1153 				child = self.model.index(row, 0, parent)
1158 					self.view.setCurrentIndex(child)
1164 					child = self.model.index(0, 0, parent)
1165 					self.view.setExpanded(parent, True)
1166 					self.view.setCurrentIndex(child)
1169 			self.view.setExpanded(parent, True)
1170 			self.view.setCurrentIndex(last_child)
1196 	def __init__(self, x=0, y=0):  argument
1197 		self.x = x
1198 		self.y = y
1200 	def __str__(self):  argument
1201 		return "XY({}, {})".format(str(self.x), str(self.y))
1206 	def __init__(self, lo=0, hi=0):  argument
1207 		self.lo = lo
1208 		self.hi = hi
1210 	def __str__(self):  argument
1211 		return "Subrange({}, {})".format(str(self.lo), str(self.hi))
1217 	def __init__(self, key, title = "", ordinal = ""):  argument
1218 		self.key = key
1219 		self.title = title
1220 		self.ordinal = ordinal
1231 	def __init__(self, colour):  argument
1232 		self.colour = colour
1238 	def __init__(self, key, exec_comm_id, pid, tid, comm, thread_id, comm_id):  argument
1239 		super(SwitchGraphDataRegion, self).__init__(key)
1241 		self.title = str(pid) + " / " + str(tid) + " " + comm
1243 		self.ordinal = str(pid).rjust(16) + str(exec_comm_id).rjust(8) + str(tid).rjust(16)
1244 		self.exec_comm_id = exec_comm_id
1245 		self.pid = pid
1246 		self.tid = tid
1247 		self.comm = comm
1248 		self.thread_id = thread_id
1249 		self.comm_id = comm_id
1255 	def __init__(self, data, index, x, y, altx=None, alty=None, hregion=None, vregion=None):  argument
1256 		self.data = data
1257 		self.index = index
1258 		self.x = x
1259 		self.y = y
1260 		self.altx = altx
1261 		self.alty = alty
1262 		self.hregion = hregion
1263 		self.vregion = vregion
1269 	def __init__(self, collection, xbase=Decimal(0), ybase=Decimal(0)):  argument
1270 		self.collection = collection
1271 		self.points = []
1272 		self.xbase = xbase
1273 		self.ybase = ybase
1274 		self.title = ""
1276 	def AddPoint(self, x, y, altx=None, alty=None, hregion=None, vregion=None):  argument
1277 		index = len(self.points)
1279 		x = float(Decimal(x) - self.xbase)
1280 		y = float(Decimal(y) - self.ybase)
1282 		self.points.append(GraphDataPoint(self, index, x, y, altx, alty, hregion, vregion))
1284 	def XToData(self, x):  argument
1285 		return Decimal(x) + self.xbase
1287 	def YToData(self, y):  argument
1288 		return Decimal(y) + self.ybase
1294 	def __init__(self, db, collection, cpu, xbase):  argument
1295 		super(SwitchGraphData, self).__init__(collection, xbase)
1297 		self.cpu = cpu
1298 		self.title = "CPU " + str(cpu)
1299 		self.SelectSwitches(db)
1301 	def SelectComms(self, db, thread_id, last_comm_id, start_time, end_time):  argument
1306 					"   AND exec_flag = " + self.collection.glb.dbref.TRUE +
1315 			hregion = self.HRegion(db, thread_id, comm_id, time)
1316 			self.AddPoint(time, 1000, None, None, hregion)
1318 	def SelectSwitches(self, db):  argument
1325 					" WHERE machine_id = " + str(self.collection.machine_id) +
1326 					"   AND cpu = " + str(self.cpu) +
1333 					self.SelectComms(db, last_thread_id, last_comm_id, last_time, query.value(0))
1336 			if len(self.points) == 0:
1337 				start_time = self.collection.glb.StartTime(self.collection.machine_id)
1338 				hregion = self.HRegion(db, query.value(1), query.value(3), start_time)
1339 				self.AddPoint(start_time, 1000, None, None, hregion)
1343 			hregion = self.HRegion(db, thread_id, comm_id, time)
1344 			self.AddPoint(time, 1000, None, None, hregion)
1349 	def NewHRegion(self, db, key, thread_id, comm_id, time):  argument
1367 	def HRegion(self, db, thread_id, comm_id, time):  argument
1369 		hregion = self.collection.LookupHRegion(key)
1371 			hregion = self.NewHRegion(db, key, thread_id, comm_id, time)
1372 			self.collection.AddHRegion(key, hregion)
1379 	def __init__(self, glb):  argument
1380 		self.glb = glb
1381 		self.data = []
1382 		self.hregions = {}
1383 		self.xrangelo = None
1384 		self.xrangehi = None
1385 		self.yrangelo = None
1386 		self.yrangehi = None
1387 		self.dp = XY(0, 0)
1389 	def AddGraphData(self, data):  argument
1390 		self.data.append(data)
1392 	def LookupHRegion(self, key):  argument
1393 		if key in self.hregions:
1394 			return self.hregions[key]
1397 	def AddHRegion(self, key, hregion):  argument
1398 		self.hregions[key] = hregion
1404 	def __init__(self, glb, db, machine_id):  argument
1405 		super(SwitchGraphDataCollection, self).__init__(glb)
1407 		self.machine_id = machine_id
1408 		self.cpus = self.SelectCPUs(db)
1410 		self.xrangelo = glb.StartTime(machine_id)
1411 		self.xrangehi = glb.FinishTime(machine_id)
1413 		self.yrangelo = Decimal(0)
1414 		self.yrangehi = Decimal(1000)
1416 		for cpu in self.cpus:
1417 			self.AddGraphData(SwitchGraphData(db, self, cpu, self.xrangelo))
1419 	def SelectCPUs(self, db):  argument
1424 					" WHERE machine_id = " + str(self.machine_id))
1433 	def __init__(self, data, graph_width, graph_height, attrs, event_handler, parent=None):  argument
1434 		super(SwitchGraphDataGraphicsItem, self).__init__(parent)
1436 		self.data = data
1437 		self.graph_width = graph_width
1438 		self.graph_height = graph_height
1439 		self.attrs = attrs
1440 		self.event_handler = event_handler
1441 		self.setAcceptHoverEvents(True)
1443 	def boundingRect(self):  argument
1444 		return QRectF(0, 0, self.graph_width, self.graph_height)
1446 	def PaintPoint(self, painter, last, x):  argument
1447 		if not(last is None or last.hregion.pid == 0 or x < self.attrs.subrange.x.lo):
1448 			if last.x < self.attrs.subrange.x.lo:
1449 				x0 = self.attrs.subrange.x.lo
1452 			if x > self.attrs.subrange.x.hi:
1453 				x1 = self.attrs.subrange.x.hi
1456 			x0 = self.attrs.XToPixel(x0)
1457 			x1 = self.attrs.XToPixel(x1)
1459 			y0 = self.attrs.YToPixel(last.y)
1461 			colour = self.attrs.region_attributes[last.hregion.key].colour
1466 				painter.drawLine(x0, self.graph_height - y0, x0, self.graph_height)
1468 				painter.fillRect(x0, self.graph_height - y0, width, self.graph_height - 1, colour)
1470 	def paint(self, painter, option, widget):  argument
1472 		for point in self.data.points:
1473 			self.PaintPoint(painter, last, point.x)
1474 			if point.x > self.attrs.subrange.x.hi:
1477 		self.PaintPoint(painter, last, self.attrs.subrange.x.hi + 1)
1479 	def BinarySearchPoint(self, target):  argument
1481 		higher_pos = len(self.data.points)
1484 			val = self.data.points[pos].x
1492 	def XPixelToData(self, x):  argument
1493 		x = self.attrs.PixelToX(x)
1494 		if x < self.data.points[0].x:
1499 			pos = self.BinarySearchPoint(x)
1501 		return (low, pos, self.data.XToData(x))
1503 	def EventToData(self, event):  argument
1505 		if len(self.data.points) < 1:
1510 		low0, pos0, time_from = self.XPixelToData(x)
1511 		low1, pos1, time_to = self.XPixelToData(x + 1)
1516 				hregion = self.data.points[i].hregion
1521 					time = self.data.XToData(self.data.points[i].x)
1525 	def hoverMoveEvent(self, event):  argument
1526 		time_from, time_to, hregions, hregion_times = self.EventToData(event)
1528 			self.event_handler.PointEvent(self.data.cpu, time_from, time_to, hregions)
1530 	def hoverLeaveEvent(self, event):  argument
1531 		self.event_handler.NoPointEvent()
1533 	def mousePressEvent(self, event):  argument
1535 			super(SwitchGraphDataGraphicsItem, self).mousePressEvent(event)
1537 		time_from, time_to, hregions, hregion_times = self.EventToData(event)
1539 			self.event_handler.RightClickEvent(self.data.cpu, hregion_times, event.screenPos())
1545 	def __init__(self, width, parent=None):  argument
1546 		super(XAxisGraphicsItem, self).__init__(parent)
1548 		self.width = width
1549 		self.max_mark_sz = 4
1550 		self.height = self.max_mark_sz + 1
1552 	def boundingRect(self):  argument
1553 		return QRectF(0, 0, self.width, self.height)
1555 	def Step(self):  argument
1556 		attrs = self.parentItem().attrs
1559 		s = (3.0 * t) / self.width
1565 	def PaintMarks(self, painter, at_y, lo, hi, step, i):  argument
1566 		attrs = self.parentItem().attrs
1576 				sz = self.max_mark_sz
1582 	def paint(self, painter, option, widget):  argument
1584 		painter.drawLine(0, 0, self.width - 1, 0)
1585 		n = self.Step()
1586 		attrs = self.parentItem().attrs
1594 		self.PaintMarks(painter, 0, x, subrange.hi, n, i)
1596 	def ScaleDimensions(self):  argument
1597 		n = self.Step()
1598 		attrs = self.parentItem().attrs
1606 	def PaintScale(self, painter, at_x, at_y):  argument
1607 		n, lo, hi, width = self.ScaleDimensions()
1611 		self.PaintMarks(painter, at_y, lo, hi, n, 0)
1613 	def ScaleWidth(self):  argument
1614 		n, lo, hi, width = self.ScaleDimensions()
1617 	def ScaleHeight(self):  argument
1618 		return self.height
1620 	def ScaleUnit(self):  argument
1621 		return self.Step() * 10
1627 	def __init__(self, axis, parent=None):  argument
1628 		super(ScaleGraphicsItem, self).__init__(parent)
1629 		self.axis = axis
1631 	def boundingRect(self):  argument
1632 		scale_width = self.axis.ScaleWidth()
1635 		return QRectF(0, 0, self.axis.ScaleWidth() + 100, self.axis.ScaleHeight())
1637 	def paint(self, painter, option, widget):  argument
1638 		scale_width = self.axis.ScaleWidth()
1641 		self.axis.PaintScale(painter, 0, 5)
1643 		painter.drawText(QPointF(x, 10), self.Text())
1645 	def Unit(self):  argument
1646 		return self.axis.ScaleUnit()
1648 	def Text(self):  argument
1655 	def __init__(self, axis, parent=None):  argument
1656 		super(SwitchScaleGraphicsItem, self).__init__(axis, parent)
1658 	def Text(self):  argument
1659 		unit = self.Unit()
1678 	def __init__(self, collection, data, attrs, event_handler, first, parent=None):  argument
1679 		super(SwitchGraphGraphicsItem, self).__init__(parent)
1680 		self.collection = collection
1681 		self.data = data
1682 		self.attrs = attrs
1683 		self.event_handler = event_handler
1688 		self.title_graphics = QGraphicsSimpleTextItem(data.title, self)
1690 		self.title_graphics.setPos(margin, margin)
1694 		self.graph_origin_x = margin + title_width + margin
1695 		self.graph_origin_y = graph_height + margin
1699 		self.yline = QGraphicsLineItem(0, 0, 0, graph_height, self)
1701 		self.x_axis = XAxisGraphicsItem(graph_width, self)
1702 		self.x_axis.setPos(self.graph_origin_x, self.graph_origin_y + 1)
1705 			self.scale_item = SwitchScaleGraphicsItem(self.x_axis, self)
1706 			self.scale_item.setPos(self.graph_origin_x, self.graph_origin_y + 10)
1708 		self.yline.setPos(self.graph_origin_x - y_axis_size, self.graph_origin_y - graph_height)
1710 		self.axis_point = QGraphicsLineItem(0, 0, 0, 0, self)
1711 		self.axis_point.setPos(self.graph_origin_x - 1, self.graph_origin_y +1)
1713 		self.width = self.graph_origin_x + graph_width + margin
1714 		self.height = self.graph_origin_y + margin
1716 …self.graph = SwitchGraphDataGraphicsItem(data, graph_width, graph_height, attrs, event_handler, se…
1717 		self.graph.setPos(self.graph_origin_x, self.graph_origin_y - graph_height)
1720 			parent.EnableRubberBand(self.graph_origin_x, self.graph_origin_x + graph_width - 1, self)
1722 	def boundingRect(self):  argument
1723 		return QRectF(0, 0, self.width, self.height)
1725 	def paint(self, painter, option, widget):  argument
1728 	def RBXToPixel(self, x):  argument
1729 		return self.attrs.PixelToX(x - self.graph_origin_x)
1731 	def RBXRangeToPixel(self, x0, x1):  argument
1732 		return (self.RBXToPixel(x0), self.RBXToPixel(x1 + 1))
1734 	def RBPixelToTime(self, x):  argument
1735 		if x < self.data.points[0].x:
1736 			return self.data.XToData(0)
1737 		return self.data.XToData(x)
1739 	def RBEventTimes(self, x0, x1):  argument
1740 		x0, x1 = self.RBXRangeToPixel(x0, x1)
1741 		time_from = self.RBPixelToTime(x0)
1742 		time_to = self.RBPixelToTime(x1)
1745 	def RBEvent(self, x0, x1):  argument
1746 		time_from, time_to = self.RBEventTimes(x0, x1)
1747 		self.event_handler.RangeEvent(time_from, time_to)
1749 	def RBMoveEvent(self, x0, x1):  argument
1752 		self.RBEvent(x0, x1)
1754 	def RBReleaseEvent(self, x0, x1, selection_state):  argument
1757 		x0, x1 = self.RBXRangeToPixel(x0, x1)
1758 		self.event_handler.SelectEvent(x0, x1, selection_state)
1764 	def __init__(self, parent=None):  argument
1765 		super(VerticalBracketGraphicsItem, self).__init__(parent)
1767 		self.width = 0
1768 		self.height = 0
1769 		self.hide()
1771 	def SetSize(self, width, height):  argument
1772 		self.width = width + 1
1773 		self.height = height + 1
1775 	def boundingRect(self):  argument
1776 		return QRectF(0, 0, self.width, self.height)
1778 	def paint(self, painter, option, widget):  argument
1780 		painter.fillRect(0, 0, self.width, self.height, colour)
1781 		x1 = self.width - 1
1782 		y1 = self.height - 1
1794 	def __init__(self, collection, attrs, event_handler, child_class, parent=None):  argument
1795 		super(VertcalGraphSetGraphicsItem, self).__init__(parent)
1797 		self.collection = collection
1799 		self.top = 10
1801 		self.width = 0
1802 		self.height = self.top
1804 		self.rubber_band = None
1805 		self.rb_enabled = False
1809 			child = child_class(collection, data, attrs, event_handler, first, self)
1810 			child.setPos(0, self.height + 1)
1812 			if rect.right() > self.width:
1813 				self.width = rect.right()
1814 			self.height = self.height + rect.bottom() + 1
1817 		self.bracket = VerticalBracketGraphicsItem(self)
1819 	def EnableRubberBand(self, xlo, xhi, rb_event_handler):  argument
1820 		if self.rb_enabled:
1822 		self.rb_enabled = True
1823 		self.rb_in_view = False
1824 		self.setAcceptedMouseButtons(Qt.LeftButton)
1825 		self.rb_xlo = xlo
1826 		self.rb_xhi = xhi
1827 		self.rb_event_handler = rb_event_handler
1828 		self.mousePressEvent = self.MousePressEvent
1829 		self.mouseMoveEvent = self.MouseMoveEvent
1830 		self.mouseReleaseEvent = self.MouseReleaseEvent
1832 	def boundingRect(self):  argument
1833 		return QRectF(0, 0, self.width, self.height)
1835 	def paint(self, painter, option, widget):  argument
1838 	def RubberBandParent(self):  argument
1839 		scene = self.scene()
1844 	def RubberBandSetGeometry(self, rect):  argument
1845 		scene_rectf = self.mapRectToScene(QRectF(rect))
1846 		scene = self.scene()
1849 		self.rubber_band.setGeometry(poly.boundingRect())
1851 	def SetSelection(self, selection_state):  argument
1852 		if self.rubber_band:
1854 				self.RubberBandSetGeometry(selection_state)
1855 				self.rubber_band.show()
1857 				self.rubber_band.hide()
1859 	def SetBracket(self, rect):  argument
1862 			self.bracket.setPos(x, y)
1863 			self.bracket.SetSize(width, height)
1864 			self.bracket.show()
1866 			self.bracket.hide()
1868 	def RubberBandX(self, event):  argument
1870 		if x < self.rb_xlo:
1871 			x = self.rb_xlo
1872 		elif x > self.rb_xhi:
1873 			x = self.rb_xhi
1875 			self.rb_in_view = True
1878 	def RubberBandRect(self, x):  argument
1879 		if self.rb_origin.x() <= x:
1880 			width = x - self.rb_origin.x()
1881 			rect = QRect(self.rb_origin, QSize(width, self.height))
1883 			width = self.rb_origin.x() - x
1884 			top_left = QPoint(self.rb_origin.x() - width, self.rb_origin.y())
1885 			rect = QRect(top_left, QSize(width, self.height))
1888 	def MousePressEvent(self, event):  argument
1889 		self.rb_in_view = False
1890 		x = self.RubberBandX(event)
1891 		self.rb_origin = QPoint(x, self.top)
1892 		if self.rubber_band is None:
1893 			self.rubber_band = QRubberBand(QRubberBand.Rectangle, self.RubberBandParent())
1894 		self.RubberBandSetGeometry(QRect(self.rb_origin, QSize(0, self.height)))
1895 		if self.rb_in_view:
1896 			self.rubber_band.show()
1897 			self.rb_event_handler.RBMoveEvent(x, x)
1899 			self.rubber_band.hide()
1901 	def MouseMoveEvent(self, event):  argument
1902 		x = self.RubberBandX(event)
1903 		rect = self.RubberBandRect(x)
1904 		self.RubberBandSetGeometry(rect)
1905 		if self.rb_in_view:
1906 			self.rubber_band.show()
1907 			self.rb_event_handler.RBMoveEvent(self.rb_origin.x(), x)
1909 	def MouseReleaseEvent(self, event):  argument
1910 		x = self.RubberBandX(event)
1911 		if self.rb_in_view:
1912 			selection_state = self.RubberBandRect(x)
1915 		self.rb_event_handler.RBReleaseEvent(self.rb_origin.x(), x, selection_state)
1921 	def __init__(self, collection, region_attributes, parent=None):  argument
1922 		super(SwitchGraphLegendModel, self).__init__(parent)
1924 		self.region_attributes = region_attributes
1926 		self.child_items = sorted(collection.hregions.values(), key=GraphDataRegionOrdinal)
1927 		self.child_count = len(self.child_items)
1929 		self.highlight_set = set()
1931 		self.column_headers = ("pid", "tid", "comm")
1933 	def rowCount(self, parent):  argument
1934 		return self.child_count
1936 	def headerData(self, section, orientation, role):  argument
1941 		return self.columnHeader(section)
1943 	def index(self, row, column, parent):  argument
1944 		return self.createIndex(row, column, self.child_items[row])
1946 	def columnCount(self, parent=None):  argument
1947 		return len(self.column_headers)
1949 	def columnHeader(self, column):  argument
1950 		return self.column_headers[column]
1952 	def data(self, index, role):  argument
1954 			child = self.child_items[index.row()]
1955 			if child in self.highlight_set:
1956 				return self.region_attributes[child.key].colour
1959 			child = self.child_items[index.row()]
1960 			if child in self.highlight_set:
1962 			return self.region_attributes[child.key].colour
1965 		hregion = self.child_items[index.row()]
1975 	def SetHighlight(self, row, set_highlight):  argument
1976 		child = self.child_items[row]
1977 		top_left = self.createIndex(row, 0, child)
1978 		bottom_right = self.createIndex(row, len(self.column_headers) - 1, child)
1979 		self.dataChanged.emit(top_left, bottom_right)
1981 	def Highlight(self, highlight_set):  argument
1982 		for row in xrange(self.child_count):
1983 			child = self.child_items[row]
1984 			if child in self.highlight_set:
1986 					self.SetHighlight(row, False)
1988 				self.SetHighlight(row, True)
1989 		self.highlight_set = highlight_set
1995 	def __init__(self, collection, region_attributes, parent=None):  argument
1996 		super(SwitchGraphLegend, self).__init__(parent)
1998 		self.data_model = SwitchGraphLegendModel(collection, region_attributes)
2000 		self.model = QSortFilterProxyModel()
2001 		self.model.setSourceModel(self.data_model)
2003 		self.view = QTableView()
2004 		self.view.setModel(self.model)
2005 		self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
2006 		self.view.verticalHeader().setVisible(False)
2007 		self.view.sortByColumn(-1, Qt.AscendingOrder)
2008 		self.view.setSortingEnabled(True)
2009 		self.view.resizeColumnsToContents()
2010 		self.view.resizeRowsToContents()
2012 		self.vbox = VBoxLayout(self.view)
2013 		self.setLayout(self.vbox)
2015 		sz1 = self.view.columnWidth(0) + self.view.columnWidth(1) + self.view.columnWidth(2) + 2
2016 		sz1 = sz1 + self.view.verticalScrollBar().sizeHint().width()
2017 		self.saved_size = sz1
2019 	def resizeEvent(self, event):  argument
2020 		self.saved_size = self.size().width()
2021 		super(SwitchGraphLegend, self).resizeEvent(event)
2023 	def Highlight(self, highlight_set):  argument
2024 		self.data_model.Highlight(highlight_set)
2025 		self.update()
2027 	def changeEvent(self, event):  argument
2029 			self.view.resizeRowsToContents()
2030 			self.view.resizeColumnsToContents()
2032 			self.view.resizeRowsToContents()
2033 		super(SwitchGraphLegend, self).changeEvent(event)
2079 	def __init__(self, scale, subrange, region_attributes, dp):  argument
2080 		self.scale = scale
2081 		self.subrange = subrange
2082 		self.region_attributes = region_attributes
2084 		self.dp = dp	# data decimal places
2085 		self.Update()
2087 	def XToPixel(self, x):  argument
2088 		return int(round((x - self.subrange.x.lo) * self.scale.x, self.pdp.x))
2090 	def YToPixel(self, y):  argument
2091 		return int(round((y - self.subrange.y.lo) * self.scale.y, self.pdp.y))
2093 	def PixelToXRounded(self, px):  argument
2094 		return round((round(px, 0) / self.scale.x), self.dp.x) + self.subrange.x.lo
2096 	def PixelToYRounded(self, py):  argument
2097 		return round((round(py, 0) / self.scale.y), self.dp.y) + self.subrange.y.lo
2099 	def PixelToX(self, px):  argument
2100 		x = self.PixelToXRounded(px)
2101 		if self.pdp.x == 0:
2102 			rt = self.XToPixel(x)
2107 	def PixelToY(self, py):  argument
2108 		y = self.PixelToYRounded(py)
2109 		if self.pdp.y == 0:
2110 			rt = self.YToPixel(y)
2115 	def ToPDP(self, dp, scale):  argument
2131 	def Update(self):  argument
2132 		x = self.ToPDP(self.dp.x, self.scale.x)
2133 		y = self.ToPDP(self.dp.y, self.scale.y)
2134 		self.pdp = XY(x, y) # pixel decimal places
2140 	def __init__(self, parent=None):  argument
2141 		super(SwitchGraphSplitter, self).__init__(parent)
2143 		self.first_time = False
2145 	def resizeEvent(self, ev):  argument
2146 		if self.first_time:
2147 			self.first_time = False
2148 …sz1 = self.widget(1).view.columnWidth(0) + self.widget(1).view.columnWidth(1) + self.widget(1).vie…
2149 			sz1 = sz1 + self.widget(1).view.verticalScrollBar().sizeHint().width()
2150 			sz0 = self.size().width() - self.handleWidth() - sz1
2151 			self.setSizes([sz0, sz1])
2152 		elif not(self.widget(1).saved_size is None):
2153 			sz1 = self.widget(1).saved_size
2154 			sz0 = self.size().width() - self.handleWidth() - sz1
2155 			self.setSizes([sz0, sz1])
2156 		super(SwitchGraphSplitter, self).resizeEvent(ev)
2164 	def __init__(self, parent=None):  argument
2165 		super(GraphWidget, self).__init__(parent)
2167 	def GraphTitleChanged(self, title):  argument
2168 		self.graph_title_changed.emit(title)
2170 	def Title(self):  argument
2189 	def __init__(self, glb, collection, parent=None):  argument
2190 		super(SwitchGraphWidget, self).__init__(parent)
2192 		self.glb = glb
2193 		self.collection = collection
2195 		self.back_state = []
2196 		self.forward_state = []
2197 		self.selection_state = (None, None)
2198 		self.fwd_rect = None
2199 		self.start_time = self.glb.StartTime(collection.machine_id)
2217 		scale = self.GetScaleForRange(subrange)
2219 		self.attrs = GraphAttributes(scale, subrange, region_attributes, collection.dp)
2221 		self.item = VertcalGraphSetGraphicsItem(collection, self.attrs, self, SwitchGraphGraphicsItem)
2223 		self.scene = QGraphicsScene()
2224 		self.scene.addItem(self.item)
2226 		self.view = QGraphicsView(self.scene)
2227 		self.view.centerOn(0, 0)
2228 		self.view.setAlignment(Qt.AlignLeft | Qt.AlignTop)
2230 		self.legend = SwitchGraphLegend(collection, region_attributes)
2232 		self.splitter = SwitchGraphSplitter()
2233 		self.splitter.addWidget(self.view)
2234 		self.splitter.addWidget(self.legend)
2236 		self.point_label = QLabel("")
2237 		self.point_label.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
2239 		self.back_button = QToolButton()
2240 		self.back_button.setIcon(self.style().standardIcon(QStyle.SP_ArrowLeft))
2241 		self.back_button.setDisabled(True)
2242 		self.back_button.released.connect(lambda: self.Back())
2244 		self.forward_button = QToolButton()
2245 		self.forward_button.setIcon(self.style().standardIcon(QStyle.SP_ArrowRight))
2246 		self.forward_button.setDisabled(True)
2247 		self.forward_button.released.connect(lambda: self.Forward())
2249 		self.zoom_button = QToolButton()
2250 		self.zoom_button.setText("Zoom")
2251 		self.zoom_button.setDisabled(True)
2252 		self.zoom_button.released.connect(lambda: self.Zoom())
2254 		self.hbox = HBoxLayout(self.back_button, self.forward_button, self.zoom_button, self.point_label)
2256 		self.vbox = VBoxLayout(self.splitter, self.hbox)
2258 		self.setLayout(self.vbox)
2260 	def GetScaleForRangeX(self, xsubrange):  argument
2266 	def GetScaleForRangeY(self, ysubrange):  argument
2272 	def GetScaleForRange(self, subrange):  argument
2274 		xscale = self.GetScaleForRangeX(subrange.x)
2275 		yscale = self.GetScaleForRangeY(subrange.y)
2278 	def PointEvent(self, cpu, time_from, time_to, hregions):  argument
2281 		rel_time_from = time_from - self.glb.StartTime(self.collection.machine_id)
2283 		self.point_label.setText(text)
2284 		self.legend.Highlight(hregions)
2286 	def RightClickEvent(self, cpu, hregion_times, pos):  argument
2287 		if not IsSelectable(self.glb.db, "calls", "WHERE parent_id >= 0"):
2289 		menu = QMenu(self.view)
2293 …text, "Show Call Tree", lambda a=None, args=thread_at_time: self.RightClickSelect(args), self.view…
2296 	def RightClickSelect(self, args):  argument
2297 		CallTreeWindow(self.glb, self.glb.mainwindow, thread_at_time=args)
2299 	def NoPointEvent(self):  argument
2300 		self.point_label.setText("")
2301 		self.legend.Highlight({})
2303 	def RangeEvent(self, time_from, time_to):  argument
2307 			self.point_label.setText("")
2309 		rel_time_from = time_from - self.start_time
2310 		rel_time_to = time_to - self.start_time
2313 		self.point_label.setText(text)
2315 	def BackState(self):  argument
2316 		return (self.attrs.subrange, self.attrs.scale, self.selection_state, self.fwd_rect)
2318 	def PushBackState(self):  argument
2319 		state = copy.deepcopy(self.BackState())
2320 		self.back_state.append(state)
2321 		self.back_button.setEnabled(True)
2323 	def PopBackState(self):  argument
2324 		self.attrs.subrange, self.attrs.scale, self.selection_state, self.fwd_rect = self.back_state.pop()
2325 		self.attrs.Update()
2326 		if not self.back_state:
2327 			self.back_button.setDisabled(True)
2329 	def PushForwardState(self):  argument
2330 		state = copy.deepcopy(self.BackState())
2331 		self.forward_state.append(state)
2332 		self.forward_button.setEnabled(True)
2334 	def PopForwardState(self):  argument
2335 …self.attrs.subrange, self.attrs.scale, self.selection_state, self.fwd_rect = self.forward_state.po…
2336 		self.attrs.Update()
2337 		if not self.forward_state:
2338 			self.forward_button.setDisabled(True)
2340 	def Title(self):  argument
2341 		time_from = self.collection.xrangelo + Decimal(self.attrs.subrange.x.lo)
2342 		time_to = self.collection.xrangelo + Decimal(self.attrs.subrange.x.hi)
2343 		rel_time_from = time_from - self.start_time
2344 		rel_time_to = time_to - self.start_time
2349 	def Update(self):  argument
2350 		selected_subrange, selection_state = self.selection_state
2351 		self.item.SetSelection(selection_state)
2352 		self.item.SetBracket(self.fwd_rect)
2353 		self.zoom_button.setDisabled(selected_subrange is None)
2354 		self.GraphTitleChanged(self.Title())
2355 		self.item.update(self.item.boundingRect())
2357 	def Back(self):  argument
2358 		if not self.back_state:
2360 		self.PushForwardState()
2361 		self.PopBackState()
2362 		self.Update()
2364 	def Forward(self):  argument
2365 		if not self.forward_state:
2367 		self.PushBackState()
2368 		self.PopForwardState()
2369 		self.Update()
2371 	def SelectEvent(self, x0, x1, selection_state):  argument
2378 		self.selection_state = (selected_subrange, selection_state)
2379 		self.zoom_button.setDisabled(selected_subrange is None)
2381 	def Zoom(self):  argument
2382 		selected_subrange, selection_state = self.selection_state
2385 		self.fwd_rect = selection_state
2386 		self.item.SetSelection(None)
2387 		self.PushBackState()
2388 		self.attrs.subrange.x = selected_subrange
2389 		self.forward_state = []
2390 		self.forward_button.setDisabled(True)
2391 		self.selection_state = (None, None)
2392 		self.fwd_rect = None
2393 		self.attrs.scale.x = self.GetScaleForRangeX(self.attrs.subrange.x)
2394 		self.attrs.Update()
2395 		self.Update()
2401 	def __init__(self, glb, title, init_fn):  argument
2402 		self.init_fn = init_fn
2403 		self.done = False
2404 		self.result = None
2406 		self.msg_box = QMessageBox(glb.mainwindow)
2407 		self.msg_box.setText("Initializing " + title + ". Please wait.")
2408 		self.msg_box.setWindowTitle("Initializing " + title)
2409 		self.msg_box.setWindowIcon(glb.mainwindow.style().standardIcon(QStyle.SP_MessageBoxInformation))
2411 		self.init_thread = Thread(self.ThreadFn, glb)
2412 		self.init_thread.done.connect(lambda: self.Done(), Qt.QueuedConnection)
2414 		self.init_thread.start()
2416 	def Done(self):  argument
2417 		self.msg_box.done(0)
2419 	def ThreadFn(self, glb):  argument
2422 		self.result = self.init_fn(db)
2423 		self.done = True
2426 	def Result(self):  argument
2427 		while not self.done:
2428 			self.msg_box.exec_()
2429 		self.init_thread.wait()
2430 		return self.result
2440 	def __init__(self, glb, parent=None):  argument
2441 		super(TimeChartByCPUWindow, self).__init__(parent)
2443 		self.glb = glb
2444 		self.machine_id = glb.HostMachineId()
2445 		self.collection_name = "SwitchGraphDataCollection " + str(self.machine_id)
2447 		collection = LookupModel(self.collection_name)
2449 			collection = SlowInit(glb, "Time Chart", self.Init)
2451 		self.widget = SwitchGraphWidget(glb, collection, self)
2452 		self.view = self.widget
2454 		self.base_title = "Time Chart by CPU"
2455 		self.setWindowTitle(self.base_title + self.widget.Title())
2456 		self.widget.graph_title_changed.connect(self.GraphTitleChanged)
2458 		self.setWidget(self.widget)
2460 		AddSubWindow(glb.mainwindow.mdi_area, self, self.windowTitle())
2462 	def Init(self, db):  argument
2463 …return LookupCreateModel(self.collection_name, lambda : SwitchGraphDataCollection(self.glb, db, se…
2465 	def GraphTitleChanged(self, title):  argument
2466 		self.setWindowTitle(self.base_title + " : " + title)
2472 	def __init__(self, root):  argument
2473 		self.root = root
2474 		self.value, self.direction, self.pattern, self.last_value, self.last_pattern = (None,) * 5
2475 		self.rows = []
2476 		self.pos = 0
2478 	def FindSelect(self):  argument
2479 		self.rows = []
2480 		if self.pattern:
2481 			pattern = re.compile(self.value)
2482 			for child in self.root.child_items:
2485 						self.rows.append(child.row)
2488 			for child in self.root.child_items:
2490 					if self.value in str(column_data):
2491 						self.rows.append(child.row)
2494 	def FindValue(self):  argument
2495 		self.pos = 0
2496 		if self.last_value != self.value or self.pattern != self.last_pattern:
2497 			self.FindSelect()
2498 		if not len(self.rows):
2500 		return self.rows[self.pos]
2502 	def FindThread(self):  argument
2503 		if self.direction == 0 or self.value != self.last_value or self.pattern != self.last_pattern:
2504 			row = self.FindValue()
2505 		elif len(self.rows):
2506 			if self.direction > 0:
2507 				self.pos += 1
2508 				if self.pos >= len(self.rows):
2509 					self.pos = 0
2511 				self.pos -= 1
2512 				if self.pos < 0:
2513 					self.pos = len(self.rows) - 1
2514 			row = self.rows[self.pos]
2519 	def Find(self, value, direction, pattern, context, callback):  argument
2520 …self.value, self.direction, self.pattern, self.last_value, self.last_pattern = (value, direction,p…
2522 		thread = Thread(self.FindThread)
2523 …thread.done.connect(lambda row, t=thread, c=callback: self.FindDone(t, c, row), Qt.QueuedConnectio…
2526 	def FindDone(self, thread, callback, row):  argument
2537 …def __init__(self, dbref, sql, buffer, head, tail, fetch_count, fetching_done, process_target, wai…  argument
2540 		self.db, dbname = dbref.Open(conn_name)
2541 		self.sql = sql
2542 		self.buffer = buffer
2543 		self.head = head
2544 		self.tail = tail
2545 		self.fetch_count = fetch_count
2546 		self.fetching_done = fetching_done
2547 		self.process_target = process_target
2548 		self.wait_event = wait_event
2549 		self.fetched_event = fetched_event
2550 		self.prep = prep
2551 		self.query = QSqlQuery(self.db)
2552 		self.query_limit = 0 if "$$last_id$$" in sql else 2
2553 		self.last_id = -1
2554 		self.fetched = 0
2555 		self.more = True
2556 		self.local_head = self.head.value
2557 		self.local_tail = self.tail.value
2559 	def Select(self):  argument
2560 		if self.query_limit:
2561 			if self.query_limit == 1:
2563 			self.query_limit -= 1
2564 		stmt = self.sql.replace("$$last_id$$", str(self.last_id))
2565 		QueryExec(self.query, stmt)
2567 	def Next(self):  argument
2568 		if not self.query.next():
2569 			self.Select()
2570 			if not self.query.next():
2572 		self.last_id = self.query.value(0)
2573 		return self.prep(self.query)
2575 	def WaitForTarget(self):  argument
2577 			self.wait_event.clear()
2578 			target = self.process_target.value
2579 			if target > self.fetched or target < 0:
2581 			self.wait_event.wait()
2584 	def HasSpace(self, sz):  argument
2585 		if self.local_tail <= self.local_head:
2586 			space = len(self.buffer) - self.local_head
2592 				self.buffer[self.local_head : self.local_head + len(nd)] = nd
2593 			self.local_head = 0
2594 		if self.local_tail - self.local_head > sz:
2598 	def WaitForSpace(self, sz):  argument
2599 		if self.HasSpace(sz):
2602 			self.wait_event.clear()
2603 			self.local_tail = self.tail.value
2604 			if self.HasSpace(sz):
2606 			self.wait_event.wait()
2608 	def AddToBuffer(self, obj):  argument
2613 		self.WaitForSpace(sz)
2614 		pos = self.local_head
2615 		self.buffer[pos : pos + len(nd)] = nd
2616 		self.buffer[pos + glb_nsz : pos + sz] = d
2617 		self.local_head += sz
2619 	def FetchBatch(self, batch_size):  argument
2622 			obj = self.Next()
2624 				self.more = False
2626 			self.AddToBuffer(obj)
2629 			self.fetched += fetched
2630 			with self.fetch_count.get_lock():
2631 				self.fetch_count.value += fetched
2632 			self.head.value = self.local_head
2633 			self.fetched_event.set()
2635 	def Run(self):  argument
2636 		while self.more:
2637 			target = self.WaitForTarget()
2640 			batch_size = min(glb_chunk_sz, target - self.fetched)
2641 			self.FetchBatch(batch_size)
2642 		self.fetching_done.value = True
2643 		self.fetched_event.set()
2655 	def __init__(self, glb, sql, prep, process_data, parent=None):  argument
2656 		super(SQLFetcher, self).__init__(parent)
2657 		self.process_data = process_data
2658 		self.more = True
2659 		self.target = 0
2660 		self.last_target = 0
2661 		self.fetched = 0
2662 		self.buffer_size = 16 * 1024 * 1024
2663 		self.buffer = Array(c_char, self.buffer_size, lock=False)
2664 		self.head = Value(c_longlong)
2665 		self.tail = Value(c_longlong)
2666 		self.local_tail = 0
2667 		self.fetch_count = Value(c_longlong)
2668 		self.fetching_done = Value(c_bool)
2669 		self.last_count = 0
2670 		self.process_target = Value(c_longlong)
2671 		self.wait_event = Event()
2672 		self.fetched_event = Event()
2673 		glb.AddInstanceToShutdownOnExit(self)
2674 …self.process = Process(target=SQLFetcherFn, args=(glb.dbref, sql, self.buffer, self.head, self.tai…
2675 		self.process.start()
2676 		self.thread = Thread(self.Thread)
2677 		self.thread.done.connect(self.ProcessData, Qt.QueuedConnection)
2678 		self.thread.start()
2680 	def Shutdown(self):  argument
2682 		self.process_target.value = -1
2683 		self.wait_event.set()
2684 		self.more = False
2685 		self.fetching_done.value = True
2686 		self.fetched_event.set()
2688 	def Thread(self):  argument
2689 		if not self.more:
2692 			self.fetched_event.clear()
2693 			fetch_count = self.fetch_count.value
2694 			if fetch_count != self.last_count:
2696 			if self.fetching_done.value:
2697 				self.more = False
2699 			self.fetched_event.wait()
2700 		count = fetch_count - self.last_count
2701 		self.last_count = fetch_count
2702 		self.fetched += count
2705 	def Fetch(self, nr):  argument
2706 		if not self.more:
2709 		result = self.fetched
2710 		extra = result + nr - self.target
2712 			self.target += extra
2714 			if self.process_target.value >= 0:
2715 				self.process_target.value = self.target
2716 			self.wait_event.set()
2719 	def RemoveFromBuffer(self):  argument
2720 		pos = self.local_tail
2721 		if len(self.buffer) - pos < glb_nsz:
2723 		n = pickle.loads(self.buffer[pos : pos + glb_nsz])
2726 			n = pickle.loads(self.buffer[0 : glb_nsz])
2728 		obj = pickle.loads(self.buffer[pos : pos + n])
2729 		self.local_tail = pos + n
2732 	def ProcessData(self, count):  argument
2734 			obj = self.RemoveFromBuffer()
2735 			self.process_data(obj)
2736 		self.tail.value = self.local_tail
2737 		self.wait_event.set()
2738 		self.done.emit(count)
2744 	def __init__(self, model, parent):  argument
2745 		self.model = model
2747 		self.label = QLabel("Number of records (x " + "{:,}".format(glb_chunk_sz) + ") to fetch:")
2748 		self.label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
2750 		self.fetch_count = QSpinBox()
2751 		self.fetch_count.setRange(1, 1000000)
2752 		self.fetch_count.setValue(10)
2753 		self.fetch_count.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
2755 		self.fetch = QPushButton("Go!")
2756 		self.fetch.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
2757 		self.fetch.released.connect(self.FetchMoreRecords)
2759 		self.progress = QProgressBar()
2760 		self.progress.setRange(0, 100)
2761 		self.progress.hide()
2763 		self.done_label = QLabel("All records fetched")
2764 		self.done_label.hide()
2766 		self.spacer = QLabel("")
2768 		self.close_button = QToolButton()
2769 		self.close_button.setIcon(parent.style().standardIcon(QStyle.SP_DockWidgetCloseButton))
2770 		self.close_button.released.connect(self.Deactivate)
2772 		self.hbox = QHBoxLayout()
2773 		self.hbox.setContentsMargins(0, 0, 0, 0)
2775 		self.hbox.addWidget(self.label)
2776 		self.hbox.addWidget(self.fetch_count)
2777 		self.hbox.addWidget(self.fetch)
2778 		self.hbox.addWidget(self.spacer)
2779 		self.hbox.addWidget(self.progress)
2780 		self.hbox.addWidget(self.done_label)
2781 		self.hbox.addWidget(self.close_button)
2783 		self.bar = QWidget()
2784 		self.bar.setLayout(self.hbox)
2785 		self.bar.show()
2787 		self.in_progress = False
2788 		self.model.progress.connect(self.Progress)
2790 		self.done = False
2793 			self.Done()
2795 	def Widget(self):  argument
2796 		return self.bar
2798 	def Activate(self):  argument
2799 		self.bar.show()
2800 		self.fetch.setFocus()
2802 	def Deactivate(self):  argument
2803 		self.bar.hide()
2805 	def Enable(self, enable):  argument
2806 		self.fetch.setEnabled(enable)
2807 		self.fetch_count.setEnabled(enable)
2809 	def Busy(self):  argument
2810 		self.Enable(False)
2811 		self.fetch.hide()
2812 		self.spacer.hide()
2813 		self.progress.show()
2815 	def Idle(self):  argument
2816 		self.in_progress = False
2817 		self.Enable(True)
2818 		self.progress.hide()
2819 		self.fetch.show()
2820 		self.spacer.show()
2822 	def Target(self):  argument
2823 		return self.fetch_count.value() * glb_chunk_sz
2825 	def Done(self):  argument
2826 		self.done = True
2827 		self.Idle()
2828 		self.label.hide()
2829 		self.fetch_count.hide()
2830 		self.fetch.hide()
2831 		self.spacer.hide()
2832 		self.done_label.show()
2834 	def Progress(self, count):  argument
2835 		if self.in_progress:
2837 				percent = ((count - self.start) * 100) / self.Target()
2839 					self.Idle()
2841 					self.progress.setValue(percent)
2844 			self.Done()
2846 	def FetchMoreRecords(self):  argument
2847 		if self.done:
2849 		self.progress.setValue(0)
2850 		self.Busy()
2851 		self.in_progress = True
2852 		self.start = self.model.FetchMoreRecords(self.Target())
2858 	def __init__(self, row, col, text, parent_item):  argument
2859 		self.row = row
2860 		self.parent_item = parent_item
2861 		self.data = [""] * (col + 1)
2862 		self.data[col] = text
2863 		self.level = 2
2865 	def getParentItem(self):  argument
2866 		return self.parent_item
2868 	def getRow(self):  argument
2869 		return self.row
2871 	def childCount(self):  argument
2874 	def hasChildren(self):  argument
2877 	def getData(self, column):  argument
2878 		return self.data[column]
2884 	def __init__(self, glb, row, data, parent_item):  argument
2885 		self.glb = glb
2886 		self.row = row
2887 		self.parent_item = parent_item
2888 		self.child_count = 0
2889 		self.child_items = []
2890 		self.data = data[1:]
2891 		self.dbid = data[0]
2892 		self.level = 1
2893 		self.query_done = False
2894 		self.br_col = len(self.data) - 1
2896 	def getChildItem(self, row):  argument
2897 		return self.child_items[row]
2899 	def getParentItem(self):  argument
2900 		return self.parent_item
2902 	def getRow(self):  argument
2903 		return self.row
2905 	def Select(self):  argument
2906 		self.query_done = True
2908 		if not self.glb.have_disassembler:
2911 		query = QSqlQuery(self.glb.db)
2917 				  " WHERE samples.id = " + str(self.dbid))
2935 				  " WHERE samples.id > " + str(self.dbid) + " AND cpu = " + str(cpu) +
2952 		inst = self.glb.disassembler.Instruction()
2953 		f = self.glb.FileFromNamesAndBuildId(short_name, long_name, build_id)
2957 		self.glb.disassembler.SetMode(inst, mode)
2966 			cnt, text = self.glb.disassembler.DisassembleOne(inst, buf_ptr, buf_sz, ip)
2975 				self.child_items.append(BranchLevelTwoItem(0, self.br_col, byte_str + " " + text, self))
2976 				self.child_count += 1
2984 	def childCount(self):  argument
2985 		if not self.query_done:
2986 			self.Select()
2987 			if not self.child_count:
2989 		return self.child_count
2991 	def hasChildren(self):  argument
2992 		if not self.query_done:
2994 		return self.child_count > 0
2996 	def getData(self, column):  argument
2997 		return self.data[column]
3003 	def __init__(self):  argument
3004 		self.child_count = 0
3005 		self.child_items = []
3006 		self.level = 0
3008 	def getChildItem(self, row):  argument
3009 		return self.child_items[row]
3011 	def getParentItem(self):  argument
3014 	def getRow(self):  argument
3017 	def childCount(self):  argument
3018 		return self.child_count
3020 	def hasChildren(self):  argument
3021 		return self.child_count > 0
3023 	def getData(self, column):  argument
3094 	def __init__(self, glb, event_id, where_clause, parent=None):  argument
3095 		super(BranchModel, self).__init__(glb, None, parent)
3096 		self.event_id = event_id
3097 		self.more = True
3098 		self.populated = 0
3099 		self.have_ipc = IsSelectable(glb.db, "samples", columns = "insn_count, cyc_count")
3100 		if self.have_ipc:
3122 			" AND evsel_id = " + str(self.event_id) +
3129 		self.fetcher = SQLFetcher(glb, sql, prep, self.AddSample)
3130 		self.fetcher.done.connect(self.Update)
3131 		self.fetcher.Fetch(glb_chunk_sz)
3133 	def GetRoot(self):  argument
3136 	def columnCount(self, parent=None):  argument
3137 		if self.have_ipc:
3142 	def columnHeader(self, column):  argument
3143 		if self.have_ipc:
3148 	def columnFont(self, column):  argument
3149 		if self.have_ipc:
3157 	def DisplayData(self, item, index):  argument
3159 			self.FetchIfNeeded(item.row)
3162 	def AddSample(self, data):  argument
3163 		child = BranchLevelOneItem(self.glb, self.populated, data, self.root)
3164 		self.root.child_items.append(child)
3165 		self.populated += 1
3167 	def Update(self, fetched):  argument
3169 			self.more = False
3170 			self.progress.emit(0)
3171 		child_count = self.root.child_count
3172 		count = self.populated - child_count
3175 			self.beginInsertRows(parent, child_count, child_count + count - 1)
3176 			self.insertRows(child_count, count, parent)
3177 			self.root.child_count += count
3178 			self.endInsertRows()
3179 			self.progress.emit(self.root.child_count)
3181 	def FetchMoreRecords(self, count):  argument
3182 		current = self.root.child_count
3183 		if self.more:
3184 			self.fetcher.Fetch(count)
3186 			self.progress.emit(0)
3189 	def HasMoreRecords(self):  argument
3190 		return self.more
3196 	def __init__(self, name = "", where_clause = "", limit = ""):  argument
3197 		self.name = name
3198 		self.where_clause = where_clause
3199 		self.limit = limit
3201 	def UniqueId(self):  argument
3202 		return str(self.where_clause + ";" + self.limit)
3208 	def __init__(self, glb, event_id, report_vars, parent=None):  argument
3209 		super(BranchWindow, self).__init__(parent)
3213 …self.model = LookupCreateModel(model_name, lambda: BranchModel(glb, event_id, report_vars.where_cl…
3215 		self.view = QTreeView()
3216 		self.view.setUniformRowHeights(True)
3217 		self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
3218 		self.view.CopyCellsToClipboard = CopyTreeCellsToClipboard
3219 		self.view.setModel(self.model)
3221 		self.ResizeColumnsToContents()
3223 		self.context_menu = TreeContextMenu(self.view)
3225 		self.find_bar = FindBar(self, self, True)
3227 		self.finder = ChildDataItemFinder(self.model.root)
3229 		self.fetch_bar = FetchMoreRecordsBar(self.model, self)
3231 		self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())
3233 		self.setWidget(self.vbox.Widget())
3235 		AddSubWindow(glb.mainwindow.mdi_area, self, report_vars.name + " Branch Events")
3237 	def ResizeColumnToContents(self, column, n):  argument
3241 		font = self.view.font()
3245 			val = self.model.root.child_items[row].data[column]
3248 		val = self.model.columnHeader(column)
3251 		self.view.setColumnWidth(column, max)
3253 	def ResizeColumnsToContents(self):  argument
3254 		n = min(self.model.root.child_count, 100)
3257 			self.model.rowsInserted.connect(self.UpdateColumnWidths)
3259 		columns = self.model.columnCount()
3261 			self.ResizeColumnToContents(i, n)
3263 	def UpdateColumnWidths(self, *x):  argument
3265 		self.model.rowsInserted.disconnect(self.UpdateColumnWidths)
3266 		self.ResizeColumnsToContents()
3268 	def Find(self, value, direction, pattern, context):  argument
3269 		self.view.setFocus()
3270 		self.find_bar.Busy()
3271 		self.finder.Find(value, direction, pattern, context, self.FindDone)
3273 	def FindDone(self, row):  argument
3274 		self.find_bar.Idle()
3276 			self.view.setCurrentIndex(self.model.index(row, 0, QModelIndex()))
3278 			self.find_bar.NotFound()
3284 	def __init__(self, glb, label, placeholder_text, parent, id = "", default = ""):  argument
3285 		self.glb = glb
3286 		self.label = label
3287 		self.placeholder_text = placeholder_text
3288 		self.parent = parent
3289 		self.id = id
3291 		self.value = default
3293 		self.widget = QLineEdit(default)
3294 		self.widget.editingFinished.connect(self.Validate)
3295 		self.widget.textChanged.connect(self.Invalidate)
3296 		self.red = False
3297 		self.error = ""
3298 		self.validated = True
3301 			self.widget.setPlaceholderText(placeholder_text)
3303 	def TurnTextRed(self):  argument
3304 		if not self.red:
3307 			self.widget.setPalette(palette)
3308 			self.red = True
3310 	def TurnTextNormal(self):  argument
3311 		if self.red:
3313 			self.widget.setPalette(palette)
3314 			self.red = False
3316 	def InvalidValue(self, value):  argument
3317 		self.value = ""
3318 		self.TurnTextRed()
3319 		self.error = self.label + " invalid value '" + value + "'"
3320 		self.parent.ShowMessage(self.error)
3322 	def Invalidate(self):  argument
3323 		self.validated = False
3325 	def DoValidate(self, input_string):  argument
3326 		self.value = input_string.strip()
3328 	def Validate(self):  argument
3329 		self.validated = True
3330 		self.error = ""
3331 		self.TurnTextNormal()
3332 		self.parent.ClearMessage()
3333 		input_string = self.widget.text()
3335 			self.value = ""
3337 		self.DoValidate(input_string)
3339 	def IsValid(self):  argument
3340 		if not self.validated:
3341 			self.Validate()
3342 		if len(self.error):
3343 			self.parent.ShowMessage(self.error)
3347 	def IsNumber(self, value):  argument
3358 	def __init__(self, glb, label, placeholder_text, column_name, parent):  argument
3359 		super(NonNegativeIntegerRangesDataItem, self).__init__(glb, label, placeholder_text, parent)
3361 		self.column_name = column_name
3363 	def DoValidate(self, input_string):  argument
3369 				if len(vrange) != 2 or not self.IsNumber(vrange[0]) or not self.IsNumber(vrange[1]):
3370 					return self.InvalidValue(value)
3373 				if not self.IsNumber(value):
3374 					return self.InvalidValue(value)
3376 …ranges = [("(" + self.column_name + " >= " + r[0] + " AND " + self.column_name + " <= " + r[1] + "…
3378 			ranges.append(self.column_name + " IN (" + ",".join(singles) + ")")
3379 		self.value = " OR ".join(ranges)
3385 	def __init__(self, glb, label, placeholder_text, parent, id = "", default = ""):  argument
3386 		super(PositiveIntegerDataItem, self).__init__(glb, label, placeholder_text, parent, id, default)
3388 	def DoValidate(self, input_string):  argument
3389 		if not self.IsNumber(input_string.strip()):
3390 			return self.InvalidValue(input_string)
3393 			return self.InvalidValue(input_string)
3394 		self.value = str(value)
3400 …def __init__(self, glb, label, placeholder_text, table_name, match_column, column_name1, column_na…  argument
3401 		super(SQLTableDataItem, self).__init__(glb, label, placeholder_text, parent)
3403 		self.table_name = table_name
3404 		self.match_column = match_column
3405 		self.column_name1 = column_name1
3406 		self.column_name2 = column_name2
3408 	def ValueToIds(self, value):  argument
3410 		query = QSqlQuery(self.glb.db)
3411 		stmt = "SELECT id FROM " + self.table_name + " WHERE " + self.match_column + " = '" + value + "'"
3418 	def DoValidate(self, input_string):  argument
3421 			ids = self.ValueToIds(value)
3425 				return self.InvalidValue(value)
3426 		self.value = self.column_name1 + " IN (" + ",".join(all_ids) + ")"
3427 		if self.column_name2:
3428 			self.value = "( " + self.value + " OR " + self.column_name2 + " IN (" + ",".join(all_ids) + ") )"
3434 	def __init__(self, glb, label, placeholder_text, column_name, parent):  argument
3435 		self.column_name = column_name
3437 		self.last_id = 0
3438 		self.first_time = 0
3439 		self.last_time = 2 ** 64
3444 			self.last_id = int(query.value(0))
3445 		self.first_time = int(glb.HostStartTime())
3446 		self.last_time = int(glb.HostFinishTime())
3448 			placeholder_text += ", between " + str(self.first_time) + " and " + str(self.last_time)
3450 		super(SampleTimeRangesDataItem, self).__init__(glb, label, placeholder_text, parent)
3452 	def IdBetween(self, query, lower_id, higher_id, order):  argument
3459 	def BinarySearchTime(self, lower_id, higher_id, target_time, get_floor):  argument
3460 		query = QSqlQuery(self.glb.db)
3465 				ok, dbid = self.IdBetween(query, lower_id, next_id, "DESC")
3467 					ok, dbid = self.IdBetween(query, next_id, higher_id, "")
3488 	def ConvertRelativeTime(self, val):  argument
3500 		if not self.IsNumber(val):
3504 			val += self.first_time
3506 			val += self.last_time
3509 	def ConvertTimeRange(self, vrange):  argument
3511 			vrange[0] = str(self.first_time)
3513 			vrange[1] = str(self.last_time)
3514 		vrange[0] = self.ConvertRelativeTime(vrange[0])
3515 		vrange[1] = self.ConvertRelativeTime(vrange[1])
3516 		if not self.IsNumber(vrange[0]) or not self.IsNumber(vrange[1]):
3518 		beg_range = max(int(vrange[0]), self.first_time)
3519 		end_range = min(int(vrange[1]), self.last_time)
3520 		if beg_range > self.last_time or end_range < self.first_time:
3522 		vrange[0] = self.BinarySearchTime(0, self.last_id, beg_range, True)
3523 		vrange[1] = self.BinarySearchTime(1, self.last_id + 1, end_range, False)
3526 	def AddTimeRange(self, value, ranges):  argument
3539 		if self.ConvertTimeRange(vrange):
3544 	def DoValidate(self, input_string):  argument
3547 			if not self.AddTimeRange(value, ranges):
3548 				return self.InvalidValue(value)
3549 …ranges = [("(" + self.column_name + " >= " + r[0] + " AND " + self.column_name + " <= " + r[1] + "…
3550 		self.value = " OR ".join(ranges)
3556 	def __init__(self, glb, title, items, partial, parent=None):  argument
3557 		super(ReportDialogBase, self).__init__(parent)
3559 		self.glb = glb
3561 		self.report_vars = ReportVars()
3563 		self.setWindowTitle(title)
3564 		self.setMinimumWidth(600)
3566 		self.data_items = [x(glb, self) for x in items]
3568 		self.partial = partial
3570 		self.grid = QGridLayout()
3572 		for row in xrange(len(self.data_items)):
3573 			self.grid.addWidget(QLabel(self.data_items[row].label), row, 0)
3574 			self.grid.addWidget(self.data_items[row].widget, row, 1)
3576 		self.status = QLabel()
3578 		self.ok_button = QPushButton("Ok", self)
3579 		self.ok_button.setDefault(True)
3580 		self.ok_button.released.connect(self.Ok)
3581 		self.ok_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
3583 		self.cancel_button = QPushButton("Cancel", self)
3584 		self.cancel_button.released.connect(self.reject)
3585 		self.cancel_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
3587 		self.hbox = QHBoxLayout()
3589 		self.hbox.addWidget(self.status)
3590 		self.hbox.addWidget(self.ok_button)
3591 		self.hbox.addWidget(self.cancel_button)
3593 		self.vbox = QVBoxLayout()
3594 		self.vbox.addLayout(self.grid)
3595 		self.vbox.addLayout(self.hbox)
3597 		self.setLayout(self.vbox)
3599 	def Ok(self):  argument
3600 		vars = self.report_vars
3601 		for d in self.data_items:
3605 			self.ShowMessage("Report name is required")
3607 		for d in self.data_items:
3610 		for d in self.data_items[1:]:
3618 			if self.partial:
3622 		self.accept()
3624 	def ShowMessage(self, msg):  argument
3625 		self.status.setText("<font color=#FF0000>" + msg)
3627 	def ClearMessage(self):  argument
3628 		self.status.setText("")
3634 	def __init__(self, glb, parent=None):  argument
3645 		super(SelectedBranchDialog, self).__init__(glb, title, items, True, parent)
3671 	def __init__(self, row, data):  argument
3672 		self.row = row
3673 		self.data = data
3675 	def getData(self, column):  argument
3676 		return self.data[column]
3684 	def __init__(self, glb, sql, column_headers, parent=None):  argument
3685 		super(SQLTableModel, self).__init__(parent)
3686 		self.glb = glb
3687 		self.more = True
3688 		self.populated = 0
3689 		self.column_headers = column_headers
3690 …self.fetcher = SQLFetcher(glb, sql, lambda x, y=len(column_headers): self.SQLTableDataPrep(x, y), …
3691 		self.fetcher.done.connect(self.Update)
3692 		self.fetcher.Fetch(glb_chunk_sz)
3694 	def DisplayData(self, item, index):  argument
3695 		self.FetchIfNeeded(item.row)
3698 	def AddSample(self, data):  argument
3699 		child = SQLTableItem(self.populated, data)
3700 		self.child_items.append(child)
3701 		self.populated += 1
3703 	def Update(self, fetched):  argument
3705 			self.more = False
3706 			self.progress.emit(0)
3707 		child_count = self.child_count
3708 		count = self.populated - child_count
3711 			self.beginInsertRows(parent, child_count, child_count + count - 1)
3712 			self.insertRows(child_count, count, parent)
3713 			self.child_count += count
3714 			self.endInsertRows()
3715 			self.progress.emit(self.child_count)
3717 	def FetchMoreRecords(self, count):  argument
3718 		current = self.child_count
3719 		if self.more:
3720 			self.fetcher.Fetch(count)
3722 			self.progress.emit(0)
3725 	def HasMoreRecords(self):  argument
3726 		return self.more
3728 	def columnCount(self, parent=None):  argument
3729 		return len(self.column_headers)
3731 	def columnHeader(self, column):  argument
3732 		return self.column_headers[column]
3734 	def SQLTableDataPrep(self, query, count):  argument
3744 	def __init__(self, glb, table_name, parent=None):  argument
3770 				self.SQLTableDataPrep = self.samples_view_DataPrep
3772 				self.SQLTableDataPrep = self.samples_DataPrep
3773 		super(SQLAutoTableModel, self).__init__(glb, sql, column_headers, parent)
3775 	def samples_view_DataPrep(self, query, count):  argument
3784 	def samples_DataPrep(self, query, count):  argument
3798 	def __init__(self, parent=None):  argument
3799 		super(ResizeColumnsToContentsBase, self).__init__(parent)
3801 	def ResizeColumnToContents(self, column, n):  argument
3804 		font = self.view.font()
3808 			val = self.data_model.child_items[row].data[column]
3811 		val = self.data_model.columnHeader(column)
3814 		self.view.setColumnWidth(column, max)
3816 	def ResizeColumnsToContents(self):  argument
3817 		n = min(self.data_model.child_count, 100)
3820 			self.data_model.rowsInserted.connect(self.UpdateColumnWidths)
3822 		columns = self.data_model.columnCount()
3824 			self.ResizeColumnToContents(i, n)
3826 	def UpdateColumnWidths(self, *x):  argument
3828 		self.data_model.rowsInserted.disconnect(self.UpdateColumnWidths)
3829 		self.ResizeColumnsToContents()
4036 	def __init__(self, view):  argument
4037 		self.view = view
4038 		self.view.setContextMenuPolicy(Qt.CustomContextMenu)
4039 		self.view.customContextMenuRequested.connect(self.ShowContextMenu)
4041 	def ShowContextMenu(self, pos):  argument
4042 		menu = QMenu(self.view)
4043 		self.AddActions(menu)
4044 		menu.exec_(self.view.mapToGlobal(pos))
4046 	def AddCopy(self, menu):  argument
4047 …ion("&Copy selection", "Copy to clipboard", lambda: CopyCellsToClipboardHdr(self.view), self.view))
4048 …ction as CS&V", "Copy to clipboard as CSV", lambda: CopyCellsToClipboardCSV(self.view), self.view))
4050 	def AddActions(self, menu):  argument
4051 		self.AddCopy(menu)
4055 	def __init__(self, view):  argument
4056 		super(TreeContextMenu, self).__init__(view)
4058 	def AddActions(self, menu):  argument
4059 		i = self.view.currentIndex()
4062 …y "' + text + '"', "Copy to clipboard", lambda: QApplication.clipboard().setText(text), self.view))
4063 		self.AddCopy(menu)
4069 	def __init__(self, glb, table_name, parent=None):  argument
4070 		super(TableWindow, self).__init__(parent)
4072 …self.data_model = LookupCreateModel(table_name + " Table", lambda: SQLAutoTableModel(glb, table_na…
4074 		self.model = QSortFilterProxyModel()
4075 		self.model.setSourceModel(self.data_model)
4077 		self.view = QTableView()
4078 		self.view.setModel(self.model)
4079 		self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
4080 		self.view.verticalHeader().setVisible(False)
4081 		self.view.sortByColumn(-1, Qt.AscendingOrder)
4082 		self.view.setSortingEnabled(True)
4083 		self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
4084 		self.view.CopyCellsToClipboard = CopyTableCellsToClipboard
4086 		self.ResizeColumnsToContents()
4088 		self.context_menu = ContextMenu(self.view)
4090 		self.find_bar = FindBar(self, self, True)
4092 		self.finder = ChildDataItemFinder(self.data_model)
4094 		self.fetch_bar = FetchMoreRecordsBar(self.data_model, self)
4096 		self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())
4098 		self.setWidget(self.vbox.Widget())
4100 		AddSubWindow(glb.mainwindow.mdi_area, self, table_name + " Table")
4102 	def Find(self, value, direction, pattern, context):  argument
4103 		self.view.setFocus()
4104 		self.find_bar.Busy()
4105 		self.finder.Find(value, direction, pattern, context, self.FindDone)
4107 	def FindDone(self, row):  argument
4108 		self.find_bar.Idle()
4110 			self.view.setCurrentIndex(self.model.mapFromSource(self.data_model.index(row, 0, QModelIndex())))
4112 			self.find_bar.NotFound()
4137 	def __init__(self, glb, report_vars, parent=None):  argument
4167 …self.alignment = (Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLe…
4168 		super(TopCallsModel, self).__init__(glb, sql, column_headers, parent)
4170 	def columnAlignment(self, column):  argument
4171 		return self.alignment[column]
4177 	def __init__(self, glb, parent=None):  argument
4187 		super(TopCallsDialog, self).__init__(glb, title, items, False, parent)
4193 	def __init__(self, glb, report_vars, parent=None):  argument
4194 		super(TopCallsWindow, self).__init__(parent)
4196 …self.data_model = LookupCreateModel("Top Calls " + report_vars.UniqueId(), lambda: TopCallsModel(g…
4197 		self.model = self.data_model
4199 		self.view = QTableView()
4200 		self.view.setModel(self.model)
4201 		self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
4202 		self.view.verticalHeader().setVisible(False)
4203 		self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
4204 		self.view.CopyCellsToClipboard = CopyTableCellsToClipboard
4206 		self.context_menu = ContextMenu(self.view)
4208 		self.ResizeColumnsToContents()
4210 		self.find_bar = FindBar(self, self, True)
4212 		self.finder = ChildDataItemFinder(self.model)
4214 		self.fetch_bar = FetchMoreRecordsBar(self.data_model, self)
4216 		self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())
4218 		self.setWidget(self.vbox.Widget())
4220 		AddSubWindow(glb.mainwindow.mdi_area, self, report_vars.name)
4222 	def Find(self, value, direction, pattern, context):  argument
4223 		self.view.setFocus()
4224 		self.find_bar.Busy()
4225 		self.finder.Find(value, direction, pattern, context, self.FindDone)
4227 	def FindDone(self, row):  argument
4228 		self.find_bar.Idle()
4230 			self.view.setCurrentIndex(self.model.index(row, 0, QModelIndex()))
4232 			self.find_bar.NotFound()
4273 	def __init__(self, mdi_area, menu):  argument
4274 		self.mdi_area = mdi_area
4275 		self.window_menu = menu.addMenu("&Windows")
4276 		self.close_active_window = CreateCloseActiveWindowAction(mdi_area)
4277 		self.close_all_windows = CreateCloseAllWindowsAction(mdi_area)
4278 		self.tile_windows = CreateTileWindowsAction(mdi_area)
4279 		self.cascade_windows = CreateCascadeWindowsAction(mdi_area)
4280 		self.next_window = CreateNextWindowAction(mdi_area)
4281 		self.previous_window = CreatePreviousWindowAction(mdi_area)
4282 		self.window_menu.aboutToShow.connect(self.Update)
4284 	def Update(self):  argument
4285 		self.window_menu.clear()
4286 		sub_window_count = len(self.mdi_area.subWindowList())
4288 		self.close_active_window.setEnabled(have_sub_windows)
4289 		self.close_all_windows.setEnabled(have_sub_windows)
4290 		self.tile_windows.setEnabled(have_sub_windows)
4291 		self.cascade_windows.setEnabled(have_sub_windows)
4292 		self.next_window.setEnabled(have_sub_windows)
4293 		self.previous_window.setEnabled(have_sub_windows)
4294 		self.window_menu.addAction(self.close_active_window)
4295 		self.window_menu.addAction(self.close_all_windows)
4296 		self.window_menu.addSeparator()
4297 		self.window_menu.addAction(self.tile_windows)
4298 		self.window_menu.addAction(self.cascade_windows)
4299 		self.window_menu.addSeparator()
4300 		self.window_menu.addAction(self.next_window)
4301 		self.window_menu.addAction(self.previous_window)
4304 		self.window_menu.addSeparator()
4306 		for sub_window in self.mdi_area.subWindowList():
4310 			action = self.window_menu.addAction(label)
4312 			action.setChecked(sub_window == self.mdi_area.activeSubWindow())
4313 			action.triggered.connect(lambda a=None,x=nr: self.setActiveSubWindow(x))
4314 			self.window_menu.addAction(action)
4317 	def setActiveSubWindow(self, nr):  argument
4318 		self.mdi_area.setActiveSubWindow(self.mdi_area.subWindowList()[nr - 1])
4471 	def __init__(self, glb, parent=None):  argument
4472 		super(HelpWindow, self).__init__(parent)
4474 		self.text = QTextBrowser()
4475 		self.text.setHtml(glb_help_text)
4476 		self.text.setReadOnly(True)
4477 		self.text.setOpenExternalLinks(True)
4479 		self.setWidget(self.text)
4481 		AddSubWindow(glb.mainwindow.mdi_area, self, "Exported SQL Viewer Help")
4487 	def __init__(self, parent=None):  argument
4488 		super(HelpOnlyWindow, self).__init__(parent)
4490 		self.setMinimumSize(200, 100)
4491 		self.resize(800, 600)
4492 		self.setWindowTitle("Exported SQL Viewer Help")
4493 		self.setWindowIcon(self.style().standardIcon(QStyle.SP_MessageBoxInformation))
4495 		self.text = QTextBrowser()
4496 		self.text.setHtml(glb_help_text)
4497 		self.text.setReadOnly(True)
4498 		self.text.setOpenExternalLinks(True)
4500 		self.setCentralWidget(self.text)
4528 	def __init__(self, glb, parent=None):  argument
4529 		super(AboutDialog, self).__init__(parent)
4531 		self.setWindowTitle("About Exported SQL Viewer")
4532 		self.setMinimumWidth(300)
4546 		self.text = QTextBrowser()
4547 		self.text.setHtml(text)
4548 		self.text.setReadOnly(True)
4549 		self.text.setOpenExternalLinks(True)
4551 		self.vbox = QVBoxLayout()
4552 		self.vbox.addWidget(self.text)
4554 		self.setLayout(self.vbox)
4607 	def __init__(self, glb, parent=None):  argument
4608 		super(MainWindow, self).__init__(parent)
4610 		self.glb = glb
4612 		self.setWindowTitle("Exported SQL Viewer: " + glb.dbname)
4613 		self.setWindowIcon(self.style().standardIcon(QStyle.SP_ComputerIcon))
4614 		self.setMinimumSize(200, 100)
4616 		self.mdi_area = QMdiArea()
4617 		self.mdi_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
4618 		self.mdi_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
4620 		self.setCentralWidget(self.mdi_area)
4622 		menu = self.menuBar()
4625 		file_menu.addAction(CreateExitAction(glb.app, self))
4628 …edit_menu.addAction(CreateAction("&Copy", "Copy to clipboard", self.CopyToClipboard, self, QKeySeq…
4629 ….addAction(CreateAction("Copy as CS&V", "Copy to clipboard as CSV", self.CopyToClipboardCSV, self))
4630 		edit_menu.addAction(CreateAction("&Find...", "Find items", self.Find, self, QKeySequence.Find))
4631 …n(CreateAction("Fetch &more records...", "Fetch more records", self.FetchMoreRecords, self, [QKeyS…
4632 …edit_menu.addAction(CreateAction("&Shrink Font", "Make text smaller", self.ShrinkFont, self, [QKey…
4633 …edit_menu.addAction(CreateAction("&Enlarge Font", "Make text bigger", self.EnlargeFont, self, [QKe…
4637 …&Graph", "Create a new window containing a context-sensitive call graph", self.NewCallGraph, self))
4640 …n(CreateAction("Call &Tree", "Create a new window containing a call tree", self.NewCallTree, self))
4642 		self.EventMenu(GetEventList(glb.db), reports_menu)
4645 …elapsed time", "Create a new window displaying top calls by elapsed time", self.NewTopCalls, self))
4649 …ime chart by CPU", "Create a new window displaying time charts by CPU", self.TimeChartByCPU, self))
4651 		self.TableMenu(GetTableList(glb), menu)
4653 		self.window_menu = WindowMenu(self.mdi_area, menu)
4656 …ion(CreateAction("&Exported SQL Viewer Help", "Helpful information", self.Help, self, QKeySequence…
4657 …u.addAction(CreateAction("&About Exported SQL Viewer", "About this application", self.About, self))
4659 	def Try(self, fn):  argument
4660 		win = self.mdi_area.activeSubWindow()
4667 	def CopyToClipboard(self):  argument
4668 		self.Try(CopyCellsToClipboardHdr)
4670 	def CopyToClipboardCSV(self):  argument
4671 		self.Try(CopyCellsToClipboardCSV)
4673 	def Find(self):  argument
4674 		win = self.mdi_area.activeSubWindow()
4681 	def FetchMoreRecords(self):  argument
4682 		win = self.mdi_area.activeSubWindow()
4689 	def ShrinkFont(self):  argument
4690 		self.Try(ShrinkFont)
4692 	def EnlargeFont(self):  argument
4693 		self.Try(EnlargeFont)
4695 	def EventMenu(self, events, reports_menu):  argument
4707 …"Create a new window displaying branch events", lambda a=None,x=dbid: self.NewBranchView(x), self))
4709 …a new window displaying branch events", lambda a=None,x=dbid: self.NewSelectedBranchView(x), self))
4711 	def TimeChartByCPU(self):  argument
4712 		TimeChartByCPUWindow(self.glb, self)
4714 	def TableMenu(self, tables, menu):  argument
4717 … "Create a new window containing a table view", lambda a=None,t=table: self.NewTableView(t), self))
4719 	def NewCallGraph(self):  argument
4720 		CallGraphWindow(self.glb, self)
4722 	def NewCallTree(self):  argument
4723 		CallTreeWindow(self.glb, self)
4725 	def NewTopCalls(self):  argument
4726 		dialog = TopCallsDialog(self.glb, self)
4729 			TopCallsWindow(self.glb, dialog.report_vars, self)
4731 	def NewBranchView(self, event_id):  argument
4732 		BranchWindow(self.glb, event_id, ReportVars(), self)
4734 	def NewSelectedBranchView(self, event_id):  argument
4735 		dialog = SelectedBranchDialog(self.glb, self)
4738 			BranchWindow(self.glb, event_id, dialog.report_vars, self)
4740 	def NewTableView(self, table_name):  argument
4741 		TableWindow(self.glb, table_name, self)
4743 	def Help(self):  argument
4744 		HelpWindow(self.glb, self)
4746 	def About(self):  argument
4747 		dialog = AboutDialog(self.glb, self)
4761 	def __init__(self, libxed):  argument
4764 		self.xedd = xedd_t()
4765 		self.xedp = addressof(self.xedd)
4766 		libxed.xed_decoded_inst_zero(self.xedp)
4767 		self.state = xed_state_t()
4768 		self.statep = addressof(self.state)
4770 		self.buffer = create_string_buffer(256)
4771 		self.bufferp = addressof(self.buffer)
4775 	def __init__(self):  argument
4777 			self.libxed = CDLL("libxed.so")
4779 			self.libxed = None
4780 		if not self.libxed:
4781 			self.libxed = CDLL("/usr/local/lib/libxed.so")
4783 		self.xed_tables_init = self.libxed.xed_tables_init
4784 		self.xed_tables_init.restype = None
4785 		self.xed_tables_init.argtypes = []
4787 		self.xed_decoded_inst_zero = self.libxed.xed_decoded_inst_zero
4788 		self.xed_decoded_inst_zero.restype = None
4789 		self.xed_decoded_inst_zero.argtypes = [ c_void_p ]
4791 		self.xed_operand_values_set_mode = self.libxed.xed_operand_values_set_mode
4792 		self.xed_operand_values_set_mode.restype = None
4793 		self.xed_operand_values_set_mode.argtypes = [ c_void_p, c_void_p ]
4795 		self.xed_decoded_inst_zero_keep_mode = self.libxed.xed_decoded_inst_zero_keep_mode
4796 		self.xed_decoded_inst_zero_keep_mode.restype = None
4797 		self.xed_decoded_inst_zero_keep_mode.argtypes = [ c_void_p ]
4799 		self.xed_decode = self.libxed.xed_decode
4800 		self.xed_decode.restype = c_int
4801 		self.xed_decode.argtypes = [ c_void_p, c_void_p, c_uint ]
4803 		self.xed_format_context = self.libxed.xed_format_context
4804 		self.xed_format_context.restype = c_uint
4805 …self.xed_format_context.argtypes = [ c_int, c_void_p, c_void_p, c_int, c_ulonglong, c_void_p, c_vo…
4807 		self.xed_tables_init()
4809 	def Instruction(self):  argument
4810 		return XEDInstruction(self)
4812 	def SetMode(self, inst, mode):  argument
4819 		self.xed_operand_values_set_mode(inst.xedp, inst.statep)
4821 	def DisassembleOne(self, inst, bytes_ptr, bytes_cnt, ip):  argument
4822 		self.xed_decoded_inst_zero_keep_mode(inst.xedp)
4823 		err = self.xed_decode(inst.xedp, bytes_ptr, bytes_cnt)
4827 		ok = self.xed_format_context(2, inst.xedp, inst.bufferp, sizeof(inst.buffer), ip, 0, 0)
4868 	def __init__(self, dbref, db, dbname):  argument
4869 		self.dbref = dbref
4870 		self.db = db
4871 		self.dbname = dbname
4872 		self.home_dir = os.path.expanduser("~")
4873 		self.buildid_dir = os.getenv("PERF_BUILDID_DIR")
4874 		if self.buildid_dir:
4875 			self.buildid_dir += "/.build-id/"
4877 			self.buildid_dir = self.home_dir + "/.debug/.build-id/"
4878 		self.app = None
4879 		self.mainwindow = None
4880 		self.instances_to_shutdown_on_exit = weakref.WeakSet()
4882 			self.disassembler = LibXED()
4883 			self.have_disassembler = True
4885 			self.have_disassembler = False
4886 		self.host_machine_id = 0
4887 		self.host_start_time = 0
4888 		self.host_finish_time = 0
4890 	def FileFromBuildId(self, build_id):  argument
4891 		file_name = self.buildid_dir + build_id[0:2] + "/" + build_id[2:] + "/elf"
4894 	def FileFromNamesAndBuildId(self, short_name, long_name, build_id):  argument
4905 		f = self.FileFromBuildId(build_id)
4910 	def AddInstanceToShutdownOnExit(self, instance):  argument
4911 		self.instances_to_shutdown_on_exit.add(instance)
4914 	def ShutdownInstances(self):  argument
4915 		for x in self.instances_to_shutdown_on_exit:
4921 	def GetHostMachineId(self):  argument
4922 		query = QSqlQuery(self.db)
4925 			self.host_machine_id = query.value(0)
4927 			self.host_machine_id = 0
4928 		return self.host_machine_id
4930 	def HostMachineId(self):  argument
4931 		if self.host_machine_id:
4932 			return self.host_machine_id
4933 		return self.GetHostMachineId()
4935 	def SelectValue(self, sql):  argument
4936 		query = QSqlQuery(self.db)
4945 	def SwitchesMinTime(self, machine_id):  argument
4946 		return self.SelectValue("SELECT time"
4951 	def SwitchesMaxTime(self, machine_id):  argument
4952 		return self.SelectValue("SELECT time"
4957 	def SamplesMinTime(self, machine_id):  argument
4958 		return self.SelectValue("SELECT time"
4963 	def SamplesMaxTime(self, machine_id):  argument
4964 		return self.SelectValue("SELECT time"
4969 	def CallsMinTime(self, machine_id):  argument
4970 		return self.SelectValue("SELECT calls.call_time"
4976 	def CallsMaxTime(self, machine_id):  argument
4977 		return self.SelectValue("SELECT calls.return_time"
4983 	def GetStartTime(self, machine_id):  argument
4984 		t0 = self.SwitchesMinTime(machine_id)
4985 		t1 = self.SamplesMinTime(machine_id)
4986 		t2 = self.CallsMinTime(machine_id)
4993 	def GetFinishTime(self, machine_id):  argument
4994 		t0 = self.SwitchesMaxTime(machine_id)
4995 		t1 = self.SamplesMaxTime(machine_id)
4996 		t2 = self.CallsMaxTime(machine_id)
5003 	def HostStartTime(self):  argument
5004 		if self.host_start_time:
5005 			return self.host_start_time
5006 		self.host_start_time = self.GetStartTime(self.HostMachineId())
5007 		return self.host_start_time
5009 	def HostFinishTime(self):  argument
5010 		if self.host_finish_time:
5011 			return self.host_finish_time
5012 		self.host_finish_time = self.GetFinishTime(self.HostMachineId())
5013 		return self.host_finish_time
5015 	def StartTime(self, machine_id):  argument
5016 		if machine_id == self.HostMachineId():
5017 			return self.HostStartTime()
5018 		return self.GetStartTime(machine_id)
5020 	def FinishTime(self, machine_id):  argument
5021 		if machine_id == self.HostMachineId():
5022 			return self.HostFinishTime()
5023 		return self.GetFinishTime(machine_id)
5029 	def __init__(self, is_sqlite3, dbname):  argument
5030 		self.is_sqlite3 = is_sqlite3
5031 		self.dbname = dbname
5032 		self.TRUE = "TRUE"
5033 		self.FALSE = "FALSE"
5035 		if self.is_sqlite3:
5036 			self.TRUE = "1"
5037 			self.FALSE = "0"
5039 	def Open(self, connection_name):  argument
5040 		dbname = self.dbname
5041 		if self.is_sqlite3: