187 	def __init__(self, task, param=None, parent=None):  argument
188 		super(Thread, self).__init__(parent)
189 		self.task = task
190 		self.param = param
192 	def run(self):  argument
194 			if self.param is None:
195 				done, result = self.task()
197 				done, result = self.task(self.param)
198 			self.done.emit(result)
206 	def __init__(self, glb, params, parent=None):  argument
207 		super(TreeModel, self).__init__(parent)
208 		self.glb = glb
209 		self.params = params
210 		self.root = self.GetRoot()
211 		self.last_row_read = 0
213 	def Item(self, parent):  argument
217 			return self.root
219 	def rowCount(self, parent):  argument
220 		result = self.Item(parent).childCount()
223 			self.dataChanged.emit(parent, parent)
226 	def hasChildren(self, parent):  argument
227 		return self.Item(parent).hasChildren()
229 	def headerData(self, section, orientation, role):  argument
231 			return self.columnAlignment(section)
236 		return self.columnHeader(section)
238 	def parent(self, child):  argument
240 		if child_item is self.root:
243 		return self.createIndex(parent_item.getRow(), 0, parent_item)
245 	def index(self, row, column, parent):  argument
246 		child_item = self.Item(parent).getChildItem(row)
247 		return self.createIndex(row, column, child_item)
249 	def DisplayData(self, item, index):  argument
252 	def FetchIfNeeded(self, row):  argument
253 		if row > self.last_row_read:
254 			self.last_row_read = row
255 			if row + 10 >= self.root.child_count:
256 				self.fetcher.Fetch(glb_chunk_sz)
258 	def columnAlignment(self, column):  argument
261 	def columnFont(self, column):  argument
264 	def data(self, index, role):  argument
266 			return self.columnAlignment(index.column())
268 			return self.columnFont(index.column())
272 		return self.DisplayData(item, index)
278 	def __init__(self, parent=None):  argument
279 		super(TableModel, self).__init__(parent)
280 		self.child_count = 0
281 		self.child_items = []
282 		self.last_row_read = 0
284 	def Item(self, parent):  argument
288 			return self
290 	def rowCount(self, parent):  argument
291 		return self.child_count
293 	def headerData(self, section, orientation, role):  argument
295 			return self.columnAlignment(section)
300 		return self.columnHeader(section)
302 	def index(self, row, column, parent):  argument
303 		return self.createIndex(row, column, self.child_items[row])
305 	def DisplayData(self, item, index):  argument
308 	def FetchIfNeeded(self, row):  argument
309 		if row > self.last_row_read:
310 			self.last_row_read = row
311 			if row + 10 >= self.child_count:
312 				self.fetcher.Fetch(glb_chunk_sz)
314 	def columnAlignment(self, column):  argument
317 	def columnFont(self, column):  argument
320 	def data(self, index, role):  argument
322 			return self.columnAlignment(index.column())
324 			return self.columnFont(index.column())
328 		return self.DisplayData(item, index)
360 	def __init__(self, parent, finder, is_reg_expr=False):  argument
361 		self.finder = finder
362 		self.context = []
363 		self.last_value = None
364 		self.last_pattern = None
369 		self.textbox = QComboBox()
370 		self.textbox.setEditable(True)
371 		self.textbox.currentIndexChanged.connect(self.ValueChanged)
373 		self.progress = QProgressBar()
374 		self.progress.setRange(0, 0)
375 		self.progress.hide()
378 			self.pattern = QCheckBox("Regular Expression")
380 			self.pattern = QCheckBox("Pattern")
381 		self.pattern.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
383 		self.next_button = QToolButton()
384 		self.next_button.setIcon(parent.style().standardIcon(QStyle.SP_ArrowDown))
385 		self.next_button.released.connect(lambda: self.NextPrev(1))
387 		self.prev_button = QToolButton()
388 		self.prev_button.setIcon(parent.style().standardIcon(QStyle.SP_ArrowUp))
389 		self.prev_button.released.connect(lambda: self.NextPrev(-1))
391 		self.close_button = QToolButton()
392 		self.close_button.setIcon(parent.style().standardIcon(QStyle.SP_DockWidgetCloseButton))
393 		self.close_button.released.connect(self.Deactivate)
395 		self.hbox = QHBoxLayout()
396 		self.hbox.setContentsMargins(0, 0, 0, 0)
398 		self.hbox.addWidget(label)
399 		self.hbox.addWidget(self.textbox)
400 		self.hbox.addWidget(self.progress)
401 		self.hbox.addWidget(self.pattern)
402 		self.hbox.addWidget(self.next_button)
403 		self.hbox.addWidget(self.prev_button)
404 		self.hbox.addWidget(self.close_button)
406 		self.bar = QWidget()
407 		self.bar.setLayout(self.hbox)
408 		self.bar.hide()
410 	def Widget(self):  argument
411 		return self.bar
413 	def Activate(self):  argument
414 		self.bar.show()
415 		self.textbox.lineEdit().selectAll()
416 		self.textbox.setFocus()
418 	def Deactivate(self):  argument
419 		self.bar.hide()
421 	def Busy(self):  argument
422 		self.textbox.setEnabled(False)
423 		self.pattern.hide()
424 		self.next_button.hide()
425 		self.prev_button.hide()
426 		self.progress.show()
428 	def Idle(self):  argument
429 		self.textbox.setEnabled(True)
430 		self.progress.hide()
431 		self.pattern.show()
432 		self.next_button.show()
433 		self.prev_button.show()
435 	def Find(self, direction):  argument
436 		value = self.textbox.currentText()
437 		pattern = self.pattern.isChecked()
438 		self.last_value = value
439 		self.last_pattern = pattern
440 		self.finder.Find(value, direction, pattern, self.context)
442 	def ValueChanged(self):  argument
443 		value = self.textbox.currentText()
444 		pattern = self.pattern.isChecked()
445 		index = self.textbox.currentIndex()
446 		data = self.textbox.itemData(index)
449 			self.textbox.setItemData(index, pattern)
451 			self.pattern.setChecked(data)
452 		self.Find(0)
454 	def NextPrev(self, direction):  argument
455 		value = self.textbox.currentText()
456 		pattern = self.pattern.isChecked()
457 		if value != self.last_value:
458 			index = self.textbox.findText(value)
461 				index = self.textbox.count()
462 				self.textbox.addItem(value, pattern)
463 				self.textbox.setCurrentIndex(index)
466 				self.textbox.setItemData(index, pattern)
467 		elif pattern != self.last_pattern:
469 			index = self.textbox.currentIndex()
470 			self.textbox.setItemData(index, pattern)
471 		self.Find(direction)
473 	def NotFound(self):  argument
474 		QMessageBox.information(self.bar, "Find", "'" + self.textbox.currentText() + "' not found")
480 	def __init__(self, glb, params, row, parent_item):  argument
481 		self.glb = glb
482 		self.params = params
483 		self.row = row
484 		self.parent_item = parent_item
485 		self.query_done = False
486 		self.child_count = 0
487 		self.child_items = []
489 			self.level = parent_item.level + 1
491 			self.level = 0
493 	def getChildItem(self, row):  argument
494 		return self.child_items[row]
496 	def getParentItem(self):  argument
497 		return self.parent_item
499 	def getRow(self):  argument
500 		return self.row
502 	def childCount(self):  argument
503 		if not self.query_done:
504 			self.Select()
505 			if not self.child_count:
507 		return self.child_count
509 	def hasChildren(self):  argument
510 		if not self.query_done:
512 		return self.child_count > 0
514 	def getData(self, column):  argument
515 		return self.data[column]
521 …def __init__(self, glb, params, row, comm_id, thread_id, call_path_id, time, insn_cnt, cyc_cnt, br…  argument
522 		super(CallGraphLevelTwoPlusItemBase, self).__init__(glb, params, row, parent_item)
523 		self.comm_id = comm_id
524 		self.thread_id = thread_id
525 		self.call_path_id = call_path_id
526 		self.insn_cnt = insn_cnt
527 		self.cyc_cnt = cyc_cnt
528 		self.branch_count = branch_count
529 		self.time = time
531 	def Select(self):  argument
532 		self.query_done = True
533 		query = QSqlQuery(self.glb.db)
534 		if self.params.have_ipc:
543 					" WHERE parent_call_path_id = " + str(self.call_path_id) +
544 					" AND comm_id = " + str(self.comm_id) +
545 					" AND thread_id = " + str(self.thread_id) +
549 			if self.params.have_ipc:
557 …self.glb, self.params, self.child_count, self.comm_id, self.thread_id, query.value(0), query.value…
558 			self.child_items.append(child_item)
559 			self.child_count += 1
565 …def __init__(self, glb, params, row, comm_id, thread_id, call_path_id, name, dso, count, time, ins…  argument
566 …super(CallGraphLevelThreeItem, self).__init__(glb, params, row, comm_id, thread_id, call_path_id, …
568 		if self.params.have_ipc:
573 …self.data = [ name, dso, str(count), str(time), PercentToOneDP(time, parent_item.time), str(insn_c…
575 …self.data = [ name, dso, str(count), str(time), PercentToOneDP(time, parent_item.time), str(branch…
576 		self.dbid = call_path_id
582 	def __init__(self, glb, params, row, comm_id, thread_id, pid, tid, parent_item):  argument
583 …super(CallGraphLevelTwoItem, self).__init__(glb, params, row, comm_id, thread_id, 1, 0, 0, 0, 0, p…
584 		if self.params.have_ipc:
585 			self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", "", "", "", "", "", ""]
587 			self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", ""]
588 		self.dbid = thread_id
590 	def Select(self):  argument
591 		super(CallGraphLevelTwoItem, self).Select()
592 		for child_item in self.child_items:
593 			self.time += child_item.time
594 			self.insn_cnt += child_item.insn_cnt
595 			self.cyc_cnt += child_item.cyc_cnt
596 			self.branch_count += child_item.branch_count
597 		for child_item in self.child_items:
598 			child_item.data[4] = PercentToOneDP(child_item.time, self.time)
599 			if self.params.have_ipc:
600 				child_item.data[6] = PercentToOneDP(child_item.insn_cnt, self.insn_cnt)
601 				child_item.data[8] = PercentToOneDP(child_item.cyc_cnt, self.cyc_cnt)
602 				child_item.data[11] = PercentToOneDP(child_item.branch_count, self.branch_count)
604 				child_item.data[6] = PercentToOneDP(child_item.branch_count, self.branch_count)
610 	def __init__(self, glb, params, row, comm_id, comm, parent_item):  argument
611 		super(CallGraphLevelOneItem, self).__init__(glb, params, row, parent_item)
612 		if self.params.have_ipc:
613 			self.data = [comm, "", "", "", "", "", "", "", "", "", "", ""]
615 			self.data = [comm, "", "", "", "", "", ""]
616 		self.dbid = comm_id
618 	def Select(self):  argument
619 		self.query_done = True
620 		query = QSqlQuery(self.glb.db)
624 					" WHERE comm_id = " + str(self.dbid))
626 …= CallGraphLevelTwoItem(self.glb, self.params, self.child_count, self.dbid, query.value(0), query.…
627 			self.child_items.append(child_item)
628 			self.child_count += 1
634 	def __init__(self, glb, params):  argument
635 		super(CallGraphRootItem, self).__init__(glb, params, 0, None)
636 		self.dbid = 0
637 		self.query_done = True
646 …child_item = CallGraphLevelOneItem(glb, params, self.child_count, query.value(0), query.value(1), …
647 			self.child_items.append(child_item)
648 			self.child_count += 1
654 	def __init__(self, glb, parent=None):  argument
655 		self.have_ipc = IsSelectable(glb.db, "calls", columns = "insn_count, cyc_count")
661 	def __init__(self, glb, parent=None):  argument
662 		super(CallGraphModelBase, self).__init__(glb, CallGraphModelParams(glb), parent)
664 	def FindSelect(self, value, pattern, query):  argument
671 			if not self.glb.dbref.is_sqlite3:
682 		self.DoFindSelect(query, match)
684 	def Found(self, query, found):  argument
686 			return self.FindPath(query)
689 	def FindValue(self, value, pattern, query, last_value, last_pattern):  argument
693 			self.FindSelect(value, pattern, query)
695 		return self.Found(query, found)
697 	def FindNext(self, query):  argument
701 		return self.Found(query, found)
703 	def FindPrev(self, query):  argument
707 		return self.Found(query, found)
709 	def FindThread(self, c):  argument
711 			ids = self.FindValue(c.value, c.pattern, c.query, c.last_value, c.last_pattern)
713 			ids = self.FindNext(c.query)
715 			ids = self.FindPrev(c.query)
718 	def Find(self, value, direction, pattern, context, callback):  argument
720 			def __init__(self, *x):  argument
721 				self.value, self.direction, self.pattern, self.query, self.last_value, self.last_pattern = x
722 			def Update(self, *x):  argument
723 …self.value, self.direction, self.pattern, self.last_value, self.last_pattern = x + (self.value, se…
727 			context.append(Context(value, direction, pattern, QSqlQuery(self.glb.db), None, None))
729 		thread = Thread(self.FindThread, context[0])
730 …thread.done.connect(lambda ids, t=thread, c=callback: self.FindDone(t, c, ids), Qt.QueuedConnectio…
733 	def FindDone(self, thread, callback, ids):  argument
740 	def __init__(self, glb, parent=None):  argument
741 		super(CallGraphModel, self).__init__(glb, parent)
743 	def GetRoot(self):  argument
744 		return CallGraphRootItem(self.glb, self.params)
746 	def columnCount(self, parent=None):  argument
747 		if self.params.have_ipc:
752 	def columnHeader(self, column):  argument
753 		if self.params.have_ipc:
759 	def columnAlignment(self, column):  argument
760 		if self.params.have_ipc:
766 	def DoFindSelect(self, query, match):  argument
776 	def FindPath(self, query):  argument
783 			q2 = QSqlQuery(self.glb.db)
801 …def __init__(self, glb, params, row, comm_id, thread_id, calls_id, call_time, time, insn_cnt, cyc_…  argument
802 		super(CallTreeLevelTwoPlusItemBase, self).__init__(glb, params, row, parent_item)
803 		self.comm_id = comm_id
804 		self.thread_id = thread_id
805 		self.calls_id = calls_id
806 		self.call_time = call_time
807 		self.time = time
808 		self.insn_cnt = insn_cnt
809 		self.cyc_cnt = cyc_cnt
810 		self.branch_count = branch_count
812 	def Select(self):  argument
813 		self.query_done = True
814 		if self.calls_id == 0:
815 			comm_thread = " AND comm_id = " + str(self.comm_id) + " AND thread_id = " + str(self.thread_id)
818 		if self.params.have_ipc:
822 		query = QSqlQuery(self.glb.db)
828 					" WHERE calls.parent_id = " + str(self.calls_id) + comm_thread +
831 			if self.params.have_ipc:
839 …self.glb, self.params, self.child_count, self.comm_id, self.thread_id, query.value(0), query.value…
840 			self.child_items.append(child_item)
841 			self.child_count += 1
847 …def __init__(self, glb, params, row, comm_id, thread_id, calls_id, name, dso, call_time, time, ins…  argument
848 …super(CallTreeLevelThreeItem, self).__init__(glb, params, row, comm_id, thread_id, calls_id, call_…
850 		if self.params.have_ipc:
855 …self.data = [ name, dso, str(call_time), str(time), PercentToOneDP(time, parent_item.time), str(in…
857 …self.data = [ name, dso, str(call_time), str(time), PercentToOneDP(time, parent_item.time), str(br…
858 		self.dbid = calls_id
864 	def __init__(self, glb, params, row, comm_id, thread_id, pid, tid, parent_item):  argument
865 …super(CallTreeLevelTwoItem, self).__init__(glb, params, row, comm_id, thread_id, 0, 0, 0, 0, 0, 0,…
866 		if self.params.have_ipc:
867 			self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", "", "", "", "", "", ""]
869 			self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", ""]
870 		self.dbid = thread_id
872 	def Select(self):  argument
873 		super(CallTreeLevelTwoItem, self).Select()
874 		for child_item in self.child_items:
875 			self.time += child_item.time
876 			self.insn_cnt += child_item.insn_cnt
877 			self.cyc_cnt += child_item.cyc_cnt
878 			self.branch_count += child_item.branch_count
879 		for child_item in self.child_items:
880 			child_item.data[4] = PercentToOneDP(child_item.time, self.time)
881 			if self.params.have_ipc:
882 				child_item.data[6] = PercentToOneDP(child_item.insn_cnt, self.insn_cnt)
883 				child_item.data[8] = PercentToOneDP(child_item.cyc_cnt, self.cyc_cnt)
884 				child_item.data[11] = PercentToOneDP(child_item.branch_count, self.branch_count)
886 				child_item.data[6] = PercentToOneDP(child_item.branch_count, self.branch_count)
892 	def __init__(self, glb, params, row, comm_id, comm, parent_item):  argument
893 		super(CallTreeLevelOneItem, self).__init__(glb, params, row, parent_item)
894 		if self.params.have_ipc:
895 			self.data = [comm, "", "", "", "", "", "", "", "", "", "", ""]
897 			self.data = [comm, "", "", "", "", "", ""]
898 		self.dbid = comm_id
900 	def Select(self):  argument
901 		self.query_done = True
902 		query = QSqlQuery(self.glb.db)
906 					" WHERE comm_id = " + str(self.dbid))
908 … = CallTreeLevelTwoItem(self.glb, self.params, self.child_count, self.dbid, query.value(0), query.…
909 			self.child_items.append(child_item)
910 			self.child_count += 1
916 	def __init__(self, glb, params):  argument
917 		super(CallTreeRootItem, self).__init__(glb, params, 0, None)
918 		self.dbid = 0
919 		self.query_done = True
928 …child_item = CallTreeLevelOneItem(glb, params, self.child_count, query.value(0), query.value(1), s…
929 			self.child_items.append(child_item)
930 			self.child_count += 1
936 	def __init__(self, glb, parent=None):  argument
937 		super(CallTreeModel, self).__init__(glb, parent)
939 	def GetRoot(self):  argument
940 		return CallTreeRootItem(self.glb, self.params)
942 	def columnCount(self, parent=None):  argument
943 		if self.params.have_ipc:
948 	def columnHeader(self, column):  argument
949 		if self.params.have_ipc:
955 	def columnAlignment(self, column):  argument
956 		if self.params.have_ipc:
962 	def DoFindSelect(self, query, match):  argument
971 	def FindPath(self, query):  argument
978 			q2 = QSqlQuery(self.glb.db)
993 	def __init__(self, *children):  argument
994 		super(HBoxLayout, self).__init__()
996 		self.layout().setContentsMargins(0, 0, 0, 0)
999 				self.layout().addWidget(child)
1001 				self.layout().addLayout(child)
1007 	def __init__(self, *children):  argument
1008 		super(VBoxLayout, self).__init__()
1010 		self.layout().setContentsMargins(0, 0, 0, 0)
1013 				self.layout().addWidget(child)
1015 				self.layout().addLayout(child)
1021 	def __init__(self, *children):  argument
1022 		self.vbox = QWidget()
1023 		self.vbox.setLayout(VBoxLayout(*children))
1025 	def Widget(self):  argument
1026 		return self.vbox
1032 	def __init__(self, parent=None):  argument
1033 		super(TreeWindowBase, self).__init__(parent)
1035 		self.model = None
1036 		self.find_bar = None
1038 		self.view = QTreeView()
1039 		self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
1040 		self.view.CopyCellsToClipboard = CopyTreeCellsToClipboard
1042 		self.context_menu = TreeContextMenu(self.view)
1044 	def DisplayFound(self, ids):  argument
1050 			n = self.model.rowCount(parent)
1052 				child = self.model.index(row, 0, parent)
1055 					self.view.setExpanded(parent, True)
1056 					self.view.setCurrentIndex(child)
1063 	def Find(self, value, direction, pattern, context):  argument
1064 		self.view.setFocus()
1065 		self.find_bar.Busy()
1066 		self.model.Find(value, direction, pattern, context, self.FindDone)
1068 	def FindDone(self, ids):  argument
1070 		if not self.DisplayFound(ids):
1072 		self.find_bar.Idle()
1074 			self.find_bar.NotFound()
1081 	def __init__(self, glb, parent=None):  argument
1082 		super(CallGraphWindow, self).__init__(parent)
1084 		self.model = LookupCreateModel("Context-Sensitive Call Graph", lambda x=glb: CallGraphModel(x))
1086 		self.view.setModel(self.model)
1089 			self.view.setColumnWidth(c, w)
1091 		self.find_bar = FindBar(self, self)
1093 		self.vbox = VBox(self.view, self.find_bar.Widget())
1095 		self.setWidget(self.vbox.Widget())
1097 		AddSubWindow(glb.mainwindow.mdi_area, self, "Context-Sensitive Call Graph")
1103 	def __init__(self, glb, parent=None, thread_at_time=None):  argument
1104 		super(CallTreeWindow, self).__init__(parent)
1106 		self.model = LookupCreateModel("Call Tree", lambda x=glb: CallTreeModel(x))
1108 		self.view.setModel(self.model)
1111 			self.view.setColumnWidth(c, w)
1113 		self.find_bar = FindBar(self, self)
1115 		self.vbox = VBox(self.view, self.find_bar.Widget())
1117 		self.setWidget(self.vbox.Widget())
1119 		AddSubWindow(glb.mainwindow.mdi_area, self, "Call Tree")
1122 			self.DisplayThreadAtTime(*thread_at_time)
1124 	def DisplayThreadAtTime(self, comm_id, thread_id, time):  argument
1128 			n = self.model.rowCount(parent)
1130 				child = self.model.index(row, 0, parent)
1133 					self.view.setExpanded(parent, True)
1134 					self.view.setCurrentIndex(child)
1141 			n = self.model.rowCount(parent)
1146 				self.view.setExpanded(parent, True)
1147 				child = self.model.index(row, 0, parent)
1152 					self.view.setCurrentIndex(child)
1158 					child = self.model.index(0, 0, parent)
1159 					self.view.setExpanded(parent, True)
1160 					self.view.setCurrentIndex(child)
1163 			self.view.setExpanded(parent, True)
1164 			self.view.setCurrentIndex(last_child)
1190 	def __init__(self, x=0, y=0):  argument
1191 		self.x = x
1192 		self.y = y
1194 	def __str__(self):  argument
1195 		return "XY({}, {})".format(str(self.x), str(self.y))
1200 	def __init__(self, lo=0, hi=0):  argument
1201 		self.lo = lo
1202 		self.hi = hi
1204 	def __str__(self):  argument
1205 		return "Subrange({}, {})".format(str(self.lo), str(self.hi))
1211 	def __init__(self, key, title = "", ordinal = ""):  argument
1212 		self.key = key
1213 		self.title = title
1214 		self.ordinal = ordinal
1225 	def __init__(self, colour):  argument
1226 		self.colour = colour
1232 	def __init__(self, key, exec_comm_id, pid, tid, comm, thread_id, comm_id):  argument
1233 		super(SwitchGraphDataRegion, self).__init__(key)
1235 		self.title = str(pid) + " / " + str(tid) + " " + comm
1237 		self.ordinal = str(pid).rjust(16) + str(exec_comm_id).rjust(8) + str(tid).rjust(16)
1238 		self.exec_comm_id = exec_comm_id
1239 		self.pid = pid
1240 		self.tid = tid
1241 		self.comm = comm
1242 		self.thread_id = thread_id
1243 		self.comm_id = comm_id
1249 	def __init__(self, data, index, x, y, altx=None, alty=None, hregion=None, vregion=None):  argument
1250 		self.data = data
1251 		self.index = index
1252 		self.x = x
1253 		self.y = y
1254 		self.altx = altx
1255 		self.alty = alty
1256 		self.hregion = hregion
1257 		self.vregion = vregion
1263 	def __init__(self, collection, xbase=Decimal(0), ybase=Decimal(0)):  argument
1264 		self.collection = collection
1265 		self.points = []
1266 		self.xbase = xbase
1267 		self.ybase = ybase
1268 		self.title = ""
1270 	def AddPoint(self, x, y, altx=None, alty=None, hregion=None, vregion=None):  argument
1271 		index = len(self.points)
1273 		x = float(Decimal(x) - self.xbase)
1274 		y = float(Decimal(y) - self.ybase)
1276 		self.points.append(GraphDataPoint(self, index, x, y, altx, alty, hregion, vregion))
1278 	def XToData(self, x):  argument
1279 		return Decimal(x) + self.xbase
1281 	def YToData(self, y):  argument
1282 		return Decimal(y) + self.ybase
1288 	def __init__(self, db, collection, cpu, xbase):  argument
1289 		super(SwitchGraphData, self).__init__(collection, xbase)
1291 		self.cpu = cpu
1292 		self.title = "CPU " + str(cpu)
1293 		self.SelectSwitches(db)
1295 	def SelectComms(self, db, thread_id, last_comm_id, start_time, end_time):  argument
1300 					"   AND exec_flag = " + self.collection.glb.dbref.TRUE +
1309 			hregion = self.HRegion(db, thread_id, comm_id, time)
1310 			self.AddPoint(time, 1000, None, None, hregion)
1312 	def SelectSwitches(self, db):  argument
1319 					" WHERE machine_id = " + str(self.collection.machine_id) +
1320 					"   AND cpu = " + str(self.cpu) +
1327 					self.SelectComms(db, last_thread_id, last_comm_id, last_time, query.value(0))
1330 			if len(self.points) == 0:
1331 				start_time = self.collection.glb.StartTime(self.collection.machine_id)
1332 				hregion = self.HRegion(db, query.value(1), query.value(3), start_time)
1333 				self.AddPoint(start_time, 1000, None, None, hregion)
1337 			hregion = self.HRegion(db, thread_id, comm_id, time)
1338 			self.AddPoint(time, 1000, None, None, hregion)
1343 	def NewHRegion(self, db, key, thread_id, comm_id, time):  argument
1361 	def HRegion(self, db, thread_id, comm_id, time):  argument
1363 		hregion = self.collection.LookupHRegion(key)
1365 			hregion = self.NewHRegion(db, key, thread_id, comm_id, time)
1366 			self.collection.AddHRegion(key, hregion)
1373 	def __init__(self, glb):  argument
1374 		self.glb = glb
1375 		self.data = []
1376 		self.hregions = {}
1377 		self.xrangelo = None
1378 		self.xrangehi = None
1379 		self.yrangelo = None
1380 		self.yrangehi = None
1381 		self.dp = XY(0, 0)
1383 	def AddGraphData(self, data):  argument
1384 		self.data.append(data)
1386 	def LookupHRegion(self, key):  argument
1387 		if key in self.hregions:
1388 			return self.hregions[key]
1391 	def AddHRegion(self, key, hregion):  argument
1392 		self.hregions[key] = hregion
1398 	def __init__(self, glb, db, machine_id):  argument
1399 		super(SwitchGraphDataCollection, self).__init__(glb)
1401 		self.machine_id = machine_id
1402 		self.cpus = self.SelectCPUs(db)
1404 		self.xrangelo = glb.StartTime(machine_id)
1405 		self.xrangehi = glb.FinishTime(machine_id)
1407 		self.yrangelo = Decimal(0)
1408 		self.yrangehi = Decimal(1000)
1410 		for cpu in self.cpus:
1411 			self.AddGraphData(SwitchGraphData(db, self, cpu, self.xrangelo))
1413 	def SelectCPUs(self, db):  argument
1418 					" WHERE machine_id = " + str(self.machine_id))
1427 	def __init__(self, data, graph_width, graph_height, attrs, event_handler, parent=None):  argument
1428 		super(SwitchGraphDataGraphicsItem, self).__init__(parent)
1430 		self.data = data
1431 		self.graph_width = graph_width
1432 		self.graph_height = graph_height
1433 		self.attrs = attrs
1434 		self.event_handler = event_handler
1435 		self.setAcceptHoverEvents(True)
1437 	def boundingRect(self):  argument
1438 		return QRectF(0, 0, self.graph_width, self.graph_height)
1440 	def PaintPoint(self, painter, last, x):  argument
1441 		if not(last is None or last.hregion.pid == 0 or x < self.attrs.subrange.x.lo):
1442 			if last.x < self.attrs.subrange.x.lo:
1443 				x0 = self.attrs.subrange.x.lo
1446 			if x > self.attrs.subrange.x.hi:
1447 				x1 = self.attrs.subrange.x.hi
1450 			x0 = self.attrs.XToPixel(x0)
1451 			x1 = self.attrs.XToPixel(x1)
1453 			y0 = self.attrs.YToPixel(last.y)
1455 			colour = self.attrs.region_attributes[last.hregion.key].colour
1460 				painter.drawLine(x0, self.graph_height - y0, x0, self.graph_height)
1462 				painter.fillRect(x0, self.graph_height - y0, width, self.graph_height - 1, colour)
1464 	def paint(self, painter, option, widget):  argument
1466 		for point in self.data.points:
1467 			self.PaintPoint(painter, last, point.x)
1468 			if point.x > self.attrs.subrange.x.hi:
1471 		self.PaintPoint(painter, last, self.attrs.subrange.x.hi + 1)
1473 	def BinarySearchPoint(self, target):  argument
1475 		higher_pos = len(self.data.points)
1478 			val = self.data.points[pos].x
1486 	def XPixelToData(self, x):  argument
1487 		x = self.attrs.PixelToX(x)
1488 		if x < self.data.points[0].x:
1493 			pos = self.BinarySearchPoint(x)
1495 		return (low, pos, self.data.XToData(x))
1497 	def EventToData(self, event):  argument
1499 		if len(self.data.points) < 1:
1504 		low0, pos0, time_from = self.XPixelToData(x)
1505 		low1, pos1, time_to = self.XPixelToData(x + 1)
1510 				hregion = self.data.points[i].hregion
1515 					time = self.data.XToData(self.data.points[i].x)
1519 	def hoverMoveEvent(self, event):  argument
1520 		time_from, time_to, hregions, hregion_times = self.EventToData(event)
1522 			self.event_handler.PointEvent(self.data.cpu, time_from, time_to, hregions)
1524 	def hoverLeaveEvent(self, event):  argument
1525 		self.event_handler.NoPointEvent()
1527 	def mousePressEvent(self, event):  argument
1529 			super(SwitchGraphDataGraphicsItem, self).mousePressEvent(event)
1531 		time_from, time_to, hregions, hregion_times = self.EventToData(event)
1533 			self.event_handler.RightClickEvent(self.data.cpu, hregion_times, event.screenPos())
1539 	def __init__(self, width, parent=None):  argument
1540 		super(XAxisGraphicsItem, self).__init__(parent)
1542 		self.width = width
1543 		self.max_mark_sz = 4
1544 		self.height = self.max_mark_sz + 1
1546 	def boundingRect(self):  argument
1547 		return QRectF(0, 0, self.width, self.height)
1549 	def Step(self):  argument
1550 		attrs = self.parentItem().attrs
1553 		s = (3.0 * t) / self.width
1559 	def PaintMarks(self, painter, at_y, lo, hi, step, i):  argument
1560 		attrs = self.parentItem().attrs
1570 				sz = self.max_mark_sz
1576 	def paint(self, painter, option, widget):  argument
1578 		painter.drawLine(0, 0, self.width - 1, 0)
1579 		n = self.Step()
1580 		attrs = self.parentItem().attrs
1588 		self.PaintMarks(painter, 0, x, subrange.hi, n, i)
1590 	def ScaleDimensions(self):  argument
1591 		n = self.Step()
1592 		attrs = self.parentItem().attrs
1600 	def PaintScale(self, painter, at_x, at_y):  argument
1601 		n, lo, hi, width = self.ScaleDimensions()
1605 		self.PaintMarks(painter, at_y, lo, hi, n, 0)
1607 	def ScaleWidth(self):  argument
1608 		n, lo, hi, width = self.ScaleDimensions()
1611 	def ScaleHeight(self):  argument
1612 		return self.height
1614 	def ScaleUnit(self):  argument
1615 		return self.Step() * 10
1621 	def __init__(self, axis, parent=None):  argument
1622 		super(ScaleGraphicsItem, self).__init__(parent)
1623 		self.axis = axis
1625 	def boundingRect(self):  argument
1626 		scale_width = self.axis.ScaleWidth()
1629 		return QRectF(0, 0, self.axis.ScaleWidth() + 100, self.axis.ScaleHeight())
1631 	def paint(self, painter, option, widget):  argument
1632 		scale_width = self.axis.ScaleWidth()
1635 		self.axis.PaintScale(painter, 0, 5)
1637 		painter.drawText(QPointF(x, 10), self.Text())
1639 	def Unit(self):  argument
1640 		return self.axis.ScaleUnit()
1642 	def Text(self):  argument
1649 	def __init__(self, axis, parent=None):  argument
1650 		super(SwitchScaleGraphicsItem, self).__init__(axis, parent)
1652 	def Text(self):  argument
1653 		unit = self.Unit()
1672 	def __init__(self, collection, data, attrs, event_handler, first, parent=None):  argument
1673 		super(SwitchGraphGraphicsItem, self).__init__(parent)
1674 		self.collection = collection
1675 		self.data = data
1676 		self.attrs = attrs
1677 		self.event_handler = event_handler
1682 		self.title_graphics = QGraphicsSimpleTextItem(data.title, self)
1684 		self.title_graphics.setPos(margin, margin)
1688 		self.graph_origin_x = margin + title_width + margin
1689 		self.graph_origin_y = graph_height + margin
1693 		self.yline = QGraphicsLineItem(0, 0, 0, graph_height, self)
1695 		self.x_axis = XAxisGraphicsItem(graph_width, self)
1696 		self.x_axis.setPos(self.graph_origin_x, self.graph_origin_y + 1)
1699 			self.scale_item = SwitchScaleGraphicsItem(self.x_axis, self)
1700 			self.scale_item.setPos(self.graph_origin_x, self.graph_origin_y + 10)
1702 		self.yline.setPos(self.graph_origin_x - y_axis_size, self.graph_origin_y - graph_height)
1704 		self.axis_point = QGraphicsLineItem(0, 0, 0, 0, self)
1705 		self.axis_point.setPos(self.graph_origin_x - 1, self.graph_origin_y +1)
1707 		self.width = self.graph_origin_x + graph_width + margin
1708 		self.height = self.graph_origin_y + margin
1710 …self.graph = SwitchGraphDataGraphicsItem(data, graph_width, graph_height, attrs, event_handler, se…
1711 		self.graph.setPos(self.graph_origin_x, self.graph_origin_y - graph_height)
1714 			parent.EnableRubberBand(self.graph_origin_x, self.graph_origin_x + graph_width - 1, self)
1716 	def boundingRect(self):  argument
1717 		return QRectF(0, 0, self.width, self.height)
1719 	def paint(self, painter, option, widget):  argument
1722 	def RBXToPixel(self, x):  argument
1723 		return self.attrs.PixelToX(x - self.graph_origin_x)
1725 	def RBXRangeToPixel(self, x0, x1):  argument
1726 		return (self.RBXToPixel(x0), self.RBXToPixel(x1 + 1))
1728 	def RBPixelToTime(self, x):  argument
1729 		if x < self.data.points[0].x:
1730 			return self.data.XToData(0)
1731 		return self.data.XToData(x)
1733 	def RBEventTimes(self, x0, x1):  argument
1734 		x0, x1 = self.RBXRangeToPixel(x0, x1)
1735 		time_from = self.RBPixelToTime(x0)
1736 		time_to = self.RBPixelToTime(x1)
1739 	def RBEvent(self, x0, x1):  argument
1740 		time_from, time_to = self.RBEventTimes(x0, x1)
1741 		self.event_handler.RangeEvent(time_from, time_to)
1743 	def RBMoveEvent(self, x0, x1):  argument
1746 		self.RBEvent(x0, x1)
1748 	def RBReleaseEvent(self, x0, x1, selection_state):  argument
1751 		x0, x1 = self.RBXRangeToPixel(x0, x1)
1752 		self.event_handler.SelectEvent(x0, x1, selection_state)
1758 	def __init__(self, parent=None):  argument
1759 		super(VerticalBracketGraphicsItem, self).__init__(parent)
1761 		self.width = 0
1762 		self.height = 0
1763 		self.hide()
1765 	def SetSize(self, width, height):  argument
1766 		self.width = width + 1
1767 		self.height = height + 1
1769 	def boundingRect(self):  argument
1770 		return QRectF(0, 0, self.width, self.height)
1772 	def paint(self, painter, option, widget):  argument
1774 		painter.fillRect(0, 0, self.width, self.height, colour)
1775 		x1 = self.width - 1
1776 		y1 = self.height - 1
1788 	def __init__(self, collection, attrs, event_handler, child_class, parent=None):  argument
1789 		super(VertcalGraphSetGraphicsItem, self).__init__(parent)
1791 		self.collection = collection
1793 		self.top = 10
1795 		self.width = 0
1796 		self.height = self.top
1798 		self.rubber_band = None
1799 		self.rb_enabled = False
1803 			child = child_class(collection, data, attrs, event_handler, first, self)
1804 			child.setPos(0, self.height + 1)
1806 			if rect.right() > self.width:
1807 				self.width = rect.right()
1808 			self.height = self.height + rect.bottom() + 1
1811 		self.bracket = VerticalBracketGraphicsItem(self)
1813 	def EnableRubberBand(self, xlo, xhi, rb_event_handler):  argument
1814 		if self.rb_enabled:
1816 		self.rb_enabled = True
1817 		self.rb_in_view = False
1818 		self.setAcceptedMouseButtons(Qt.LeftButton)
1819 		self.rb_xlo = xlo
1820 		self.rb_xhi = xhi
1821 		self.rb_event_handler = rb_event_handler
1822 		self.mousePressEvent = self.MousePressEvent
1823 		self.mouseMoveEvent = self.MouseMoveEvent
1824 		self.mouseReleaseEvent = self.MouseReleaseEvent
1826 	def boundingRect(self):  argument
1827 		return QRectF(0, 0, self.width, self.height)
1829 	def paint(self, painter, option, widget):  argument
1832 	def RubberBandParent(self):  argument
1833 		scene = self.scene()
1838 	def RubberBandSetGeometry(self, rect):  argument
1839 		scene_rectf = self.mapRectToScene(QRectF(rect))
1840 		scene = self.scene()
1843 		self.rubber_band.setGeometry(poly.boundingRect())
1845 	def SetSelection(self, selection_state):  argument
1846 		if self.rubber_band:
1848 				self.RubberBandSetGeometry(selection_state)
1849 				self.rubber_band.show()
1851 				self.rubber_band.hide()
1853 	def SetBracket(self, rect):  argument
1856 			self.bracket.setPos(x, y)
1857 			self.bracket.SetSize(width, height)
1858 			self.bracket.show()
1860 			self.bracket.hide()
1862 	def RubberBandX(self, event):  argument
1864 		if x < self.rb_xlo:
1865 			x = self.rb_xlo
1866 		elif x > self.rb_xhi:
1867 			x = self.rb_xhi
1869 			self.rb_in_view = True
1872 	def RubberBandRect(self, x):  argument
1873 		if self.rb_origin.x() <= x:
1874 			width = x - self.rb_origin.x()
1875 			rect = QRect(self.rb_origin, QSize(width, self.height))
1877 			width = self.rb_origin.x() - x
1878 			top_left = QPoint(self.rb_origin.x() - width, self.rb_origin.y())
1879 			rect = QRect(top_left, QSize(width, self.height))
1882 	def MousePressEvent(self, event):  argument
1883 		self.rb_in_view = False
1884 		x = self.RubberBandX(event)
1885 		self.rb_origin = QPoint(x, self.top)
1886 		if self.rubber_band is None:
1887 			self.rubber_band = QRubberBand(QRubberBand.Rectangle, self.RubberBandParent())
1888 		self.RubberBandSetGeometry(QRect(self.rb_origin, QSize(0, self.height)))
1889 		if self.rb_in_view:
1890 			self.rubber_band.show()
1891 			self.rb_event_handler.RBMoveEvent(x, x)
1893 			self.rubber_band.hide()
1895 	def MouseMoveEvent(self, event):  argument
1896 		x = self.RubberBandX(event)
1897 		rect = self.RubberBandRect(x)
1898 		self.RubberBandSetGeometry(rect)
1899 		if self.rb_in_view:
1900 			self.rubber_band.show()
1901 			self.rb_event_handler.RBMoveEvent(self.rb_origin.x(), x)
1903 	def MouseReleaseEvent(self, event):  argument
1904 		x = self.RubberBandX(event)
1905 		if self.rb_in_view:
1906 			selection_state = self.RubberBandRect(x)
1909 		self.rb_event_handler.RBReleaseEvent(self.rb_origin.x(), x, selection_state)
1915 	def __init__(self, collection, region_attributes, parent=None):  argument
1916 		super(SwitchGraphLegendModel, self).__init__(parent)
1918 		self.region_attributes = region_attributes
1920 		self.child_items = sorted(collection.hregions.values(), key=GraphDataRegionOrdinal)
1921 		self.child_count = len(self.child_items)
1923 		self.highlight_set = set()
1925 		self.column_headers = ("pid", "tid", "comm")
1927 	def rowCount(self, parent):  argument
1928 		return self.child_count
1930 	def headerData(self, section, orientation, role):  argument
1935 		return self.columnHeader(section)
1937 	def index(self, row, column, parent):  argument
1938 		return self.createIndex(row, column, self.child_items[row])
1940 	def columnCount(self, parent=None):  argument
1941 		return len(self.column_headers)
1943 	def columnHeader(self, column):  argument
1944 		return self.column_headers[column]
1946 	def data(self, index, role):  argument
1948 			child = self.child_items[index.row()]
1949 			if child in self.highlight_set:
1950 				return self.region_attributes[child.key].colour
1953 			child = self.child_items[index.row()]
1954 			if child in self.highlight_set:
1956 			return self.region_attributes[child.key].colour
1959 		hregion = self.child_items[index.row()]
1969 	def SetHighlight(self, row, set_highlight):  argument
1970 		child = self.child_items[row]
1971 		top_left = self.createIndex(row, 0, child)
1972 		bottom_right = self.createIndex(row, len(self.column_headers) - 1, child)
1973 		self.dataChanged.emit(top_left, bottom_right)
1975 	def Highlight(self, highlight_set):  argument
1976 		for row in xrange(self.child_count):
1977 			child = self.child_items[row]
1978 			if child in self.highlight_set:
1980 					self.SetHighlight(row, False)
1982 				self.SetHighlight(row, True)
1983 		self.highlight_set = highlight_set
1989 	def __init__(self, collection, region_attributes, parent=None):  argument
1990 		super(SwitchGraphLegend, self).__init__(parent)
1992 		self.data_model = SwitchGraphLegendModel(collection, region_attributes)
1994 		self.model = QSortFilterProxyModel()
1995 		self.model.setSourceModel(self.data_model)
1997 		self.view = QTableView()
1998 		self.view.setModel(self.model)
1999 		self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
2000 		self.view.verticalHeader().setVisible(False)
2001 		self.view.sortByColumn(-1, Qt.AscendingOrder)
2002 		self.view.setSortingEnabled(True)
2003 		self.view.resizeColumnsToContents()
2004 		self.view.resizeRowsToContents()
2006 		self.vbox = VBoxLayout(self.view)
2007 		self.setLayout(self.vbox)
2009 		sz1 = self.view.columnWidth(0) + self.view.columnWidth(1) + self.view.columnWidth(2) + 2
2010 		sz1 = sz1 + self.view.verticalScrollBar().sizeHint().width()
2011 		self.saved_size = sz1
2013 	def resizeEvent(self, event):  argument
2014 		self.saved_size = self.size().width()
2015 		super(SwitchGraphLegend, self).resizeEvent(event)
2017 	def Highlight(self, highlight_set):  argument
2018 		self.data_model.Highlight(highlight_set)
2019 		self.update()
2021 	def changeEvent(self, event):  argument
2023 			self.view.resizeRowsToContents()
2024 			self.view.resizeColumnsToContents()
2026 			self.view.resizeRowsToContents()
2027 		super(SwitchGraphLegend, self).changeEvent(event)
2073 	def __init__(self, scale, subrange, region_attributes, dp):  argument
2074 		self.scale = scale
2075 		self.subrange = subrange
2076 		self.region_attributes = region_attributes
2078 		self.dp = dp	# data decimal places
2079 		self.Update()
2081 	def XToPixel(self, x):  argument
2082 		return int(round((x - self.subrange.x.lo) * self.scale.x, self.pdp.x))
2084 	def YToPixel(self, y):  argument
2085 		return int(round((y - self.subrange.y.lo) * self.scale.y, self.pdp.y))
2087 	def PixelToXRounded(self, px):  argument
2088 		return round((round(px, 0) / self.scale.x), self.dp.x) + self.subrange.x.lo
2090 	def PixelToYRounded(self, py):  argument
2091 		return round((round(py, 0) / self.scale.y), self.dp.y) + self.subrange.y.lo
2093 	def PixelToX(self, px):  argument
2094 		x = self.PixelToXRounded(px)
2095 		if self.pdp.x == 0:
2096 			rt = self.XToPixel(x)
2101 	def PixelToY(self, py):  argument
2102 		y = self.PixelToYRounded(py)
2103 		if self.pdp.y == 0:
2104 			rt = self.YToPixel(y)
2109 	def ToPDP(self, dp, scale):  argument
2125 	def Update(self):  argument
2126 		x = self.ToPDP(self.dp.x, self.scale.x)
2127 		y = self.ToPDP(self.dp.y, self.scale.y)
2128 		self.pdp = XY(x, y) # pixel decimal places
2134 	def __init__(self, parent=None):  argument
2135 		super(SwitchGraphSplitter, self).__init__(parent)
2137 		self.first_time = False
2139 	def resizeEvent(self, ev):  argument
2140 		if self.first_time:
2141 			self.first_time = False
2142 …sz1 = self.widget(1).view.columnWidth(0) + self.widget(1).view.columnWidth(1) + self.widget(1).vie…
2143 			sz1 = sz1 + self.widget(1).view.verticalScrollBar().sizeHint().width()
2144 			sz0 = self.size().width() - self.handleWidth() - sz1
2145 			self.setSizes([sz0, sz1])
2146 		elif not(self.widget(1).saved_size is None):
2147 			sz1 = self.widget(1).saved_size
2148 			sz0 = self.size().width() - self.handleWidth() - sz1
2149 			self.setSizes([sz0, sz1])
2150 		super(SwitchGraphSplitter, self).resizeEvent(ev)
2158 	def __init__(self, parent=None):  argument
2159 		super(GraphWidget, self).__init__(parent)
2161 	def GraphTitleChanged(self, title):  argument
2162 		self.graph_title_changed.emit(title)
2164 	def Title(self):  argument
2183 	def __init__(self, glb, collection, parent=None):  argument
2184 		super(SwitchGraphWidget, self).__init__(parent)
2186 		self.glb = glb
2187 		self.collection = collection
2189 		self.back_state = []
2190 		self.forward_state = []
2191 		self.selection_state = (None, None)
2192 		self.fwd_rect = None
2193 		self.start_time = self.glb.StartTime(collection.machine_id)
2211 		scale = self.GetScaleForRange(subrange)
2213 		self.attrs = GraphAttributes(scale, subrange, region_attributes, collection.dp)
2215 		self.item = VertcalGraphSetGraphicsItem(collection, self.attrs, self, SwitchGraphGraphicsItem)
2217 		self.scene = QGraphicsScene()
2218 		self.scene.addItem(self.item)
2220 		self.view = QGraphicsView(self.scene)
2221 		self.view.centerOn(0, 0)
2222 		self.view.setAlignment(Qt.AlignLeft | Qt.AlignTop)
2224 		self.legend = SwitchGraphLegend(collection, region_attributes)
2226 		self.splitter = SwitchGraphSplitter()
2227 		self.splitter.addWidget(self.view)
2228 		self.splitter.addWidget(self.legend)
2230 		self.point_label = QLabel("")
2231 		self.point_label.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
2233 		self.back_button = QToolButton()
2234 		self.back_button.setIcon(self.style().standardIcon(QStyle.SP_ArrowLeft))
2235 		self.back_button.setDisabled(True)
2236 		self.back_button.released.connect(lambda: self.Back())
2238 		self.forward_button = QToolButton()
2239 		self.forward_button.setIcon(self.style().standardIcon(QStyle.SP_ArrowRight))
2240 		self.forward_button.setDisabled(True)
2241 		self.forward_button.released.connect(lambda: self.Forward())
2243 		self.zoom_button = QToolButton()
2244 		self.zoom_button.setText("Zoom")
2245 		self.zoom_button.setDisabled(True)
2246 		self.zoom_button.released.connect(lambda: self.Zoom())
2248 		self.hbox = HBoxLayout(self.back_button, self.forward_button, self.zoom_button, self.point_label)
2250 		self.vbox = VBoxLayout(self.splitter, self.hbox)
2252 		self.setLayout(self.vbox)
2254 	def GetScaleForRangeX(self, xsubrange):  argument
2260 	def GetScaleForRangeY(self, ysubrange):  argument
2266 	def GetScaleForRange(self, subrange):  argument
2268 		xscale = self.GetScaleForRangeX(subrange.x)
2269 		yscale = self.GetScaleForRangeY(subrange.y)
2272 	def PointEvent(self, cpu, time_from, time_to, hregions):  argument
2275 		rel_time_from = time_from - self.glb.StartTime(self.collection.machine_id)
2277 		self.point_label.setText(text)
2278 		self.legend.Highlight(hregions)
2280 	def RightClickEvent(self, cpu, hregion_times, pos):  argument
2281 		if not IsSelectable(self.glb.db, "calls", "WHERE parent_id >= 0"):
2283 		menu = QMenu(self.view)
2287 …text, "Show Call Tree", lambda a=None, args=thread_at_time: self.RightClickSelect(args), self.view…
2290 	def RightClickSelect(self, args):  argument
2291 		CallTreeWindow(self.glb, self.glb.mainwindow, thread_at_time=args)
2293 	def NoPointEvent(self):  argument
2294 		self.point_label.setText("")
2295 		self.legend.Highlight({})
2297 	def RangeEvent(self, time_from, time_to):  argument
2301 			self.point_label.setText("")
2303 		rel_time_from = time_from - self.start_time
2304 		rel_time_to = time_to - self.start_time
2307 		self.point_label.setText(text)
2309 	def BackState(self):  argument
2310 		return (self.attrs.subrange, self.attrs.scale, self.selection_state, self.fwd_rect)
2312 	def PushBackState(self):  argument
2313 		state = copy.deepcopy(self.BackState())
2314 		self.back_state.append(state)
2315 		self.back_button.setEnabled(True)
2317 	def PopBackState(self):  argument
2318 		self.attrs.subrange, self.attrs.scale, self.selection_state, self.fwd_rect = self.back_state.pop()
2319 		self.attrs.Update()
2320 		if not self.back_state:
2321 			self.back_button.setDisabled(True)
2323 	def PushForwardState(self):  argument
2324 		state = copy.deepcopy(self.BackState())
2325 		self.forward_state.append(state)
2326 		self.forward_button.setEnabled(True)
2328 	def PopForwardState(self):  argument
2329 …self.attrs.subrange, self.attrs.scale, self.selection_state, self.fwd_rect = self.forward_state.po…
2330 		self.attrs.Update()
2331 		if not self.forward_state:
2332 			self.forward_button.setDisabled(True)
2334 	def Title(self):  argument
2335 		time_from = self.collection.xrangelo + Decimal(self.attrs.subrange.x.lo)
2336 		time_to = self.collection.xrangelo + Decimal(self.attrs.subrange.x.hi)
2337 		rel_time_from = time_from - self.start_time
2338 		rel_time_to = time_to - self.start_time
2343 	def Update(self):  argument
2344 		selected_subrange, selection_state = self.selection_state
2345 		self.item.SetSelection(selection_state)
2346 		self.item.SetBracket(self.fwd_rect)
2347 		self.zoom_button.setDisabled(selected_subrange is None)
2348 		self.GraphTitleChanged(self.Title())
2349 		self.item.update(self.item.boundingRect())
2351 	def Back(self):  argument
2352 		if not self.back_state:
2354 		self.PushForwardState()
2355 		self.PopBackState()
2356 		self.Update()
2358 	def Forward(self):  argument
2359 		if not self.forward_state:
2361 		self.PushBackState()
2362 		self.PopForwardState()
2363 		self.Update()
2365 	def SelectEvent(self, x0, x1, selection_state):  argument
2372 		self.selection_state = (selected_subrange, selection_state)
2373 		self.zoom_button.setDisabled(selected_subrange is None)
2375 	def Zoom(self):  argument
2376 		selected_subrange, selection_state = self.selection_state
2379 		self.fwd_rect = selection_state
2380 		self.item.SetSelection(None)
2381 		self.PushBackState()
2382 		self.attrs.subrange.x = selected_subrange
2383 		self.forward_state = []
2384 		self.forward_button.setDisabled(True)
2385 		self.selection_state = (None, None)
2386 		self.fwd_rect = None
2387 		self.attrs.scale.x = self.GetScaleForRangeX(self.attrs.subrange.x)
2388 		self.attrs.Update()
2389 		self.Update()
2395 	def __init__(self, glb, title, init_fn):  argument
2396 		self.init_fn = init_fn
2397 		self.done = False
2398 		self.result = None
2400 		self.msg_box = QMessageBox(glb.mainwindow)
2401 		self.msg_box.setText("Initializing " + title + ". Please wait.")
2402 		self.msg_box.setWindowTitle("Initializing " + title)
2403 		self.msg_box.setWindowIcon(glb.mainwindow.style().standardIcon(QStyle.SP_MessageBoxInformation))
2405 		self.init_thread = Thread(self.ThreadFn, glb)
2406 		self.init_thread.done.connect(lambda: self.Done(), Qt.QueuedConnection)
2408 		self.init_thread.start()
2410 	def Done(self):  argument
2411 		self.msg_box.done(0)
2413 	def ThreadFn(self, glb):  argument
2416 		self.result = self.init_fn(db)
2417 		self.done = True
2420 	def Result(self):  argument
2421 		while not self.done:
2422 			self.msg_box.exec_()
2423 		self.init_thread.wait()
2424 		return self.result
2434 	def __init__(self, glb, parent=None):  argument
2435 		super(TimeChartByCPUWindow, self).__init__(parent)
2437 		self.glb = glb
2438 		self.machine_id = glb.HostMachineId()
2439 		self.collection_name = "SwitchGraphDataCollection " + str(self.machine_id)
2441 		collection = LookupModel(self.collection_name)
2443 			collection = SlowInit(glb, "Time Chart", self.Init)
2445 		self.widget = SwitchGraphWidget(glb, collection, self)
2446 		self.view = self.widget
2448 		self.base_title = "Time Chart by CPU"
2449 		self.setWindowTitle(self.base_title + self.widget.Title())
2450 		self.widget.graph_title_changed.connect(self.GraphTitleChanged)
2452 		self.setWidget(self.widget)
2454 		AddSubWindow(glb.mainwindow.mdi_area, self, self.windowTitle())
2456 	def Init(self, db):  argument
2457 …return LookupCreateModel(self.collection_name, lambda : SwitchGraphDataCollection(self.glb, db, se…
2459 	def GraphTitleChanged(self, title):  argument
2460 		self.setWindowTitle(self.base_title + " : " + title)
2466 	def __init__(self, root):  argument
2467 		self.root = root
2468 		self.value, self.direction, self.pattern, self.last_value, self.last_pattern = (None,) * 5
2469 		self.rows = []
2470 		self.pos = 0
2472 	def FindSelect(self):  argument
2473 		self.rows = []
2474 		if self.pattern:
2475 			pattern = re.compile(self.value)
2476 			for child in self.root.child_items:
2479 						self.rows.append(child.row)
2482 			for child in self.root.child_items:
2484 					if self.value in str(column_data):
2485 						self.rows.append(child.row)
2488 	def FindValue(self):  argument
2489 		self.pos = 0
2490 		if self.last_value != self.value or self.pattern != self.last_pattern:
2491 			self.FindSelect()
2492 		if not len(self.rows):
2494 		return self.rows[self.pos]
2496 	def FindThread(self):  argument
2497 		if self.direction == 0 or self.value != self.last_value or self.pattern != self.last_pattern:
2498 			row = self.FindValue()
2499 		elif len(self.rows):
2500 			if self.direction > 0:
2501 				self.pos += 1
2502 				if self.pos >= len(self.rows):
2503 					self.pos = 0
2505 				self.pos -= 1
2506 				if self.pos < 0:
2507 					self.pos = len(self.rows) - 1
2508 			row = self.rows[self.pos]
2513 	def Find(self, value, direction, pattern, context, callback):  argument
2514 …self.value, self.direction, self.pattern, self.last_value, self.last_pattern = (value, direction,p…
2516 		thread = Thread(self.FindThread)
2517 …thread.done.connect(lambda row, t=thread, c=callback: self.FindDone(t, c, row), Qt.QueuedConnectio…
2520 	def FindDone(self, thread, callback, row):  argument
2531 …def __init__(self, dbref, sql, buffer, head, tail, fetch_count, fetching_done, process_target, wai…  argument
2534 		self.db, dbname = dbref.Open(conn_name)
2535 		self.sql = sql
2536 		self.buffer = buffer
2537 		self.head = head
2538 		self.tail = tail
2539 		self.fetch_count = fetch_count
2540 		self.fetching_done = fetching_done
2541 		self.process_target = process_target
2542 		self.wait_event = wait_event
2543 		self.fetched_event = fetched_event
2544 		self.prep = prep
2545 		self.query = QSqlQuery(self.db)
2546 		self.query_limit = 0 if "$$last_id$$" in sql else 2
2547 		self.last_id = -1
2548 		self.fetched = 0
2549 		self.more = True
2550 		self.local_head = self.head.value
2551 		self.local_tail = self.tail.value
2553 	def Select(self):  argument
2554 		if self.query_limit:
2555 			if self.query_limit == 1:
2557 			self.query_limit -= 1
2558 		stmt = self.sql.replace("$$last_id$$", str(self.last_id))
2559 		QueryExec(self.query, stmt)
2561 	def Next(self):  argument
2562 		if not self.query.next():
2563 			self.Select()
2564 			if not self.query.next():
2566 		self.last_id = self.query.value(0)
2567 		return self.prep(self.query)
2569 	def WaitForTarget(self):  argument
2571 			self.wait_event.clear()
2572 			target = self.process_target.value
2573 			if target > self.fetched or target < 0:
2575 			self.wait_event.wait()
2578 	def HasSpace(self, sz):  argument
2579 		if self.local_tail <= self.local_head:
2580 			space = len(self.buffer) - self.local_head
2586 				self.buffer[self.local_head : self.local_head + len(nd)] = nd
2587 			self.local_head = 0
2588 		if self.local_tail - self.local_head > sz:
2592 	def WaitForSpace(self, sz):  argument
2593 		if self.HasSpace(sz):
2596 			self.wait_event.clear()
2597 			self.local_tail = self.tail.value
2598 			if self.HasSpace(sz):
2600 			self.wait_event.wait()
2602 	def AddToBuffer(self, obj):  argument
2607 		self.WaitForSpace(sz)
2608 		pos = self.local_head
2609 		self.buffer[pos : pos + len(nd)] = nd
2610 		self.buffer[pos + glb_nsz : pos + sz] = d
2611 		self.local_head += sz
2613 	def FetchBatch(self, batch_size):  argument
2616 			obj = self.Next()
2618 				self.more = False
2620 			self.AddToBuffer(obj)
2623 			self.fetched += fetched
2624 			with self.fetch_count.get_lock():
2625 				self.fetch_count.value += fetched
2626 			self.head.value = self.local_head
2627 			self.fetched_event.set()
2629 	def Run(self):  argument
2630 		while self.more:
2631 			target = self.WaitForTarget()
2634 			batch_size = min(glb_chunk_sz, target - self.fetched)
2635 			self.FetchBatch(batch_size)
2636 		self.fetching_done.value = True
2637 		self.fetched_event.set()
2649 	def __init__(self, glb, sql, prep, process_data, parent=None):  argument
2650 		super(SQLFetcher, self).__init__(parent)
2651 		self.process_data = process_data
2652 		self.more = True
2653 		self.target = 0
2654 		self.last_target = 0
2655 		self.fetched = 0
2656 		self.buffer_size = 16 * 1024 * 1024
2657 		self.buffer = Array(c_char, self.buffer_size, lock=False)
2658 		self.head = Value(c_longlong)
2659 		self.tail = Value(c_longlong)
2660 		self.local_tail = 0
2661 		self.fetch_count = Value(c_longlong)
2662 		self.fetching_done = Value(c_bool)
2663 		self.last_count = 0
2664 		self.process_target = Value(c_longlong)
2665 		self.wait_event = Event()
2666 		self.fetched_event = Event()
2667 		glb.AddInstanceToShutdownOnExit(self)
2668 …self.process = Process(target=SQLFetcherFn, args=(glb.dbref, sql, self.buffer, self.head, self.tai…
2669 		self.process.start()
2670 		self.thread = Thread(self.Thread)
2671 		self.thread.done.connect(self.ProcessData, Qt.QueuedConnection)
2672 		self.thread.start()
2674 	def Shutdown(self):  argument
2676 		self.process_target.value = -1
2677 		self.wait_event.set()
2678 		self.more = False
2679 		self.fetching_done.value = True
2680 		self.fetched_event.set()
2682 	def Thread(self):  argument
2683 		if not self.more:
2686 			self.fetched_event.clear()
2687 			fetch_count = self.fetch_count.value
2688 			if fetch_count != self.last_count:
2690 			if self.fetching_done.value:
2691 				self.more = False
2693 			self.fetched_event.wait()
2694 		count = fetch_count - self.last_count
2695 		self.last_count = fetch_count
2696 		self.fetched += count
2699 	def Fetch(self, nr):  argument
2700 		if not self.more:
2703 		result = self.fetched
2704 		extra = result + nr - self.target
2706 			self.target += extra
2708 			if self.process_target.value >= 0:
2709 				self.process_target.value = self.target
2710 			self.wait_event.set()
2713 	def RemoveFromBuffer(self):  argument
2714 		pos = self.local_tail
2715 		if len(self.buffer) - pos < glb_nsz:
2717 		n = pickle.loads(self.buffer[pos : pos + glb_nsz])
2720 			n = pickle.loads(self.buffer[0 : glb_nsz])
2722 		obj = pickle.loads(self.buffer[pos : pos + n])
2723 		self.local_tail = pos + n
2726 	def ProcessData(self, count):  argument
2728 			obj = self.RemoveFromBuffer()
2729 			self.process_data(obj)
2730 		self.tail.value = self.local_tail
2731 		self.wait_event.set()
2732 		self.done.emit(count)
2738 	def __init__(self, model, parent):  argument
2739 		self.model = model
2741 		self.label = QLabel("Number of records (x " + "{:,}".format(glb_chunk_sz) + ") to fetch:")
2742 		self.label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
2744 		self.fetch_count = QSpinBox()
2745 		self.fetch_count.setRange(1, 1000000)
2746 		self.fetch_count.setValue(10)
2747 		self.fetch_count.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
2749 		self.fetch = QPushButton("Go!")
2750 		self.fetch.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
2751 		self.fetch.released.connect(self.FetchMoreRecords)
2753 		self.progress = QProgressBar()
2754 		self.progress.setRange(0, 100)
2755 		self.progress.hide()
2757 		self.done_label = QLabel("All records fetched")
2758 		self.done_label.hide()
2760 		self.spacer = QLabel("")
2762 		self.close_button = QToolButton()
2763 		self.close_button.setIcon(parent.style().standardIcon(QStyle.SP_DockWidgetCloseButton))
2764 		self.close_button.released.connect(self.Deactivate)
2766 		self.hbox = QHBoxLayout()
2767 		self.hbox.setContentsMargins(0, 0, 0, 0)
2769 		self.hbox.addWidget(self.label)
2770 		self.hbox.addWidget(self.fetch_count)
2771 		self.hbox.addWidget(self.fetch)
2772 		self.hbox.addWidget(self.spacer)
2773 		self.hbox.addWidget(self.progress)
2774 		self.hbox.addWidget(self.done_label)
2775 		self.hbox.addWidget(self.close_button)
2777 		self.bar = QWidget()
2778 		self.bar.setLayout(self.hbox)
2779 		self.bar.show()
2781 		self.in_progress = False
2782 		self.model.progress.connect(self.Progress)
2784 		self.done = False
2787 			self.Done()
2789 	def Widget(self):  argument
2790 		return self.bar
2792 	def Activate(self):  argument
2793 		self.bar.show()
2794 		self.fetch.setFocus()
2796 	def Deactivate(self):  argument
2797 		self.bar.hide()
2799 	def Enable(self, enable):  argument
2800 		self.fetch.setEnabled(enable)
2801 		self.fetch_count.setEnabled(enable)
2803 	def Busy(self):  argument
2804 		self.Enable(False)
2805 		self.fetch.hide()
2806 		self.spacer.hide()
2807 		self.progress.show()
2809 	def Idle(self):  argument
2810 		self.in_progress = False
2811 		self.Enable(True)
2812 		self.progress.hide()
2813 		self.fetch.show()
2814 		self.spacer.show()
2816 	def Target(self):  argument
2817 		return self.fetch_count.value() * glb_chunk_sz
2819 	def Done(self):  argument
2820 		self.done = True
2821 		self.Idle()
2822 		self.label.hide()
2823 		self.fetch_count.hide()
2824 		self.fetch.hide()
2825 		self.spacer.hide()
2826 		self.done_label.show()
2828 	def Progress(self, count):  argument
2829 		if self.in_progress:
2831 				percent = ((count - self.start) * 100) / self.Target()
2833 					self.Idle()
2835 					self.progress.setValue(percent)
2838 			self.Done()
2840 	def FetchMoreRecords(self):  argument
2841 		if self.done:
2843 		self.progress.setValue(0)
2844 		self.Busy()
2845 		self.in_progress = True
2846 		self.start = self.model.FetchMoreRecords(self.Target())
2852 	def __init__(self, row, col, text, parent_item):  argument
2853 		self.row = row
2854 		self.parent_item = parent_item
2855 		self.data = [""] * (col + 1)
2856 		self.data[col] = text
2857 		self.level = 2
2859 	def getParentItem(self):  argument
2860 		return self.parent_item
2862 	def getRow(self):  argument
2863 		return self.row
2865 	def childCount(self):  argument
2868 	def hasChildren(self):  argument
2871 	def getData(self, column):  argument
2872 		return self.data[column]
2878 	def __init__(self, glb, row, data, parent_item):  argument
2879 		self.glb = glb
2880 		self.row = row
2881 		self.parent_item = parent_item
2882 		self.child_count = 0
2883 		self.child_items = []
2884 		self.data = data[1:]
2885 		self.dbid = data[0]
2886 		self.level = 1
2887 		self.query_done = False
2888 		self.br_col = len(self.data) - 1
2890 	def getChildItem(self, row):  argument
2891 		return self.child_items[row]
2893 	def getParentItem(self):  argument
2894 		return self.parent_item
2896 	def getRow(self):  argument
2897 		return self.row
2899 	def Select(self):  argument
2900 		self.query_done = True
2902 		if not self.glb.have_disassembler:
2905 		query = QSqlQuery(self.glb.db)
2911 				  " WHERE samples.id = " + str(self.dbid))
2929 				  " WHERE samples.id > " + str(self.dbid) + " AND cpu = " + str(cpu) +
2946 		inst = self.glb.disassembler.Instruction()
2947 		f = self.glb.FileFromNamesAndBuildId(short_name, long_name, build_id)
2951 		self.glb.disassembler.SetMode(inst, mode)
2960 			cnt, text = self.glb.disassembler.DisassembleOne(inst, buf_ptr, buf_sz, ip)
2969 				self.child_items.append(BranchLevelTwoItem(0, self.br_col, byte_str + " " + text, self))
2970 				self.child_count += 1
2978 	def childCount(self):  argument
2979 		if not self.query_done:
2980 			self.Select()
2981 			if not self.child_count:
2983 		return self.child_count
2985 	def hasChildren(self):  argument
2986 		if not self.query_done:
2988 		return self.child_count > 0
2990 	def getData(self, column):  argument
2991 		return self.data[column]
2997 	def __init__(self):  argument
2998 		self.child_count = 0
2999 		self.child_items = []
3000 		self.level = 0
3002 	def getChildItem(self, row):  argument
3003 		return self.child_items[row]
3005 	def getParentItem(self):  argument
3008 	def getRow(self):  argument
3011 	def childCount(self):  argument
3012 		return self.child_count
3014 	def hasChildren(self):  argument
3015 		return self.child_count > 0
3017 	def getData(self, column):  argument
3088 	def __init__(self, glb, event_id, where_clause, parent=None):  argument
3089 		super(BranchModel, self).__init__(glb, None, parent)
3090 		self.event_id = event_id
3091 		self.more = True
3092 		self.populated = 0
3093 		self.have_ipc = IsSelectable(glb.db, "samples", columns = "insn_count, cyc_count")
3094 		if self.have_ipc:
3116 			" AND evsel_id = " + str(self.event_id) +
3123 		self.fetcher = SQLFetcher(glb, sql, prep, self.AddSample)
3124 		self.fetcher.done.connect(self.Update)
3125 		self.fetcher.Fetch(glb_chunk_sz)
3127 	def GetRoot(self):  argument
3130 	def columnCount(self, parent=None):  argument
3131 		if self.have_ipc:
3136 	def columnHeader(self, column):  argument
3137 		if self.have_ipc:
3142 	def columnFont(self, column):  argument
3143 		if self.have_ipc:
3151 	def DisplayData(self, item, index):  argument
3153 			self.FetchIfNeeded(item.row)
3156 	def AddSample(self, data):  argument
3157 		child = BranchLevelOneItem(self.glb, self.populated, data, self.root)
3158 		self.root.child_items.append(child)
3159 		self.populated += 1
3161 	def Update(self, fetched):  argument
3163 			self.more = False
3164 			self.progress.emit(0)
3165 		child_count = self.root.child_count
3166 		count = self.populated - child_count
3169 			self.beginInsertRows(parent, child_count, child_count + count - 1)
3170 			self.insertRows(child_count, count, parent)
3171 			self.root.child_count += count
3172 			self.endInsertRows()
3173 			self.progress.emit(self.root.child_count)
3175 	def FetchMoreRecords(self, count):  argument
3176 		current = self.root.child_count
3177 		if self.more:
3178 			self.fetcher.Fetch(count)
3180 			self.progress.emit(0)
3183 	def HasMoreRecords(self):  argument
3184 		return self.more
3190 	def __init__(self, name = "", where_clause = "", limit = ""):  argument
3191 		self.name = name
3192 		self.where_clause = where_clause
3193 		self.limit = limit
3195 	def UniqueId(self):  argument
3196 		return str(self.where_clause + ";" + self.limit)
3202 	def __init__(self, glb, event_id, report_vars, parent=None):  argument
3203 		super(BranchWindow, self).__init__(parent)
3207 …self.model = LookupCreateModel(model_name, lambda: BranchModel(glb, event_id, report_vars.where_cl…
3209 		self.view = QTreeView()
3210 		self.view.setUniformRowHeights(True)
3211 		self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
3212 		self.view.CopyCellsToClipboard = CopyTreeCellsToClipboard
3213 		self.view.setModel(self.model)
3215 		self.ResizeColumnsToContents()
3217 		self.context_menu = TreeContextMenu(self.view)
3219 		self.find_bar = FindBar(self, self, True)
3221 		self.finder = ChildDataItemFinder(self.model.root)
3223 		self.fetch_bar = FetchMoreRecordsBar(self.model, self)
3225 		self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())
3227 		self.setWidget(self.vbox.Widget())
3229 		AddSubWindow(glb.mainwindow.mdi_area, self, report_vars.name + " Branch Events")
3231 	def ResizeColumnToContents(self, column, n):  argument
3235 		font = self.view.font()
3239 			val = self.model.root.child_items[row].data[column]
3242 		val = self.model.columnHeader(column)
3245 		self.view.setColumnWidth(column, max)
3247 	def ResizeColumnsToContents(self):  argument
3248 		n = min(self.model.root.child_count, 100)
3251 			self.model.rowsInserted.connect(self.UpdateColumnWidths)
3253 		columns = self.model.columnCount()
3255 			self.ResizeColumnToContents(i, n)
3257 	def UpdateColumnWidths(self, *x):  argument
3259 		self.model.rowsInserted.disconnect(self.UpdateColumnWidths)
3260 		self.ResizeColumnsToContents()
3262 	def Find(self, value, direction, pattern, context):  argument
3263 		self.view.setFocus()
3264 		self.find_bar.Busy()
3265 		self.finder.Find(value, direction, pattern, context, self.FindDone)
3267 	def FindDone(self, row):  argument
3268 		self.find_bar.Idle()
3270 			self.view.setCurrentIndex(self.model.index(row, 0, QModelIndex()))
3272 			self.find_bar.NotFound()
3278 	def __init__(self, glb, label, placeholder_text, parent, id = "", default = ""):  argument
3279 		self.glb = glb
3280 		self.label = label
3281 		self.placeholder_text = placeholder_text
3282 		self.parent = parent
3283 		self.id = id
3285 		self.value = default
3287 		self.widget = QLineEdit(default)
3288 		self.widget.editingFinished.connect(self.Validate)
3289 		self.widget.textChanged.connect(self.Invalidate)
3290 		self.red = False
3291 		self.error = ""
3292 		self.validated = True
3295 			self.widget.setPlaceholderText(placeholder_text)
3297 	def TurnTextRed(self):  argument
3298 		if not self.red:
3301 			self.widget.setPalette(palette)
3302 			self.red = True
3304 	def TurnTextNormal(self):  argument
3305 		if self.red:
3307 			self.widget.setPalette(palette)
3308 			self.red = False
3310 	def InvalidValue(self, value):  argument
3311 		self.value = ""
3312 		self.TurnTextRed()
3313 		self.error = self.label + " invalid value '" + value + "'"
3314 		self.parent.ShowMessage(self.error)
3316 	def Invalidate(self):  argument
3317 		self.validated = False
3319 	def DoValidate(self, input_string):  argument
3320 		self.value = input_string.strip()
3322 	def Validate(self):  argument
3323 		self.validated = True
3324 		self.error = ""
3325 		self.TurnTextNormal()
3326 		self.parent.ClearMessage()
3327 		input_string = self.widget.text()
3329 			self.value = ""
3331 		self.DoValidate(input_string)
3333 	def IsValid(self):  argument
3334 		if not self.validated:
3335 			self.Validate()
3336 		if len(self.error):
3337 			self.parent.ShowMessage(self.error)
3341 	def IsNumber(self, value):  argument
3352 	def __init__(self, glb, label, placeholder_text, column_name, parent):  argument
3353 		super(NonNegativeIntegerRangesDataItem, self).__init__(glb, label, placeholder_text, parent)
3355 		self.column_name = column_name
3357 	def DoValidate(self, input_string):  argument
3363 				if len(vrange) != 2 or not self.IsNumber(vrange[0]) or not self.IsNumber(vrange[1]):
3364 					return self.InvalidValue(value)
3367 				if not self.IsNumber(value):
3368 					return self.InvalidValue(value)
3370 …ranges = [("(" + self.column_name + " >= " + r[0] + " AND " + self.column_name + " <= " + r[1] + "…
3372 			ranges.append(self.column_name + " IN (" + ",".join(singles) + ")")
3373 		self.value = " OR ".join(ranges)
3379 	def __init__(self, glb, label, placeholder_text, parent, id = "", default = ""):  argument
3380 		super(PositiveIntegerDataItem, self).__init__(glb, label, placeholder_text, parent, id, default)
3382 	def DoValidate(self, input_string):  argument
3383 		if not self.IsNumber(input_string.strip()):
3384 			return self.InvalidValue(input_string)
3387 			return self.InvalidValue(input_string)
3388 		self.value = str(value)
3394 …def __init__(self, glb, label, placeholder_text, table_name, match_column, column_name1, column_na…  argument
3395 		super(SQLTableDataItem, self).__init__(glb, label, placeholder_text, parent)
3397 		self.table_name = table_name
3398 		self.match_column = match_column
3399 		self.column_name1 = column_name1
3400 		self.column_name2 = column_name2
3402 	def ValueToIds(self, value):  argument
3404 		query = QSqlQuery(self.glb.db)
3405 		stmt = "SELECT id FROM " + self.table_name + " WHERE " + self.match_column + " = '" + value + "'"
3412 	def DoValidate(self, input_string):  argument
3415 			ids = self.ValueToIds(value)
3419 				return self.InvalidValue(value)
3420 		self.value = self.column_name1 + " IN (" + ",".join(all_ids) + ")"
3421 		if self.column_name2:
3422 			self.value = "( " + self.value + " OR " + self.column_name2 + " IN (" + ",".join(all_ids) + ") )"
3428 	def __init__(self, glb, label, placeholder_text, column_name, parent):  argument
3429 		self.column_name = column_name
3431 		self.last_id = 0
3432 		self.first_time = 0
3433 		self.last_time = 2 ** 64
3438 			self.last_id = int(query.value(0))
3439 		self.first_time = int(glb.HostStartTime())
3440 		self.last_time = int(glb.HostFinishTime())
3442 			placeholder_text += ", between " + str(self.first_time) + " and " + str(self.last_time)
3444 		super(SampleTimeRangesDataItem, self).__init__(glb, label, placeholder_text, parent)
3446 	def IdBetween(self, query, lower_id, higher_id, order):  argument
3453 	def BinarySearchTime(self, lower_id, higher_id, target_time, get_floor):  argument
3454 		query = QSqlQuery(self.glb.db)
3459 				ok, dbid = self.IdBetween(query, lower_id, next_id, "DESC")
3461 					ok, dbid = self.IdBetween(query, next_id, higher_id, "")
3482 	def ConvertRelativeTime(self, val):  argument
3494 		if not self.IsNumber(val):
3498 			val += self.first_time
3500 			val += self.last_time
3503 	def ConvertTimeRange(self, vrange):  argument
3505 			vrange[0] = str(self.first_time)
3507 			vrange[1] = str(self.last_time)
3508 		vrange[0] = self.ConvertRelativeTime(vrange[0])
3509 		vrange[1] = self.ConvertRelativeTime(vrange[1])
3510 		if not self.IsNumber(vrange[0]) or not self.IsNumber(vrange[1]):
3512 		beg_range = max(int(vrange[0]), self.first_time)
3513 		end_range = min(int(vrange[1]), self.last_time)
3514 		if beg_range > self.last_time or end_range < self.first_time:
3516 		vrange[0] = self.BinarySearchTime(0, self.last_id, beg_range, True)
3517 		vrange[1] = self.BinarySearchTime(1, self.last_id + 1, end_range, False)
3520 	def AddTimeRange(self, value, ranges):  argument
3533 		if self.ConvertTimeRange(vrange):
3538 	def DoValidate(self, input_string):  argument
3541 			if not self.AddTimeRange(value, ranges):
3542 				return self.InvalidValue(value)
3543 …ranges = [("(" + self.column_name + " >= " + r[0] + " AND " + self.column_name + " <= " + r[1] + "…
3544 		self.value = " OR ".join(ranges)
3550 	def __init__(self, glb, title, items, partial, parent=None):  argument
3551 		super(ReportDialogBase, self).__init__(parent)
3553 		self.glb = glb
3555 		self.report_vars = ReportVars()
3557 		self.setWindowTitle(title)
3558 		self.setMinimumWidth(600)
3560 		self.data_items = [x(glb, self) for x in items]
3562 		self.partial = partial
3564 		self.grid = QGridLayout()
3566 		for row in xrange(len(self.data_items)):
3567 			self.grid.addWidget(QLabel(self.data_items[row].label), row, 0)
3568 			self.grid.addWidget(self.data_items[row].widget, row, 1)
3570 		self.status = QLabel()
3572 		self.ok_button = QPushButton("Ok", self)
3573 		self.ok_button.setDefault(True)
3574 		self.ok_button.released.connect(self.Ok)
3575 		self.ok_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
3577 		self.cancel_button = QPushButton("Cancel", self)
3578 		self.cancel_button.released.connect(self.reject)
3579 		self.cancel_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
3581 		self.hbox = QHBoxLayout()
3583 		self.hbox.addWidget(self.status)
3584 		self.hbox.addWidget(self.ok_button)
3585 		self.hbox.addWidget(self.cancel_button)
3587 		self.vbox = QVBoxLayout()
3588 		self.vbox.addLayout(self.grid)
3589 		self.vbox.addLayout(self.hbox)
3591 		self.setLayout(self.vbox)
3593 	def Ok(self):  argument
3594 		vars = self.report_vars
3595 		for d in self.data_items:
3599 			self.ShowMessage("Report name is required")
3601 		for d in self.data_items:
3604 		for d in self.data_items[1:]:
3612 			if self.partial:
3616 		self.accept()
3618 	def ShowMessage(self, msg):  argument
3619 		self.status.setText("<font color=#FF0000>" + msg)
3621 	def ClearMessage(self):  argument
3622 		self.status.setText("")
3628 	def __init__(self, glb, parent=None):  argument
3639 		super(SelectedBranchDialog, self).__init__(glb, title, items, True, parent)
3665 	def __init__(self, row, data):  argument
3666 		self.row = row
3667 		self.data = data
3669 	def getData(self, column):  argument
3670 		return self.data[column]
3678 	def __init__(self, glb, sql, column_headers, parent=None):  argument
3679 		super(SQLTableModel, self).__init__(parent)
3680 		self.glb = glb
3681 		self.more = True
3682 		self.populated = 0
3683 		self.column_headers = column_headers
3684 …self.fetcher = SQLFetcher(glb, sql, lambda x, y=len(column_headers): self.SQLTableDataPrep(x, y), …
3685 		self.fetcher.done.connect(self.Update)
3686 		self.fetcher.Fetch(glb_chunk_sz)
3688 	def DisplayData(self, item, index):  argument
3689 		self.FetchIfNeeded(item.row)
3692 	def AddSample(self, data):  argument
3693 		child = SQLTableItem(self.populated, data)
3694 		self.child_items.append(child)
3695 		self.populated += 1
3697 	def Update(self, fetched):  argument
3699 			self.more = False
3700 			self.progress.emit(0)
3701 		child_count = self.child_count
3702 		count = self.populated - child_count
3705 			self.beginInsertRows(parent, child_count, child_count + count - 1)
3706 			self.insertRows(child_count, count, parent)
3707 			self.child_count += count
3708 			self.endInsertRows()
3709 			self.progress.emit(self.child_count)
3711 	def FetchMoreRecords(self, count):  argument
3712 		current = self.child_count
3713 		if self.more:
3714 			self.fetcher.Fetch(count)
3716 			self.progress.emit(0)
3719 	def HasMoreRecords(self):  argument
3720 		return self.more
3722 	def columnCount(self, parent=None):  argument
3723 		return len(self.column_headers)
3725 	def columnHeader(self, column):  argument
3726 		return self.column_headers[column]
3728 	def SQLTableDataPrep(self, query, count):  argument
3738 	def __init__(self, glb, table_name, parent=None):  argument
3764 				self.SQLTableDataPrep = self.samples_view_DataPrep
3766 				self.SQLTableDataPrep = self.samples_DataPrep
3767 		super(SQLAutoTableModel, self).__init__(glb, sql, column_headers, parent)
3769 	def samples_view_DataPrep(self, query, count):  argument
3778 	def samples_DataPrep(self, query, count):  argument
3792 	def __init__(self, parent=None):  argument
3793 		super(ResizeColumnsToContentsBase, self).__init__(parent)
3795 	def ResizeColumnToContents(self, column, n):  argument
3798 		font = self.view.font()
3802 			val = self.data_model.child_items[row].data[column]
3805 		val = self.data_model.columnHeader(column)
3808 		self.view.setColumnWidth(column, max)
3810 	def ResizeColumnsToContents(self):  argument
3811 		n = min(self.data_model.child_count, 100)
3814 			self.data_model.rowsInserted.connect(self.UpdateColumnWidths)
3816 		columns = self.data_model.columnCount()
3818 			self.ResizeColumnToContents(i, n)
3820 	def UpdateColumnWidths(self, *x):  argument
3822 		self.data_model.rowsInserted.disconnect(self.UpdateColumnWidths)
3823 		self.ResizeColumnsToContents()
4030 	def __init__(self, view):  argument
4031 		self.view = view
4032 		self.view.setContextMenuPolicy(Qt.CustomContextMenu)
4033 		self.view.customContextMenuRequested.connect(self.ShowContextMenu)
4035 	def ShowContextMenu(self, pos):  argument
4036 		menu = QMenu(self.view)
4037 		self.AddActions(menu)
4038 		menu.exec_(self.view.mapToGlobal(pos))
4040 	def AddCopy(self, menu):  argument
4041 …ion("&Copy selection", "Copy to clipboard", lambda: CopyCellsToClipboardHdr(self.view), self.view))
4042 …ction as CS&V", "Copy to clipboard as CSV", lambda: CopyCellsToClipboardCSV(self.view), self.view))
4044 	def AddActions(self, menu):  argument
4045 		self.AddCopy(menu)
4049 	def __init__(self, view):  argument
4050 		super(TreeContextMenu, self).__init__(view)
4052 	def AddActions(self, menu):  argument
4053 		i = self.view.currentIndex()
4056 …y "' + text + '"', "Copy to clipboard", lambda: QApplication.clipboard().setText(text), self.view))
4057 		self.AddCopy(menu)
4063 	def __init__(self, glb, table_name, parent=None):  argument
4064 		super(TableWindow, self).__init__(parent)
4066 …self.data_model = LookupCreateModel(table_name + " Table", lambda: SQLAutoTableModel(glb, table_na…
4068 		self.model = QSortFilterProxyModel()
4069 		self.model.setSourceModel(self.data_model)
4071 		self.view = QTableView()
4072 		self.view.setModel(self.model)
4073 		self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
4074 		self.view.verticalHeader().setVisible(False)
4075 		self.view.sortByColumn(-1, Qt.AscendingOrder)
4076 		self.view.setSortingEnabled(True)
4077 		self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
4078 		self.view.CopyCellsToClipboard = CopyTableCellsToClipboard
4080 		self.ResizeColumnsToContents()
4082 		self.context_menu = ContextMenu(self.view)
4084 		self.find_bar = FindBar(self, self, True)
4086 		self.finder = ChildDataItemFinder(self.data_model)
4088 		self.fetch_bar = FetchMoreRecordsBar(self.data_model, self)
4090 		self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())
4092 		self.setWidget(self.vbox.Widget())
4094 		AddSubWindow(glb.mainwindow.mdi_area, self, table_name + " Table")
4096 	def Find(self, value, direction, pattern, context):  argument
4097 		self.view.setFocus()
4098 		self.find_bar.Busy()
4099 		self.finder.Find(value, direction, pattern, context, self.FindDone)
4101 	def FindDone(self, row):  argument
4102 		self.find_bar.Idle()
4104 			self.view.setCurrentIndex(self.model.mapFromSource(self.data_model.index(row, 0, QModelIndex())))
4106 			self.find_bar.NotFound()
4131 	def __init__(self, glb, report_vars, parent=None):  argument
4161 …self.alignment = (Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLe…
4162 		super(TopCallsModel, self).__init__(glb, sql, column_headers, parent)
4164 	def columnAlignment(self, column):  argument
4165 		return self.alignment[column]
4171 	def __init__(self, glb, parent=None):  argument
4181 		super(TopCallsDialog, self).__init__(glb, title, items, False, parent)
4187 	def __init__(self, glb, report_vars, parent=None):  argument
4188 		super(TopCallsWindow, self).__init__(parent)
4190 …self.data_model = LookupCreateModel("Top Calls " + report_vars.UniqueId(), lambda: TopCallsModel(g…
4191 		self.model = self.data_model
4193 		self.view = QTableView()
4194 		self.view.setModel(self.model)
4195 		self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
4196 		self.view.verticalHeader().setVisible(False)
4197 		self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
4198 		self.view.CopyCellsToClipboard = CopyTableCellsToClipboard
4200 		self.context_menu = ContextMenu(self.view)
4202 		self.ResizeColumnsToContents()
4204 		self.find_bar = FindBar(self, self, True)
4206 		self.finder = ChildDataItemFinder(self.model)
4208 		self.fetch_bar = FetchMoreRecordsBar(self.data_model, self)
4210 		self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())
4212 		self.setWidget(self.vbox.Widget())
4214 		AddSubWindow(glb.mainwindow.mdi_area, self, report_vars.name)
4216 	def Find(self, value, direction, pattern, context):  argument
4217 		self.view.setFocus()
4218 		self.find_bar.Busy()
4219 		self.finder.Find(value, direction, pattern, context, self.FindDone)
4221 	def FindDone(self, row):  argument
4222 		self.find_bar.Idle()
4224 			self.view.setCurrentIndex(self.model.index(row, 0, QModelIndex()))
4226 			self.find_bar.NotFound()
4267 	def __init__(self, mdi_area, menu):  argument
4268 		self.mdi_area = mdi_area
4269 		self.window_menu = menu.addMenu("&Windows")
4270 		self.close_active_window = CreateCloseActiveWindowAction(mdi_area)
4271 		self.close_all_windows = CreateCloseAllWindowsAction(mdi_area)
4272 		self.tile_windows = CreateTileWindowsAction(mdi_area)
4273 		self.cascade_windows = CreateCascadeWindowsAction(mdi_area)
4274 		self.next_window = CreateNextWindowAction(mdi_area)
4275 		self.previous_window = CreatePreviousWindowAction(mdi_area)
4276 		self.window_menu.aboutToShow.connect(self.Update)
4278 	def Update(self):  argument
4279 		self.window_menu.clear()
4280 		sub_window_count = len(self.mdi_area.subWindowList())
4282 		self.close_active_window.setEnabled(have_sub_windows)
4283 		self.close_all_windows.setEnabled(have_sub_windows)
4284 		self.tile_windows.setEnabled(have_sub_windows)
4285 		self.cascade_windows.setEnabled(have_sub_windows)
4286 		self.next_window.setEnabled(have_sub_windows)
4287 		self.previous_window.setEnabled(have_sub_windows)
4288 		self.window_menu.addAction(self.close_active_window)
4289 		self.window_menu.addAction(self.close_all_windows)
4290 		self.window_menu.addSeparator()
4291 		self.window_menu.addAction(self.tile_windows)
4292 		self.window_menu.addAction(self.cascade_windows)
4293 		self.window_menu.addSeparator()
4294 		self.window_menu.addAction(self.next_window)
4295 		self.window_menu.addAction(self.previous_window)
4298 		self.window_menu.addSeparator()
4300 		for sub_window in self.mdi_area.subWindowList():
4304 			action = self.window_menu.addAction(label)
4306 			action.setChecked(sub_window == self.mdi_area.activeSubWindow())
4307 			action.triggered.connect(lambda a=None,x=nr: self.setActiveSubWindow(x))
4308 			self.window_menu.addAction(action)
4311 	def setActiveSubWindow(self, nr):  argument
4312 		self.mdi_area.setActiveSubWindow(self.mdi_area.subWindowList()[nr - 1])
4465 	def __init__(self, glb, parent=None):  argument
4466 		super(HelpWindow, self).__init__(parent)
4468 		self.text = QTextBrowser()
4469 		self.text.setHtml(glb_help_text)
4470 		self.text.setReadOnly(True)
4471 		self.text.setOpenExternalLinks(True)
4473 		self.setWidget(self.text)
4475 		AddSubWindow(glb.mainwindow.mdi_area, self, "Exported SQL Viewer Help")
4481 	def __init__(self, parent=None):  argument
4482 		super(HelpOnlyWindow, self).__init__(parent)
4484 		self.setMinimumSize(200, 100)
4485 		self.resize(800, 600)
4486 		self.setWindowTitle("Exported SQL Viewer Help")
4487 		self.setWindowIcon(self.style().standardIcon(QStyle.SP_MessageBoxInformation))
4489 		self.text = QTextBrowser()
4490 		self.text.setHtml(glb_help_text)
4491 		self.text.setReadOnly(True)
4492 		self.text.setOpenExternalLinks(True)
4494 		self.setCentralWidget(self.text)
4522 	def __init__(self, glb, parent=None):  argument
4523 		super(AboutDialog, self).__init__(parent)
4525 		self.setWindowTitle("About Exported SQL Viewer")
4526 		self.setMinimumWidth(300)
4540 		self.text = QTextBrowser()
4541 		self.text.setHtml(text)
4542 		self.text.setReadOnly(True)
4543 		self.text.setOpenExternalLinks(True)
4545 		self.vbox = QVBoxLayout()
4546 		self.vbox.addWidget(self.text)
4548 		self.setLayout(self.vbox)
4601 	def __init__(self, glb, parent=None):  argument
4602 		super(MainWindow, self).__init__(parent)
4604 		self.glb = glb
4606 		self.setWindowTitle("Exported SQL Viewer: " + glb.dbname)
4607 		self.setWindowIcon(self.style().standardIcon(QStyle.SP_ComputerIcon))
4608 		self.setMinimumSize(200, 100)
4610 		self.mdi_area = QMdiArea()
4611 		self.mdi_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
4612 		self.mdi_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
4614 		self.setCentralWidget(self.mdi_area)
4616 		menu = self.menuBar()
4619 		file_menu.addAction(CreateExitAction(glb.app, self))
4622 …edit_menu.addAction(CreateAction("&Copy", "Copy to clipboard", self.CopyToClipboard, self, QKeySeq…
4623 ….addAction(CreateAction("Copy as CS&V", "Copy to clipboard as CSV", self.CopyToClipboardCSV, self))
4624 		edit_menu.addAction(CreateAction("&Find...", "Find items", self.Find, self, QKeySequence.Find))
4625 …n(CreateAction("Fetch &more records...", "Fetch more records", self.FetchMoreRecords, self, [QKeyS…
4626 …edit_menu.addAction(CreateAction("&Shrink Font", "Make text smaller", self.ShrinkFont, self, [QKey…
4627 …edit_menu.addAction(CreateAction("&Enlarge Font", "Make text bigger", self.EnlargeFont, self, [QKe…
4631 …&Graph", "Create a new window containing a context-sensitive call graph", self.NewCallGraph, self))
4634 …n(CreateAction("Call &Tree", "Create a new window containing a call tree", self.NewCallTree, self))
4636 		self.EventMenu(GetEventList(glb.db), reports_menu)
4639 …elapsed time", "Create a new window displaying top calls by elapsed time", self.NewTopCalls, self))
4643 …ime chart by CPU", "Create a new window displaying time charts by CPU", self.TimeChartByCPU, self))
4645 		self.TableMenu(GetTableList(glb), menu)
4647 		self.window_menu = WindowMenu(self.mdi_area, menu)
4650 …ion(CreateAction("&Exported SQL Viewer Help", "Helpful information", self.Help, self, QKeySequence…
4651 …u.addAction(CreateAction("&About Exported SQL Viewer", "About this application", self.About, self))
4653 	def Try(self, fn):  argument
4654 		win = self.mdi_area.activeSubWindow()
4661 	def CopyToClipboard(self):  argument
4662 		self.Try(CopyCellsToClipboardHdr)
4664 	def CopyToClipboardCSV(self):  argument
4665 		self.Try(CopyCellsToClipboardCSV)
4667 	def Find(self):  argument
4668 		win = self.mdi_area.activeSubWindow()
4675 	def FetchMoreRecords(self):  argument
4676 		win = self.mdi_area.activeSubWindow()
4683 	def ShrinkFont(self):  argument
4684 		self.Try(ShrinkFont)
4686 	def EnlargeFont(self):  argument
4687 		self.Try(EnlargeFont)
4689 	def EventMenu(self, events, reports_menu):  argument
4701 …"Create a new window displaying branch events", lambda a=None,x=dbid: self.NewBranchView(x), self))
4703 …a new window displaying branch events", lambda a=None,x=dbid: self.NewSelectedBranchView(x), self))
4705 	def TimeChartByCPU(self):  argument
4706 		TimeChartByCPUWindow(self.glb, self)
4708 	def TableMenu(self, tables, menu):  argument
4711 … "Create a new window containing a table view", lambda a=None,t=table: self.NewTableView(t), self))
4713 	def NewCallGraph(self):  argument
4714 		CallGraphWindow(self.glb, self)
4716 	def NewCallTree(self):  argument
4717 		CallTreeWindow(self.glb, self)
4719 	def NewTopCalls(self):  argument
4720 		dialog = TopCallsDialog(self.glb, self)
4723 			TopCallsWindow(self.glb, dialog.report_vars, self)
4725 	def NewBranchView(self, event_id):  argument
4726 		BranchWindow(self.glb, event_id, ReportVars(), self)
4728 	def NewSelectedBranchView(self, event_id):  argument
4729 		dialog = SelectedBranchDialog(self.glb, self)
4732 			BranchWindow(self.glb, event_id, dialog.report_vars, self)
4734 	def NewTableView(self, table_name):  argument
4735 		TableWindow(self.glb, table_name, self)
4737 	def Help(self):  argument
4738 		HelpWindow(self.glb, self)
4740 	def About(self):  argument
4741 		dialog = AboutDialog(self.glb, self)
4755 	def __init__(self, libxed):  argument
4758 		self.xedd = xedd_t()
4759 		self.xedp = addressof(self.xedd)
4760 		libxed.xed_decoded_inst_zero(self.xedp)
4761 		self.state = xed_state_t()
4762 		self.statep = addressof(self.state)
4764 		self.buffer = create_string_buffer(256)
4765 		self.bufferp = addressof(self.buffer)
4769 	def __init__(self):  argument
4771 			self.libxed = CDLL("libxed.so")
4773 			self.libxed = None
4774 		if not self.libxed:
4775 			self.libxed = CDLL("/usr/local/lib/libxed.so")
4777 		self.xed_tables_init = self.libxed.xed_tables_init
4778 		self.xed_tables_init.restype = None
4779 		self.xed_tables_init.argtypes = []
4781 		self.xed_decoded_inst_zero = self.libxed.xed_decoded_inst_zero
4782 		self.xed_decoded_inst_zero.restype = None
4783 		self.xed_decoded_inst_zero.argtypes = [ c_void_p ]
4785 		self.xed_operand_values_set_mode = self.libxed.xed_operand_values_set_mode
4786 		self.xed_operand_values_set_mode.restype = None
4787 		self.xed_operand_values_set_mode.argtypes = [ c_void_p, c_void_p ]
4789 		self.xed_decoded_inst_zero_keep_mode = self.libxed.xed_decoded_inst_zero_keep_mode
4790 		self.xed_decoded_inst_zero_keep_mode.restype = None
4791 		self.xed_decoded_inst_zero_keep_mode.argtypes = [ c_void_p ]
4793 		self.xed_decode = self.libxed.xed_decode
4794 		self.xed_decode.restype = c_int
4795 		self.xed_decode.argtypes = [ c_void_p, c_void_p, c_uint ]
4797 		self.xed_format_context = self.libxed.xed_format_context
4798 		self.xed_format_context.restype = c_uint
4799 …self.xed_format_context.argtypes = [ c_int, c_void_p, c_void_p, c_int, c_ulonglong, c_void_p, c_vo…
4801 		self.xed_tables_init()
4803 	def Instruction(self):  argument
4804 		return XEDInstruction(self)
4806 	def SetMode(self, inst, mode):  argument
4813 		self.xed_operand_values_set_mode(inst.xedp, inst.statep)
4815 	def DisassembleOne(self, inst, bytes_ptr, bytes_cnt, ip):  argument
4816 		self.xed_decoded_inst_zero_keep_mode(inst.xedp)
4817 		err = self.xed_decode(inst.xedp, bytes_ptr, bytes_cnt)
4821 		ok = self.xed_format_context(2, inst.xedp, inst.bufferp, sizeof(inst.buffer), ip, 0, 0)
4862 	def __init__(self, dbref, db, dbname):  argument
4863 		self.dbref = dbref
4864 		self.db = db
4865 		self.dbname = dbname
4866 		self.home_dir = os.path.expanduser("~")
4867 		self.buildid_dir = os.getenv("PERF_BUILDID_DIR")
4868 		if self.buildid_dir:
4869 			self.buildid_dir += "/.build-id/"
4871 			self.buildid_dir = self.home_dir + "/.debug/.build-id/"
4872 		self.app = None
4873 		self.mainwindow = None
4874 		self.instances_to_shutdown_on_exit = weakref.WeakSet()
4876 			self.disassembler = LibXED()
4877 			self.have_disassembler = True
4879 			self.have_disassembler = False
4880 		self.host_machine_id = 0
4881 		self.host_start_time = 0
4882 		self.host_finish_time = 0
4884 	def FileFromBuildId(self, build_id):  argument
4885 		file_name = self.buildid_dir + build_id[0:2] + "/" + build_id[2:] + "/elf"
4888 	def FileFromNamesAndBuildId(self, short_name, long_name, build_id):  argument
4899 		f = self.FileFromBuildId(build_id)
4904 	def AddInstanceToShutdownOnExit(self, instance):  argument
4905 		self.instances_to_shutdown_on_exit.add(instance)
4908 	def ShutdownInstances(self):  argument
4909 		for x in self.instances_to_shutdown_on_exit:
4915 	def GetHostMachineId(self):  argument
4916 		query = QSqlQuery(self.db)
4919 			self.host_machine_id = query.value(0)
4921 			self.host_machine_id = 0
4922 		return self.host_machine_id
4924 	def HostMachineId(self):  argument
4925 		if self.host_machine_id:
4926 			return self.host_machine_id
4927 		return self.GetHostMachineId()
4929 	def SelectValue(self, sql):  argument
4930 		query = QSqlQuery(self.db)
4939 	def SwitchesMinTime(self, machine_id):  argument
4940 		return self.SelectValue("SELECT time"
4945 	def SwitchesMaxTime(self, machine_id):  argument
4946 		return self.SelectValue("SELECT time"
4951 	def SamplesMinTime(self, machine_id):  argument
4952 		return self.SelectValue("SELECT time"
4957 	def SamplesMaxTime(self, machine_id):  argument
4958 		return self.SelectValue("SELECT time"
4963 	def CallsMinTime(self, machine_id):  argument
4964 		return self.SelectValue("SELECT calls.call_time"
4970 	def CallsMaxTime(self, machine_id):  argument
4971 		return self.SelectValue("SELECT calls.return_time"
4977 	def GetStartTime(self, machine_id):  argument
4978 		t0 = self.SwitchesMinTime(machine_id)
4979 		t1 = self.SamplesMinTime(machine_id)
4980 		t2 = self.CallsMinTime(machine_id)
4987 	def GetFinishTime(self, machine_id):  argument
4988 		t0 = self.SwitchesMaxTime(machine_id)
4989 		t1 = self.SamplesMaxTime(machine_id)
4990 		t2 = self.CallsMaxTime(machine_id)
4997 	def HostStartTime(self):  argument
4998 		if self.host_start_time:
4999 			return self.host_start_time
5000 		self.host_start_time = self.GetStartTime(self.HostMachineId())
5001 		return self.host_start_time
5003 	def HostFinishTime(self):  argument
5004 		if self.host_finish_time:
5005 			return self.host_finish_time
5006 		self.host_finish_time = self.GetFinishTime(self.HostMachineId())
5007 		return self.host_finish_time
5009 	def StartTime(self, machine_id):  argument
5010 		if machine_id == self.HostMachineId():
5011 			return self.HostStartTime()
5012 		return self.GetStartTime(machine_id)
5014 	def FinishTime(self, machine_id):  argument
5015 		if machine_id == self.HostMachineId():
5016 			return self.HostFinishTime()
5017 		return self.GetFinishTime(machine_id)
5023 	def __init__(self, is_sqlite3, dbname):  argument
5024 		self.is_sqlite3 = is_sqlite3
5025 		self.dbname = dbname
5026 		self.TRUE = "TRUE"
5027 		self.FALSE = "FALSE"
5029 		if self.is_sqlite3:
5030 			self.TRUE = "1"
5031 			self.FALSE = "0"
5033 	def Open(self, connection_name):  argument
5034 		dbname = self.dbname
5035 		if self.is_sqlite3: