194 	def __init__(self, task, param=None, parent=None):  argument
195 		super(Thread, self).__init__(parent)
196 		self.task = task
197 		self.param = param
199 	def run(self):  argument
201 			if self.param is None:
202 				done, result = self.task()
204 				done, result = self.task(self.param)
205 			self.done.emit(result)
213 	def __init__(self, glb, params, parent=None):  argument
214 		super(TreeModel, self).__init__(parent)
215 		self.glb = glb
216 		self.params = params
217 		self.root = self.GetRoot()
218 		self.last_row_read = 0
220 	def Item(self, parent):  argument
224 			return self.root
226 	def rowCount(self, parent):  argument
227 		result = self.Item(parent).childCount()
230 			self.dataChanged.emit(parent, parent)
233 	def hasChildren(self, parent):  argument
234 		return self.Item(parent).hasChildren()
236 	def headerData(self, section, orientation, role):  argument
238 			return self.columnAlignment(section)
243 		return self.columnHeader(section)
245 	def parent(self, child):  argument
247 		if child_item is self.root:
250 		return self.createIndex(parent_item.getRow(), 0, parent_item)
252 	def index(self, row, column, parent):  argument
253 		child_item = self.Item(parent).getChildItem(row)
254 		return self.createIndex(row, column, child_item)
256 	def DisplayData(self, item, index):  argument
259 	def FetchIfNeeded(self, row):  argument
260 		if row > self.last_row_read:
261 			self.last_row_read = row
262 			if row + 10 >= self.root.child_count:
263 				self.fetcher.Fetch(glb_chunk_sz)
265 	def columnAlignment(self, column):  argument
268 	def columnFont(self, column):  argument
271 	def data(self, index, role):  argument
273 			return self.columnAlignment(index.column())
275 			return self.columnFont(index.column())
279 		return self.DisplayData(item, index)
285 	def __init__(self, parent=None):  argument
286 		super(TableModel, self).__init__(parent)
287 		self.child_count = 0
288 		self.child_items = []
289 		self.last_row_read = 0
291 	def Item(self, parent):  argument
295 			return self
297 	def rowCount(self, parent):  argument
298 		return self.child_count
300 	def headerData(self, section, orientation, role):  argument
302 			return self.columnAlignment(section)
307 		return self.columnHeader(section)
309 	def index(self, row, column, parent):  argument
310 		return self.createIndex(row, column, self.child_items[row])
312 	def DisplayData(self, item, index):  argument
315 	def FetchIfNeeded(self, row):  argument
316 		if row > self.last_row_read:
317 			self.last_row_read = row
318 			if row + 10 >= self.child_count:
319 				self.fetcher.Fetch(glb_chunk_sz)
321 	def columnAlignment(self, column):  argument
324 	def columnFont(self, column):  argument
327 	def data(self, index, role):  argument
329 			return self.columnAlignment(index.column())
331 			return self.columnFont(index.column())
335 		return self.DisplayData(item, index)
367 	def __init__(self, parent, finder, is_reg_expr=False):  argument
368 		self.finder = finder
369 		self.context = []
370 		self.last_value = None
371 		self.last_pattern = None
376 		self.textbox = QComboBox()
377 		self.textbox.setEditable(True)
378 		self.textbox.currentIndexChanged.connect(self.ValueChanged)
380 		self.progress = QProgressBar()
381 		self.progress.setRange(0, 0)
382 		self.progress.hide()
385 			self.pattern = QCheckBox("Regular Expression")
387 			self.pattern = QCheckBox("Pattern")
388 		self.pattern.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
390 		self.next_button = QToolButton()
391 		self.next_button.setIcon(parent.style().standardIcon(QStyle.SP_ArrowDown))
392 		self.next_button.released.connect(lambda: self.NextPrev(1))
394 		self.prev_button = QToolButton()
395 		self.prev_button.setIcon(parent.style().standardIcon(QStyle.SP_ArrowUp))
396 		self.prev_button.released.connect(lambda: self.NextPrev(-1))
398 		self.close_button = QToolButton()
399 		self.close_button.setIcon(parent.style().standardIcon(QStyle.SP_DockWidgetCloseButton))
400 		self.close_button.released.connect(self.Deactivate)
402 		self.hbox = QHBoxLayout()
403 		self.hbox.setContentsMargins(0, 0, 0, 0)
405 		self.hbox.addWidget(label)
406 		self.hbox.addWidget(self.textbox)
407 		self.hbox.addWidget(self.progress)
408 		self.hbox.addWidget(self.pattern)
409 		self.hbox.addWidget(self.next_button)
410 		self.hbox.addWidget(self.prev_button)
411 		self.hbox.addWidget(self.close_button)
413 		self.bar = QWidget()
414 		self.bar.setLayout(self.hbox)
415 		self.bar.hide()
417 	def Widget(self):  argument
418 		return self.bar
420 	def Activate(self):  argument
421 		self.bar.show()
422 		self.textbox.lineEdit().selectAll()
423 		self.textbox.setFocus()
425 	def Deactivate(self):  argument
426 		self.bar.hide()
428 	def Busy(self):  argument
429 		self.textbox.setEnabled(False)
430 		self.pattern.hide()
431 		self.next_button.hide()
432 		self.prev_button.hide()
433 		self.progress.show()
435 	def Idle(self):  argument
436 		self.textbox.setEnabled(True)
437 		self.progress.hide()
438 		self.pattern.show()
439 		self.next_button.show()
440 		self.prev_button.show()
442 	def Find(self, direction):  argument
443 		value = self.textbox.currentText()
444 		pattern = self.pattern.isChecked()
445 		self.last_value = value
446 		self.last_pattern = pattern
447 		self.finder.Find(value, direction, pattern, self.context)
449 	def ValueChanged(self):  argument
450 		value = self.textbox.currentText()
451 		pattern = self.pattern.isChecked()
452 		index = self.textbox.currentIndex()
453 		data = self.textbox.itemData(index)
456 			self.textbox.setItemData(index, pattern)
458 			self.pattern.setChecked(data)
459 		self.Find(0)
461 	def NextPrev(self, direction):  argument
462 		value = self.textbox.currentText()
463 		pattern = self.pattern.isChecked()
464 		if value != self.last_value:
465 			index = self.textbox.findText(value)
468 				index = self.textbox.count()
469 				self.textbox.addItem(value, pattern)
470 				self.textbox.setCurrentIndex(index)
473 				self.textbox.setItemData(index, pattern)
474 		elif pattern != self.last_pattern:
476 			index = self.textbox.currentIndex()
477 			self.textbox.setItemData(index, pattern)
478 		self.Find(direction)
480 	def NotFound(self):  argument
481 		QMessageBox.information(self.bar, "Find", "'" + self.textbox.currentText() + "' not found")
487 	def __init__(self, glb, params, row, parent_item):  argument
488 		self.glb = glb
489 		self.params = params
490 		self.row = row
491 		self.parent_item = parent_item
492 		self.query_done = False
493 		self.child_count = 0
494 		self.child_items = []
496 			self.level = parent_item.level + 1
498 			self.level = 0
500 	def getChildItem(self, row):  argument
501 		return self.child_items[row]
503 	def getParentItem(self):  argument
504 		return self.parent_item
506 	def getRow(self):  argument
507 		return self.row
509 	def childCount(self):  argument
510 		if not self.query_done:
511 			self.Select()
512 			if not self.child_count:
514 		return self.child_count
516 	def hasChildren(self):  argument
517 		if not self.query_done:
519 		return self.child_count > 0
521 	def getData(self, column):  argument
522 		return self.data[column]
528 …def __init__(self, glb, params, row, comm_id, thread_id, call_path_id, time, insn_cnt, cyc_cnt, br…  argument
529 		super(CallGraphLevelTwoPlusItemBase, self).__init__(glb, params, row, parent_item)
530 		self.comm_id = comm_id
531 		self.thread_id = thread_id
532 		self.call_path_id = call_path_id
533 		self.insn_cnt = insn_cnt
534 		self.cyc_cnt = cyc_cnt
535 		self.branch_count = branch_count
536 		self.time = time
538 	def Select(self):  argument
539 		self.query_done = True
540 		query = QSqlQuery(self.glb.db)
541 		if self.params.have_ipc:
550 					" WHERE parent_call_path_id = " + str(self.call_path_id) +
551 					" AND comm_id = " + str(self.comm_id) +
552 					" AND thread_id = " + str(self.thread_id) +
556 			if self.params.have_ipc:
564 …self.glb, self.params, self.child_count, self.comm_id, self.thread_id, query.value(0), query.value…
565 			self.child_items.append(child_item)
566 			self.child_count += 1
572 …def __init__(self, glb, params, row, comm_id, thread_id, call_path_id, name, dso, count, time, ins…  argument
573 …super(CallGraphLevelThreeItem, self).__init__(glb, params, row, comm_id, thread_id, call_path_id, …
575 		if self.params.have_ipc:
580 …self.data = [ name, dso, str(count), str(time), PercentToOneDP(time, parent_item.time), str(insn_c…
582 …self.data = [ name, dso, str(count), str(time), PercentToOneDP(time, parent_item.time), str(branch…
583 		self.dbid = call_path_id
589 	def __init__(self, glb, params, row, comm_id, thread_id, pid, tid, parent_item):  argument
590 …super(CallGraphLevelTwoItem, self).__init__(glb, params, row, comm_id, thread_id, 1, 0, 0, 0, 0, p…
591 		if self.params.have_ipc:
592 			self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", "", "", "", "", "", ""]
594 			self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", ""]
595 		self.dbid = thread_id
597 	def Select(self):  argument
598 		super(CallGraphLevelTwoItem, self).Select()
599 		for child_item in self.child_items:
600 			self.time += child_item.time
601 			self.insn_cnt += child_item.insn_cnt
602 			self.cyc_cnt += child_item.cyc_cnt
603 			self.branch_count += child_item.branch_count
604 		for child_item in self.child_items:
605 			child_item.data[4] = PercentToOneDP(child_item.time, self.time)
606 			if self.params.have_ipc:
607 				child_item.data[6] = PercentToOneDP(child_item.insn_cnt, self.insn_cnt)
608 				child_item.data[8] = PercentToOneDP(child_item.cyc_cnt, self.cyc_cnt)
609 				child_item.data[11] = PercentToOneDP(child_item.branch_count, self.branch_count)
611 				child_item.data[6] = PercentToOneDP(child_item.branch_count, self.branch_count)
617 	def __init__(self, glb, params, row, comm_id, comm, parent_item):  argument
618 		super(CallGraphLevelOneItem, self).__init__(glb, params, row, parent_item)
619 		if self.params.have_ipc:
620 			self.data = [comm, "", "", "", "", "", "", "", "", "", "", ""]
622 			self.data = [comm, "", "", "", "", "", ""]
623 		self.dbid = comm_id
625 	def Select(self):  argument
626 		self.query_done = True
627 		query = QSqlQuery(self.glb.db)
631 					" WHERE comm_id = " + str(self.dbid))
633 …= CallGraphLevelTwoItem(self.glb, self.params, self.child_count, self.dbid, query.value(0), query.…
634 			self.child_items.append(child_item)
635 			self.child_count += 1
641 	def __init__(self, glb, params):  argument
642 		super(CallGraphRootItem, self).__init__(glb, params, 0, None)
643 		self.dbid = 0
644 		self.query_done = True
653 …child_item = CallGraphLevelOneItem(glb, params, self.child_count, query.value(0), query.value(1), …
654 			self.child_items.append(child_item)
655 			self.child_count += 1
661 	def __init__(self, glb, parent=None):  argument
662 		self.have_ipc = IsSelectable(glb.db, "calls", columns = "insn_count, cyc_count")
668 	def __init__(self, glb, parent=None):  argument
669 		super(CallGraphModelBase, self).__init__(glb, CallGraphModelParams(glb), parent)
671 	def FindSelect(self, value, pattern, query):  argument
678 			if not self.glb.dbref.is_sqlite3:
692 		self.DoFindSelect(query, match)
694 	def Found(self, query, found):  argument
696 			return self.FindPath(query)
699 	def FindValue(self, value, pattern, query, last_value, last_pattern):  argument
703 			self.FindSelect(value, pattern, query)
705 		return self.Found(query, found)
707 	def FindNext(self, query):  argument
711 		return self.Found(query, found)
713 	def FindPrev(self, query):  argument
717 		return self.Found(query, found)
719 	def FindThread(self, c):  argument
721 			ids = self.FindValue(c.value, c.pattern, c.query, c.last_value, c.last_pattern)
723 			ids = self.FindNext(c.query)
725 			ids = self.FindPrev(c.query)
728 	def Find(self, value, direction, pattern, context, callback):  argument
730 			def __init__(self, *x):  argument
731 				self.value, self.direction, self.pattern, self.query, self.last_value, self.last_pattern = x
732 			def Update(self, *x):  argument
733 …self.value, self.direction, self.pattern, self.last_value, self.last_pattern = x + (self.value, se…
737 			context.append(Context(value, direction, pattern, QSqlQuery(self.glb.db), None, None))
739 		thread = Thread(self.FindThread, context[0])
740 …thread.done.connect(lambda ids, t=thread, c=callback: self.FindDone(t, c, ids), Qt.QueuedConnectio…
743 	def FindDone(self, thread, callback, ids):  argument
750 	def __init__(self, glb, parent=None):  argument
751 		super(CallGraphModel, self).__init__(glb, parent)
753 	def GetRoot(self):  argument
754 		return CallGraphRootItem(self.glb, self.params)
756 	def columnCount(self, parent=None):  argument
757 		if self.params.have_ipc:
762 	def columnHeader(self, column):  argument
763 		if self.params.have_ipc:
769 	def columnAlignment(self, column):  argument
770 		if self.params.have_ipc:
776 	def DoFindSelect(self, query, match):  argument
786 	def FindPath(self, query):  argument
793 			q2 = QSqlQuery(self.glb.db)
811 …def __init__(self, glb, params, row, comm_id, thread_id, calls_id, call_time, time, insn_cnt, cyc_…  argument
812 		super(CallTreeLevelTwoPlusItemBase, self).__init__(glb, params, row, parent_item)
813 		self.comm_id = comm_id
814 		self.thread_id = thread_id
815 		self.calls_id = calls_id
816 		self.call_time = call_time
817 		self.time = time
818 		self.insn_cnt = insn_cnt
819 		self.cyc_cnt = cyc_cnt
820 		self.branch_count = branch_count
822 	def Select(self):  argument
823 		self.query_done = True
824 		if self.calls_id == 0:
825 			comm_thread = " AND comm_id = " + str(self.comm_id) + " AND thread_id = " + str(self.thread_id)
828 		if self.params.have_ipc:
832 		query = QSqlQuery(self.glb.db)
838 					" WHERE calls.parent_id = " + str(self.calls_id) + comm_thread +
841 			if self.params.have_ipc:
849 …self.glb, self.params, self.child_count, self.comm_id, self.thread_id, query.value(0), query.value…
850 			self.child_items.append(child_item)
851 			self.child_count += 1
857 …def __init__(self, glb, params, row, comm_id, thread_id, calls_id, name, dso, call_time, time, ins…  argument
858 …super(CallTreeLevelThreeItem, self).__init__(glb, params, row, comm_id, thread_id, calls_id, call_…
860 		if self.params.have_ipc:
865 …self.data = [ name, dso, str(call_time), str(time), PercentToOneDP(time, parent_item.time), str(in…
867 …self.data = [ name, dso, str(call_time), str(time), PercentToOneDP(time, parent_item.time), str(br…
868 		self.dbid = calls_id
874 	def __init__(self, glb, params, row, comm_id, thread_id, pid, tid, parent_item):  argument
875 …super(CallTreeLevelTwoItem, self).__init__(glb, params, row, comm_id, thread_id, 0, 0, 0, 0, 0, 0,…
876 		if self.params.have_ipc:
877 			self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", "", "", "", "", "", ""]
879 			self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", ""]
880 		self.dbid = thread_id
882 	def Select(self):  argument
883 		super(CallTreeLevelTwoItem, self).Select()
884 		for child_item in self.child_items:
885 			self.time += child_item.time
886 			self.insn_cnt += child_item.insn_cnt
887 			self.cyc_cnt += child_item.cyc_cnt
888 			self.branch_count += child_item.branch_count
889 		for child_item in self.child_items:
890 			child_item.data[4] = PercentToOneDP(child_item.time, self.time)
891 			if self.params.have_ipc:
892 				child_item.data[6] = PercentToOneDP(child_item.insn_cnt, self.insn_cnt)
893 				child_item.data[8] = PercentToOneDP(child_item.cyc_cnt, self.cyc_cnt)
894 				child_item.data[11] = PercentToOneDP(child_item.branch_count, self.branch_count)
896 				child_item.data[6] = PercentToOneDP(child_item.branch_count, self.branch_count)
902 	def __init__(self, glb, params, row, comm_id, comm, parent_item):  argument
903 		super(CallTreeLevelOneItem, self).__init__(glb, params, row, parent_item)
904 		if self.params.have_ipc:
905 			self.data = [comm, "", "", "", "", "", "", "", "", "", "", ""]
907 			self.data = [comm, "", "", "", "", "", ""]
908 		self.dbid = comm_id
910 	def Select(self):  argument
911 		self.query_done = True
912 		query = QSqlQuery(self.glb.db)
916 					" WHERE comm_id = " + str(self.dbid))
918 … = CallTreeLevelTwoItem(self.glb, self.params, self.child_count, self.dbid, query.value(0), query.…
919 			self.child_items.append(child_item)
920 			self.child_count += 1
926 	def __init__(self, glb, params):  argument
927 		super(CallTreeRootItem, self).__init__(glb, params, 0, None)
928 		self.dbid = 0
929 		self.query_done = True
938 …child_item = CallTreeLevelOneItem(glb, params, self.child_count, query.value(0), query.value(1), s…
939 			self.child_items.append(child_item)
940 			self.child_count += 1
946 	def __init__(self, glb, parent=None):  argument
947 		super(CallTreeModel, self).__init__(glb, parent)
949 	def GetRoot(self):  argument
950 		return CallTreeRootItem(self.glb, self.params)
952 	def columnCount(self, parent=None):  argument
953 		if self.params.have_ipc:
958 	def columnHeader(self, column):  argument
959 		if self.params.have_ipc:
965 	def columnAlignment(self, column):  argument
966 		if self.params.have_ipc:
972 	def DoFindSelect(self, query, match):  argument
981 	def FindPath(self, query):  argument
988 			q2 = QSqlQuery(self.glb.db)
1003 	def __init__(self, *children):  argument
1004 		super(HBoxLayout, self).__init__()
1006 		self.layout().setContentsMargins(0, 0, 0, 0)
1009 				self.layout().addWidget(child)
1011 				self.layout().addLayout(child)
1017 	def __init__(self, *children):  argument
1018 		super(VBoxLayout, self).__init__()
1020 		self.layout().setContentsMargins(0, 0, 0, 0)
1023 				self.layout().addWidget(child)
1025 				self.layout().addLayout(child)
1031 	def __init__(self, *children):  argument
1032 		self.vbox = QWidget()
1033 		self.vbox.setLayout(VBoxLayout(*children))
1035 	def Widget(self):  argument
1036 		return self.vbox
1042 	def __init__(self, parent=None):  argument
1043 		super(TreeWindowBase, self).__init__(parent)
1045 		self.model = None
1046 		self.find_bar = None
1048 		self.view = QTreeView()
1049 		self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
1050 		self.view.CopyCellsToClipboard = CopyTreeCellsToClipboard
1052 		self.context_menu = TreeContextMenu(self.view)
1054 	def DisplayFound(self, ids):  argument
1060 			n = self.model.rowCount(parent)
1062 				child = self.model.index(row, 0, parent)
1065 					self.view.setExpanded(parent, True)
1066 					self.view.setCurrentIndex(child)
1073 	def Find(self, value, direction, pattern, context):  argument
1074 		self.view.setFocus()
1075 		self.find_bar.Busy()
1076 		self.model.Find(value, direction, pattern, context, self.FindDone)
1078 	def FindDone(self, ids):  argument
1080 		if not self.DisplayFound(ids):
1082 		self.find_bar.Idle()
1084 			self.find_bar.NotFound()
1091 	def __init__(self, glb, parent=None):  argument
1092 		super(CallGraphWindow, self).__init__(parent)
1094 		self.model = LookupCreateModel("Context-Sensitive Call Graph", lambda x=glb: CallGraphModel(x))
1096 		self.view.setModel(self.model)
1099 			self.view.setColumnWidth(c, w)
1101 		self.find_bar = FindBar(self, self)
1103 		self.vbox = VBox(self.view, self.find_bar.Widget())
1105 		self.setWidget(self.vbox.Widget())
1107 		AddSubWindow(glb.mainwindow.mdi_area, self, "Context-Sensitive Call Graph")
1113 	def __init__(self, glb, parent=None, thread_at_time=None):  argument
1114 		super(CallTreeWindow, self).__init__(parent)
1116 		self.model = LookupCreateModel("Call Tree", lambda x=glb: CallTreeModel(x))
1118 		self.view.setModel(self.model)
1121 			self.view.setColumnWidth(c, w)
1123 		self.find_bar = FindBar(self, self)
1125 		self.vbox = VBox(self.view, self.find_bar.Widget())
1127 		self.setWidget(self.vbox.Widget())
1129 		AddSubWindow(glb.mainwindow.mdi_area, self, "Call Tree")
1132 			self.DisplayThreadAtTime(*thread_at_time)
1134 	def DisplayThreadAtTime(self, comm_id, thread_id, time):  argument
1138 			n = self.model.rowCount(parent)
1140 				child = self.model.index(row, 0, parent)
1143 					self.view.setExpanded(parent, True)
1144 					self.view.setCurrentIndex(child)
1151 			n = self.model.rowCount(parent)
1156 				self.view.setExpanded(parent, True)
1157 				child = self.model.index(row, 0, parent)
1162 					self.view.setCurrentIndex(child)
1168 					child = self.model.index(0, 0, parent)
1169 					self.view.setExpanded(parent, True)
1170 					self.view.setCurrentIndex(child)
1173 			self.view.setExpanded(parent, True)
1174 			self.view.setCurrentIndex(last_child)
1200 	def __init__(self, x=0, y=0):  argument
1201 		self.x = x
1202 		self.y = y
1204 	def __str__(self):  argument
1205 		return "XY({}, {})".format(str(self.x), str(self.y))
1210 	def __init__(self, lo=0, hi=0):  argument
1211 		self.lo = lo
1212 		self.hi = hi
1214 	def __str__(self):  argument
1215 		return "Subrange({}, {})".format(str(self.lo), str(self.hi))
1221 	def __init__(self, key, title = "", ordinal = ""):  argument
1222 		self.key = key
1223 		self.title = title
1224 		self.ordinal = ordinal
1235 	def __init__(self, colour):  argument
1236 		self.colour = colour
1242 	def __init__(self, key, exec_comm_id, pid, tid, comm, thread_id, comm_id):  argument
1243 		super(SwitchGraphDataRegion, self).__init__(key)
1245 		self.title = str(pid) + " / " + str(tid) + " " + comm
1247 		self.ordinal = str(pid).rjust(16) + str(exec_comm_id).rjust(8) + str(tid).rjust(16)
1248 		self.exec_comm_id = exec_comm_id
1249 		self.pid = pid
1250 		self.tid = tid
1251 		self.comm = comm
1252 		self.thread_id = thread_id
1253 		self.comm_id = comm_id
1259 	def __init__(self, data, index, x, y, altx=None, alty=None, hregion=None, vregion=None):  argument
1260 		self.data = data
1261 		self.index = index
1262 		self.x = x
1263 		self.y = y
1264 		self.altx = altx
1265 		self.alty = alty
1266 		self.hregion = hregion
1267 		self.vregion = vregion
1273 	def __init__(self, collection, xbase=Decimal(0), ybase=Decimal(0)):  argument
1274 		self.collection = collection
1275 		self.points = []
1276 		self.xbase = xbase
1277 		self.ybase = ybase
1278 		self.title = ""
1280 	def AddPoint(self, x, y, altx=None, alty=None, hregion=None, vregion=None):  argument
1281 		index = len(self.points)
1283 		x = float(Decimal(x) - self.xbase)
1284 		y = float(Decimal(y) - self.ybase)
1286 		self.points.append(GraphDataPoint(self, index, x, y, altx, alty, hregion, vregion))
1288 	def XToData(self, x):  argument
1289 		return Decimal(x) + self.xbase
1291 	def YToData(self, y):  argument
1292 		return Decimal(y) + self.ybase
1298 	def __init__(self, db, collection, cpu, xbase):  argument
1299 		super(SwitchGraphData, self).__init__(collection, xbase)
1301 		self.cpu = cpu
1302 		self.title = "CPU " + str(cpu)
1303 		self.SelectSwitches(db)
1305 	def SelectComms(self, db, thread_id, last_comm_id, start_time, end_time):  argument
1310 					"   AND exec_flag = " + self.collection.glb.dbref.TRUE +
1319 			hregion = self.HRegion(db, thread_id, comm_id, time)
1320 			self.AddPoint(time, 1000, None, None, hregion)
1322 	def SelectSwitches(self, db):  argument
1329 					" WHERE machine_id = " + str(self.collection.machine_id) +
1330 					"   AND cpu = " + str(self.cpu) +
1337 					self.SelectComms(db, last_thread_id, last_comm_id, last_time, query.value(0))
1340 			if len(self.points) == 0:
1341 				start_time = self.collection.glb.StartTime(self.collection.machine_id)
1342 				hregion = self.HRegion(db, query.value(1), query.value(3), start_time)
1343 				self.AddPoint(start_time, 1000, None, None, hregion)
1347 			hregion = self.HRegion(db, thread_id, comm_id, time)
1348 			self.AddPoint(time, 1000, None, None, hregion)
1353 	def NewHRegion(self, db, key, thread_id, comm_id, time):  argument
1371 	def HRegion(self, db, thread_id, comm_id, time):  argument
1373 		hregion = self.collection.LookupHRegion(key)
1375 			hregion = self.NewHRegion(db, key, thread_id, comm_id, time)
1376 			self.collection.AddHRegion(key, hregion)
1383 	def __init__(self, glb):  argument
1384 		self.glb = glb
1385 		self.data = []
1386 		self.hregions = {}
1387 		self.xrangelo = None
1388 		self.xrangehi = None
1389 		self.yrangelo = None
1390 		self.yrangehi = None
1391 		self.dp = XY(0, 0)
1393 	def AddGraphData(self, data):  argument
1394 		self.data.append(data)
1396 	def LookupHRegion(self, key):  argument
1397 		if key in self.hregions:
1398 			return self.hregions[key]
1401 	def AddHRegion(self, key, hregion):  argument
1402 		self.hregions[key] = hregion
1408 	def __init__(self, glb, db, machine_id):  argument
1409 		super(SwitchGraphDataCollection, self).__init__(glb)
1411 		self.machine_id = machine_id
1412 		self.cpus = self.SelectCPUs(db)
1414 		self.xrangelo = glb.StartTime(machine_id)
1415 		self.xrangehi = glb.FinishTime(machine_id)
1417 		self.yrangelo = Decimal(0)
1418 		self.yrangehi = Decimal(1000)
1420 		for cpu in self.cpus:
1421 			self.AddGraphData(SwitchGraphData(db, self, cpu, self.xrangelo))
1423 	def SelectCPUs(self, db):  argument
1428 					" WHERE machine_id = " + str(self.machine_id))
1437 	def __init__(self, data, graph_width, graph_height, attrs, event_handler, parent=None):  argument
1438 		super(SwitchGraphDataGraphicsItem, self).__init__(parent)
1440 		self.data = data
1441 		self.graph_width = graph_width
1442 		self.graph_height = graph_height
1443 		self.attrs = attrs
1444 		self.event_handler = event_handler
1445 		self.setAcceptHoverEvents(True)
1447 	def boundingRect(self):  argument
1448 		return QRectF(0, 0, self.graph_width, self.graph_height)
1450 	def PaintPoint(self, painter, last, x):  argument
1451 		if not(last is None or last.hregion.pid == 0 or x < self.attrs.subrange.x.lo):
1452 			if last.x < self.attrs.subrange.x.lo:
1453 				x0 = self.attrs.subrange.x.lo
1456 			if x > self.attrs.subrange.x.hi:
1457 				x1 = self.attrs.subrange.x.hi
1460 			x0 = self.attrs.XToPixel(x0)
1461 			x1 = self.attrs.XToPixel(x1)
1463 			y0 = self.attrs.YToPixel(last.y)
1465 			colour = self.attrs.region_attributes[last.hregion.key].colour
1470 				painter.drawLine(x0, self.graph_height - y0, x0, self.graph_height)
1472 				painter.fillRect(x0, self.graph_height - y0, width, self.graph_height - 1, colour)
1474 	def paint(self, painter, option, widget):  argument
1476 		for point in self.data.points:
1477 			self.PaintPoint(painter, last, point.x)
1478 			if point.x > self.attrs.subrange.x.hi:
1481 		self.PaintPoint(painter, last, self.attrs.subrange.x.hi + 1)
1483 	def BinarySearchPoint(self, target):  argument
1485 		higher_pos = len(self.data.points)
1488 			val = self.data.points[pos].x
1496 	def XPixelToData(self, x):  argument
1497 		x = self.attrs.PixelToX(x)
1498 		if x < self.data.points[0].x:
1503 			pos = self.BinarySearchPoint(x)
1505 		return (low, pos, self.data.XToData(x))
1507 	def EventToData(self, event):  argument
1509 		if len(self.data.points) < 1:
1514 		low0, pos0, time_from = self.XPixelToData(x)
1515 		low1, pos1, time_to = self.XPixelToData(x + 1)
1520 				hregion = self.data.points[i].hregion
1525 					time = self.data.XToData(self.data.points[i].x)
1529 	def hoverMoveEvent(self, event):  argument
1530 		time_from, time_to, hregions, hregion_times = self.EventToData(event)
1532 			self.event_handler.PointEvent(self.data.cpu, time_from, time_to, hregions)
1534 	def hoverLeaveEvent(self, event):  argument
1535 		self.event_handler.NoPointEvent()
1537 	def mousePressEvent(self, event):  argument
1539 			super(SwitchGraphDataGraphicsItem, self).mousePressEvent(event)
1541 		time_from, time_to, hregions, hregion_times = self.EventToData(event)
1543 			self.event_handler.RightClickEvent(self.data.cpu, hregion_times, event.screenPos())
1549 	def __init__(self, width, parent=None):  argument
1550 		super(XAxisGraphicsItem, self).__init__(parent)
1552 		self.width = width
1553 		self.max_mark_sz = 4
1554 		self.height = self.max_mark_sz + 1
1556 	def boundingRect(self):  argument
1557 		return QRectF(0, 0, self.width, self.height)
1559 	def Step(self):  argument
1560 		attrs = self.parentItem().attrs
1563 		s = (3.0 * t) / self.width
1569 	def PaintMarks(self, painter, at_y, lo, hi, step, i):  argument
1570 		attrs = self.parentItem().attrs
1580 				sz = self.max_mark_sz
1586 	def paint(self, painter, option, widget):  argument
1588 		painter.drawLine(0, 0, self.width - 1, 0)
1589 		n = self.Step()
1590 		attrs = self.parentItem().attrs
1598 		self.PaintMarks(painter, 0, x, subrange.hi, n, i)
1600 	def ScaleDimensions(self):  argument
1601 		n = self.Step()
1602 		attrs = self.parentItem().attrs
1610 	def PaintScale(self, painter, at_x, at_y):  argument
1611 		n, lo, hi, width = self.ScaleDimensions()
1615 		self.PaintMarks(painter, at_y, lo, hi, n, 0)
1617 	def ScaleWidth(self):  argument
1618 		n, lo, hi, width = self.ScaleDimensions()
1621 	def ScaleHeight(self):  argument
1622 		return self.height
1624 	def ScaleUnit(self):  argument
1625 		return self.Step() * 10
1631 	def __init__(self, axis, parent=None):  argument
1632 		super(ScaleGraphicsItem, self).__init__(parent)
1633 		self.axis = axis
1635 	def boundingRect(self):  argument
1636 		scale_width = self.axis.ScaleWidth()
1639 		return QRectF(0, 0, self.axis.ScaleWidth() + 100, self.axis.ScaleHeight())
1641 	def paint(self, painter, option, widget):  argument
1642 		scale_width = self.axis.ScaleWidth()
1645 		self.axis.PaintScale(painter, 0, 5)
1647 		painter.drawText(QPointF(x, 10), self.Text())
1649 	def Unit(self):  argument
1650 		return self.axis.ScaleUnit()
1652 	def Text(self):  argument
1659 	def __init__(self, axis, parent=None):  argument
1660 		super(SwitchScaleGraphicsItem, self).__init__(axis, parent)
1662 	def Text(self):  argument
1663 		unit = self.Unit()
1682 	def __init__(self, collection, data, attrs, event_handler, first, parent=None):  argument
1683 		super(SwitchGraphGraphicsItem, self).__init__(parent)
1684 		self.collection = collection
1685 		self.data = data
1686 		self.attrs = attrs
1687 		self.event_handler = event_handler
1692 		self.title_graphics = QGraphicsSimpleTextItem(data.title, self)
1694 		self.title_graphics.setPos(margin, margin)
1698 		self.graph_origin_x = margin + title_width + margin
1699 		self.graph_origin_y = graph_height + margin
1703 		self.yline = QGraphicsLineItem(0, 0, 0, graph_height, self)
1705 		self.x_axis = XAxisGraphicsItem(graph_width, self)
1706 		self.x_axis.setPos(self.graph_origin_x, self.graph_origin_y + 1)
1709 			self.scale_item = SwitchScaleGraphicsItem(self.x_axis, self)
1710 			self.scale_item.setPos(self.graph_origin_x, self.graph_origin_y + 10)
1712 		self.yline.setPos(self.graph_origin_x - y_axis_size, self.graph_origin_y - graph_height)
1714 		self.axis_point = QGraphicsLineItem(0, 0, 0, 0, self)
1715 		self.axis_point.setPos(self.graph_origin_x - 1, self.graph_origin_y +1)
1717 		self.width = self.graph_origin_x + graph_width + margin
1718 		self.height = self.graph_origin_y + margin
1720 …self.graph = SwitchGraphDataGraphicsItem(data, graph_width, graph_height, attrs, event_handler, se…
1721 		self.graph.setPos(self.graph_origin_x, self.graph_origin_y - graph_height)
1724 			parent.EnableRubberBand(self.graph_origin_x, self.graph_origin_x + graph_width - 1, self)
1726 	def boundingRect(self):  argument
1727 		return QRectF(0, 0, self.width, self.height)
1729 	def paint(self, painter, option, widget):  argument
1732 	def RBXToPixel(self, x):  argument
1733 		return self.attrs.PixelToX(x - self.graph_origin_x)
1735 	def RBXRangeToPixel(self, x0, x1):  argument
1736 		return (self.RBXToPixel(x0), self.RBXToPixel(x1 + 1))
1738 	def RBPixelToTime(self, x):  argument
1739 		if x < self.data.points[0].x:
1740 			return self.data.XToData(0)
1741 		return self.data.XToData(x)
1743 	def RBEventTimes(self, x0, x1):  argument
1744 		x0, x1 = self.RBXRangeToPixel(x0, x1)
1745 		time_from = self.RBPixelToTime(x0)
1746 		time_to = self.RBPixelToTime(x1)
1749 	def RBEvent(self, x0, x1):  argument
1750 		time_from, time_to = self.RBEventTimes(x0, x1)
1751 		self.event_handler.RangeEvent(time_from, time_to)
1753 	def RBMoveEvent(self, x0, x1):  argument
1756 		self.RBEvent(x0, x1)
1758 	def RBReleaseEvent(self, x0, x1, selection_state):  argument
1761 		x0, x1 = self.RBXRangeToPixel(x0, x1)
1762 		self.event_handler.SelectEvent(x0, x1, selection_state)
1768 	def __init__(self, parent=None):  argument
1769 		super(VerticalBracketGraphicsItem, self).__init__(parent)
1771 		self.width = 0
1772 		self.height = 0
1773 		self.hide()
1775 	def SetSize(self, width, height):  argument
1776 		self.width = width + 1
1777 		self.height = height + 1
1779 	def boundingRect(self):  argument
1780 		return QRectF(0, 0, self.width, self.height)
1782 	def paint(self, painter, option, widget):  argument
1784 		painter.fillRect(0, 0, self.width, self.height, colour)
1785 		x1 = self.width - 1
1786 		y1 = self.height - 1
1798 	def __init__(self, collection, attrs, event_handler, child_class, parent=None):  argument
1799 		super(VertcalGraphSetGraphicsItem, self).__init__(parent)
1801 		self.collection = collection
1803 		self.top = 10
1805 		self.width = 0
1806 		self.height = self.top
1808 		self.rubber_band = None
1809 		self.rb_enabled = False
1813 			child = child_class(collection, data, attrs, event_handler, first, self)
1814 			child.setPos(0, self.height + 1)
1816 			if rect.right() > self.width:
1817 				self.width = rect.right()
1818 			self.height = self.height + rect.bottom() + 1
1821 		self.bracket = VerticalBracketGraphicsItem(self)
1823 	def EnableRubberBand(self, xlo, xhi, rb_event_handler):  argument
1824 		if self.rb_enabled:
1826 		self.rb_enabled = True
1827 		self.rb_in_view = False
1828 		self.setAcceptedMouseButtons(Qt.LeftButton)
1829 		self.rb_xlo = xlo
1830 		self.rb_xhi = xhi
1831 		self.rb_event_handler = rb_event_handler
1832 		self.mousePressEvent = self.MousePressEvent
1833 		self.mouseMoveEvent = self.MouseMoveEvent
1834 		self.mouseReleaseEvent = self.MouseReleaseEvent
1836 	def boundingRect(self):  argument
1837 		return QRectF(0, 0, self.width, self.height)
1839 	def paint(self, painter, option, widget):  argument
1842 	def RubberBandParent(self):  argument
1843 		scene = self.scene()
1848 	def RubberBandSetGeometry(self, rect):  argument
1849 		scene_rectf = self.mapRectToScene(QRectF(rect))
1850 		scene = self.scene()
1853 		self.rubber_band.setGeometry(poly.boundingRect())
1855 	def SetSelection(self, selection_state):  argument
1856 		if self.rubber_band:
1858 				self.RubberBandSetGeometry(selection_state)
1859 				self.rubber_band.show()
1861 				self.rubber_band.hide()
1863 	def SetBracket(self, rect):  argument
1866 			self.bracket.setPos(x, y)
1867 			self.bracket.SetSize(width, height)
1868 			self.bracket.show()
1870 			self.bracket.hide()
1872 	def RubberBandX(self, event):  argument
1874 		if x < self.rb_xlo:
1875 			x = self.rb_xlo
1876 		elif x > self.rb_xhi:
1877 			x = self.rb_xhi
1879 			self.rb_in_view = True
1882 	def RubberBandRect(self, x):  argument
1883 		if self.rb_origin.x() <= x:
1884 			width = x - self.rb_origin.x()
1885 			rect = QRect(self.rb_origin, QSize(width, self.height))
1887 			width = self.rb_origin.x() - x
1888 			top_left = QPoint(self.rb_origin.x() - width, self.rb_origin.y())
1889 			rect = QRect(top_left, QSize(width, self.height))
1892 	def MousePressEvent(self, event):  argument
1893 		self.rb_in_view = False
1894 		x = self.RubberBandX(event)
1895 		self.rb_origin = QPoint(x, self.top)
1896 		if self.rubber_band is None:
1897 			self.rubber_band = QRubberBand(QRubberBand.Rectangle, self.RubberBandParent())
1898 		self.RubberBandSetGeometry(QRect(self.rb_origin, QSize(0, self.height)))
1899 		if self.rb_in_view:
1900 			self.rubber_band.show()
1901 			self.rb_event_handler.RBMoveEvent(x, x)
1903 			self.rubber_band.hide()
1905 	def MouseMoveEvent(self, event):  argument
1906 		x = self.RubberBandX(event)
1907 		rect = self.RubberBandRect(x)
1908 		self.RubberBandSetGeometry(rect)
1909 		if self.rb_in_view:
1910 			self.rubber_band.show()
1911 			self.rb_event_handler.RBMoveEvent(self.rb_origin.x(), x)
1913 	def MouseReleaseEvent(self, event):  argument
1914 		x = self.RubberBandX(event)
1915 		if self.rb_in_view:
1916 			selection_state = self.RubberBandRect(x)
1919 		self.rb_event_handler.RBReleaseEvent(self.rb_origin.x(), x, selection_state)
1925 	def __init__(self, collection, region_attributes, parent=None):  argument
1926 		super(SwitchGraphLegendModel, self).__init__(parent)
1928 		self.region_attributes = region_attributes
1930 		self.child_items = sorted(collection.hregions.values(), key=GraphDataRegionOrdinal)
1931 		self.child_count = len(self.child_items)
1933 		self.highlight_set = set()
1935 		self.column_headers = ("pid", "tid", "comm")
1937 	def rowCount(self, parent):  argument
1938 		return self.child_count
1940 	def headerData(self, section, orientation, role):  argument
1945 		return self.columnHeader(section)
1947 	def index(self, row, column, parent):  argument
1948 		return self.createIndex(row, column, self.child_items[row])
1950 	def columnCount(self, parent=None):  argument
1951 		return len(self.column_headers)
1953 	def columnHeader(self, column):  argument
1954 		return self.column_headers[column]
1956 	def data(self, index, role):  argument
1958 			child = self.child_items[index.row()]
1959 			if child in self.highlight_set:
1960 				return self.region_attributes[child.key].colour
1963 			child = self.child_items[index.row()]
1964 			if child in self.highlight_set:
1966 			return self.region_attributes[child.key].colour
1969 		hregion = self.child_items[index.row()]
1979 	def SetHighlight(self, row, set_highlight):  argument
1980 		child = self.child_items[row]
1981 		top_left = self.createIndex(row, 0, child)
1982 		bottom_right = self.createIndex(row, len(self.column_headers) - 1, child)
1983 		self.dataChanged.emit(top_left, bottom_right)
1985 	def Highlight(self, highlight_set):  argument
1986 		for row in xrange(self.child_count):
1987 			child = self.child_items[row]
1988 			if child in self.highlight_set:
1990 					self.SetHighlight(row, False)
1992 				self.SetHighlight(row, True)
1993 		self.highlight_set = highlight_set
1999 	def __init__(self, collection, region_attributes, parent=None):  argument
2000 		super(SwitchGraphLegend, self).__init__(parent)
2002 		self.data_model = SwitchGraphLegendModel(collection, region_attributes)
2004 		self.model = QSortFilterProxyModel()
2005 		self.model.setSourceModel(self.data_model)
2007 		self.view = QTableView()
2008 		self.view.setModel(self.model)
2009 		self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
2010 		self.view.verticalHeader().setVisible(False)
2011 		self.view.sortByColumn(-1, Qt.AscendingOrder)
2012 		self.view.setSortingEnabled(True)
2013 		self.view.resizeColumnsToContents()
2014 		self.view.resizeRowsToContents()
2016 		self.vbox = VBoxLayout(self.view)
2017 		self.setLayout(self.vbox)
2019 		sz1 = self.view.columnWidth(0) + self.view.columnWidth(1) + self.view.columnWidth(2) + 2
2020 		sz1 = sz1 + self.view.verticalScrollBar().sizeHint().width()
2021 		self.saved_size = sz1
2023 	def resizeEvent(self, event):  argument
2024 		self.saved_size = self.size().width()
2025 		super(SwitchGraphLegend, self).resizeEvent(event)
2027 	def Highlight(self, highlight_set):  argument
2028 		self.data_model.Highlight(highlight_set)
2029 		self.update()
2031 	def changeEvent(self, event):  argument
2033 			self.view.resizeRowsToContents()
2034 			self.view.resizeColumnsToContents()
2036 			self.view.resizeRowsToContents()
2037 		super(SwitchGraphLegend, self).changeEvent(event)
2083 	def __init__(self, scale, subrange, region_attributes, dp):  argument
2084 		self.scale = scale
2085 		self.subrange = subrange
2086 		self.region_attributes = region_attributes
2088 		self.dp = dp	# data decimal places
2089 		self.Update()
2091 	def XToPixel(self, x):  argument
2092 		return int(round((x - self.subrange.x.lo) * self.scale.x, self.pdp.x))
2094 	def YToPixel(self, y):  argument
2095 		return int(round((y - self.subrange.y.lo) * self.scale.y, self.pdp.y))
2097 	def PixelToXRounded(self, px):  argument
2098 		return round((round(px, 0) / self.scale.x), self.dp.x) + self.subrange.x.lo
2100 	def PixelToYRounded(self, py):  argument
2101 		return round((round(py, 0) / self.scale.y), self.dp.y) + self.subrange.y.lo
2103 	def PixelToX(self, px):  argument
2104 		x = self.PixelToXRounded(px)
2105 		if self.pdp.x == 0:
2106 			rt = self.XToPixel(x)
2111 	def PixelToY(self, py):  argument
2112 		y = self.PixelToYRounded(py)
2113 		if self.pdp.y == 0:
2114 			rt = self.YToPixel(y)
2119 	def ToPDP(self, dp, scale):  argument
2135 	def Update(self):  argument
2136 		x = self.ToPDP(self.dp.x, self.scale.x)
2137 		y = self.ToPDP(self.dp.y, self.scale.y)
2138 		self.pdp = XY(x, y) # pixel decimal places
2144 	def __init__(self, parent=None):  argument
2145 		super(SwitchGraphSplitter, self).__init__(parent)
2147 		self.first_time = False
2149 	def resizeEvent(self, ev):  argument
2150 		if self.first_time:
2151 			self.first_time = False
2152 …sz1 = self.widget(1).view.columnWidth(0) + self.widget(1).view.columnWidth(1) + self.widget(1).vie…
2153 			sz1 = sz1 + self.widget(1).view.verticalScrollBar().sizeHint().width()
2154 			sz0 = self.size().width() - self.handleWidth() - sz1
2155 			self.setSizes([sz0, sz1])
2156 		elif not(self.widget(1).saved_size is None):
2157 			sz1 = self.widget(1).saved_size
2158 			sz0 = self.size().width() - self.handleWidth() - sz1
2159 			self.setSizes([sz0, sz1])
2160 		super(SwitchGraphSplitter, self).resizeEvent(ev)
2168 	def __init__(self, parent=None):  argument
2169 		super(GraphWidget, self).__init__(parent)
2171 	def GraphTitleChanged(self, title):  argument
2172 		self.graph_title_changed.emit(title)
2174 	def Title(self):  argument
2193 	def __init__(self, glb, collection, parent=None):  argument
2194 		super(SwitchGraphWidget, self).__init__(parent)
2196 		self.glb = glb
2197 		self.collection = collection
2199 		self.back_state = []
2200 		self.forward_state = []
2201 		self.selection_state = (None, None)
2202 		self.fwd_rect = None
2203 		self.start_time = self.glb.StartTime(collection.machine_id)
2221 		scale = self.GetScaleForRange(subrange)
2223 		self.attrs = GraphAttributes(scale, subrange, region_attributes, collection.dp)
2225 		self.item = VertcalGraphSetGraphicsItem(collection, self.attrs, self, SwitchGraphGraphicsItem)
2227 		self.scene = QGraphicsScene()
2228 		self.scene.addItem(self.item)
2230 		self.view = QGraphicsView(self.scene)
2231 		self.view.centerOn(0, 0)
2232 		self.view.setAlignment(Qt.AlignLeft | Qt.AlignTop)
2234 		self.legend = SwitchGraphLegend(collection, region_attributes)
2236 		self.splitter = SwitchGraphSplitter()
2237 		self.splitter.addWidget(self.view)
2238 		self.splitter.addWidget(self.legend)
2240 		self.point_label = QLabel("")
2241 		self.point_label.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
2243 		self.back_button = QToolButton()
2244 		self.back_button.setIcon(self.style().standardIcon(QStyle.SP_ArrowLeft))
2245 		self.back_button.setDisabled(True)
2246 		self.back_button.released.connect(lambda: self.Back())
2248 		self.forward_button = QToolButton()
2249 		self.forward_button.setIcon(self.style().standardIcon(QStyle.SP_ArrowRight))
2250 		self.forward_button.setDisabled(True)
2251 		self.forward_button.released.connect(lambda: self.Forward())
2253 		self.zoom_button = QToolButton()
2254 		self.zoom_button.setText("Zoom")
2255 		self.zoom_button.setDisabled(True)
2256 		self.zoom_button.released.connect(lambda: self.Zoom())
2258 		self.hbox = HBoxLayout(self.back_button, self.forward_button, self.zoom_button, self.point_label)
2260 		self.vbox = VBoxLayout(self.splitter, self.hbox)
2262 		self.setLayout(self.vbox)
2264 	def GetScaleForRangeX(self, xsubrange):  argument
2270 	def GetScaleForRangeY(self, ysubrange):  argument
2276 	def GetScaleForRange(self, subrange):  argument
2278 		xscale = self.GetScaleForRangeX(subrange.x)
2279 		yscale = self.GetScaleForRangeY(subrange.y)
2282 	def PointEvent(self, cpu, time_from, time_to, hregions):  argument
2285 		rel_time_from = time_from - self.glb.StartTime(self.collection.machine_id)
2287 		self.point_label.setText(text)
2288 		self.legend.Highlight(hregions)
2290 	def RightClickEvent(self, cpu, hregion_times, pos):  argument
2291 		if not IsSelectable(self.glb.db, "calls", "WHERE parent_id >= 0"):
2293 		menu = QMenu(self.view)
2297 …text, "Show Call Tree", lambda a=None, args=thread_at_time: self.RightClickSelect(args), self.view…
2300 	def RightClickSelect(self, args):  argument
2301 		CallTreeWindow(self.glb, self.glb.mainwindow, thread_at_time=args)
2303 	def NoPointEvent(self):  argument
2304 		self.point_label.setText("")
2305 		self.legend.Highlight({})
2307 	def RangeEvent(self, time_from, time_to):  argument
2311 			self.point_label.setText("")
2313 		rel_time_from = time_from - self.start_time
2314 		rel_time_to = time_to - self.start_time
2317 		self.point_label.setText(text)
2319 	def BackState(self):  argument
2320 		return (self.attrs.subrange, self.attrs.scale, self.selection_state, self.fwd_rect)
2322 	def PushBackState(self):  argument
2323 		state = copy.deepcopy(self.BackState())
2324 		self.back_state.append(state)
2325 		self.back_button.setEnabled(True)
2327 	def PopBackState(self):  argument
2328 		self.attrs.subrange, self.attrs.scale, self.selection_state, self.fwd_rect = self.back_state.pop()
2329 		self.attrs.Update()
2330 		if not self.back_state:
2331 			self.back_button.setDisabled(True)
2333 	def PushForwardState(self):  argument
2334 		state = copy.deepcopy(self.BackState())
2335 		self.forward_state.append(state)
2336 		self.forward_button.setEnabled(True)
2338 	def PopForwardState(self):  argument
2339 …self.attrs.subrange, self.attrs.scale, self.selection_state, self.fwd_rect = self.forward_state.po…
2340 		self.attrs.Update()
2341 		if not self.forward_state:
2342 			self.forward_button.setDisabled(True)
2344 	def Title(self):  argument
2345 		time_from = self.collection.xrangelo + Decimal(self.attrs.subrange.x.lo)
2346 		time_to = self.collection.xrangelo + Decimal(self.attrs.subrange.x.hi)
2347 		rel_time_from = time_from - self.start_time
2348 		rel_time_to = time_to - self.start_time
2353 	def Update(self):  argument
2354 		selected_subrange, selection_state = self.selection_state
2355 		self.item.SetSelection(selection_state)
2356 		self.item.SetBracket(self.fwd_rect)
2357 		self.zoom_button.setDisabled(selected_subrange is None)
2358 		self.GraphTitleChanged(self.Title())
2359 		self.item.update(self.item.boundingRect())
2361 	def Back(self):  argument
2362 		if not self.back_state:
2364 		self.PushForwardState()
2365 		self.PopBackState()
2366 		self.Update()
2368 	def Forward(self):  argument
2369 		if not self.forward_state:
2371 		self.PushBackState()
2372 		self.PopForwardState()
2373 		self.Update()
2375 	def SelectEvent(self, x0, x1, selection_state):  argument
2382 		self.selection_state = (selected_subrange, selection_state)
2383 		self.zoom_button.setDisabled(selected_subrange is None)
2385 	def Zoom(self):  argument
2386 		selected_subrange, selection_state = self.selection_state
2389 		self.fwd_rect = selection_state
2390 		self.item.SetSelection(None)
2391 		self.PushBackState()
2392 		self.attrs.subrange.x = selected_subrange
2393 		self.forward_state = []
2394 		self.forward_button.setDisabled(True)
2395 		self.selection_state = (None, None)
2396 		self.fwd_rect = None
2397 		self.attrs.scale.x = self.GetScaleForRangeX(self.attrs.subrange.x)
2398 		self.attrs.Update()
2399 		self.Update()
2405 	def __init__(self, glb, title, init_fn):  argument
2406 		self.init_fn = init_fn
2407 		self.done = False
2408 		self.result = None
2410 		self.msg_box = QMessageBox(glb.mainwindow)
2411 		self.msg_box.setText("Initializing " + title + ". Please wait.")
2412 		self.msg_box.setWindowTitle("Initializing " + title)
2413 		self.msg_box.setWindowIcon(glb.mainwindow.style().standardIcon(QStyle.SP_MessageBoxInformation))
2415 		self.init_thread = Thread(self.ThreadFn, glb)
2416 		self.init_thread.done.connect(lambda: self.Done(), Qt.QueuedConnection)
2418 		self.init_thread.start()
2420 	def Done(self):  argument
2421 		self.msg_box.done(0)
2423 	def ThreadFn(self, glb):  argument
2426 		self.result = self.init_fn(db)
2427 		self.done = True
2430 	def Result(self):  argument
2431 		while not self.done:
2432 			self.msg_box.exec_()
2433 		self.init_thread.wait()
2434 		return self.result
2444 	def __init__(self, glb, parent=None):  argument
2445 		super(TimeChartByCPUWindow, self).__init__(parent)
2447 		self.glb = glb
2448 		self.machine_id = glb.HostMachineId()
2449 		self.collection_name = "SwitchGraphDataCollection " + str(self.machine_id)
2451 		collection = LookupModel(self.collection_name)
2453 			collection = SlowInit(glb, "Time Chart", self.Init)
2455 		self.widget = SwitchGraphWidget(glb, collection, self)
2456 		self.view = self.widget
2458 		self.base_title = "Time Chart by CPU"
2459 		self.setWindowTitle(self.base_title + self.widget.Title())
2460 		self.widget.graph_title_changed.connect(self.GraphTitleChanged)
2462 		self.setWidget(self.widget)
2464 		AddSubWindow(glb.mainwindow.mdi_area, self, self.windowTitle())
2466 	def Init(self, db):  argument
2467 …return LookupCreateModel(self.collection_name, lambda : SwitchGraphDataCollection(self.glb, db, se…
2469 	def GraphTitleChanged(self, title):  argument
2470 		self.setWindowTitle(self.base_title + " : " + title)
2476 	def __init__(self, root):  argument
2477 		self.root = root
2478 		self.value, self.direction, self.pattern, self.last_value, self.last_pattern = (None,) * 5
2479 		self.rows = []
2480 		self.pos = 0
2482 	def FindSelect(self):  argument
2483 		self.rows = []
2484 		if self.pattern:
2485 			pattern = re.compile(self.value)
2486 			for child in self.root.child_items:
2489 						self.rows.append(child.row)
2492 			for child in self.root.child_items:
2494 					if self.value in str(column_data):
2495 						self.rows.append(child.row)
2498 	def FindValue(self):  argument
2499 		self.pos = 0
2500 		if self.last_value != self.value or self.pattern != self.last_pattern:
2501 			self.FindSelect()
2502 		if not len(self.rows):
2504 		return self.rows[self.pos]
2506 	def FindThread(self):  argument
2507 		if self.direction == 0 or self.value != self.last_value or self.pattern != self.last_pattern:
2508 			row = self.FindValue()
2509 		elif len(self.rows):
2510 			if self.direction > 0:
2511 				self.pos += 1
2512 				if self.pos >= len(self.rows):
2513 					self.pos = 0
2515 				self.pos -= 1
2516 				if self.pos < 0:
2517 					self.pos = len(self.rows) - 1
2518 			row = self.rows[self.pos]
2523 	def Find(self, value, direction, pattern, context, callback):  argument
2524 …self.value, self.direction, self.pattern, self.last_value, self.last_pattern = (value, direction,p…
2526 		thread = Thread(self.FindThread)
2527 …thread.done.connect(lambda row, t=thread, c=callback: self.FindDone(t, c, row), Qt.QueuedConnectio…
2530 	def FindDone(self, thread, callback, row):  argument
2541 …def __init__(self, dbref, sql, buffer, head, tail, fetch_count, fetching_done, process_target, wai…  argument
2544 		self.db, dbname = dbref.Open(conn_name)
2545 		self.sql = sql
2546 		self.buffer = buffer
2547 		self.head = head
2548 		self.tail = tail
2549 		self.fetch_count = fetch_count
2550 		self.fetching_done = fetching_done
2551 		self.process_target = process_target
2552 		self.wait_event = wait_event
2553 		self.fetched_event = fetched_event
2554 		self.prep = prep
2555 		self.query = QSqlQuery(self.db)
2556 		self.query_limit = 0 if "$$last_id$$" in sql else 2
2557 		self.last_id = -1
2558 		self.fetched = 0
2559 		self.more = True
2560 		self.local_head = self.head.value
2561 		self.local_tail = self.tail.value
2563 	def Select(self):  argument
2564 		if self.query_limit:
2565 			if self.query_limit == 1:
2567 			self.query_limit -= 1
2568 		stmt = self.sql.replace("$$last_id$$", str(self.last_id))
2569 		QueryExec(self.query, stmt)
2571 	def Next(self):  argument
2572 		if not self.query.next():
2573 			self.Select()
2574 			if not self.query.next():
2576 		self.last_id = self.query.value(0)
2577 		return self.prep(self.query)
2579 	def WaitForTarget(self):  argument
2581 			self.wait_event.clear()
2582 			target = self.process_target.value
2583 			if target > self.fetched or target < 0:
2585 			self.wait_event.wait()
2588 	def HasSpace(self, sz):  argument
2589 		if self.local_tail <= self.local_head:
2590 			space = len(self.buffer) - self.local_head
2596 				self.buffer[self.local_head : self.local_head + len(nd)] = nd
2597 			self.local_head = 0
2598 		if self.local_tail - self.local_head > sz:
2602 	def WaitForSpace(self, sz):  argument
2603 		if self.HasSpace(sz):
2606 			self.wait_event.clear()
2607 			self.local_tail = self.tail.value
2608 			if self.HasSpace(sz):
2610 			self.wait_event.wait()
2612 	def AddToBuffer(self, obj):  argument
2617 		self.WaitForSpace(sz)
2618 		pos = self.local_head
2619 		self.buffer[pos : pos + len(nd)] = nd
2620 		self.buffer[pos + glb_nsz : pos + sz] = d
2621 		self.local_head += sz
2623 	def FetchBatch(self, batch_size):  argument
2626 			obj = self.Next()
2628 				self.more = False
2630 			self.AddToBuffer(obj)
2633 			self.fetched += fetched
2634 			with self.fetch_count.get_lock():
2635 				self.fetch_count.value += fetched
2636 			self.head.value = self.local_head
2637 			self.fetched_event.set()
2639 	def Run(self):  argument
2640 		while self.more:
2641 			target = self.WaitForTarget()
2644 			batch_size = min(glb_chunk_sz, target - self.fetched)
2645 			self.FetchBatch(batch_size)
2646 		self.fetching_done.value = True
2647 		self.fetched_event.set()
2659 	def __init__(self, glb, sql, prep, process_data, parent=None):  argument
2660 		super(SQLFetcher, self).__init__(parent)
2661 		self.process_data = process_data
2662 		self.more = True
2663 		self.target = 0
2664 		self.last_target = 0
2665 		self.fetched = 0
2666 		self.buffer_size = 16 * 1024 * 1024
2667 		self.buffer = Array(c_char, self.buffer_size, lock=False)
2668 		self.head = Value(c_longlong)
2669 		self.tail = Value(c_longlong)
2670 		self.local_tail = 0
2671 		self.fetch_count = Value(c_longlong)
2672 		self.fetching_done = Value(c_bool)
2673 		self.last_count = 0
2674 		self.process_target = Value(c_longlong)
2675 		self.wait_event = Event()
2676 		self.fetched_event = Event()
2677 		glb.AddInstanceToShutdownOnExit(self)
2678 …self.process = Process(target=SQLFetcherFn, args=(glb.dbref, sql, self.buffer, self.head, self.tai…
2679 		self.process.start()
2680 		self.thread = Thread(self.Thread)
2681 		self.thread.done.connect(self.ProcessData, Qt.QueuedConnection)
2682 		self.thread.start()
2684 	def Shutdown(self):  argument
2686 		self.process_target.value = -1
2687 		self.wait_event.set()
2688 		self.more = False
2689 		self.fetching_done.value = True
2690 		self.fetched_event.set()
2692 	def Thread(self):  argument
2693 		if not self.more:
2696 			self.fetched_event.clear()
2697 			fetch_count = self.fetch_count.value
2698 			if fetch_count != self.last_count:
2700 			if self.fetching_done.value:
2701 				self.more = False
2703 			self.fetched_event.wait()
2704 		count = fetch_count - self.last_count
2705 		self.last_count = fetch_count
2706 		self.fetched += count
2709 	def Fetch(self, nr):  argument
2710 		if not self.more:
2713 		result = self.fetched
2714 		extra = result + nr - self.target
2716 			self.target += extra
2718 			if self.process_target.value >= 0:
2719 				self.process_target.value = self.target
2720 			self.wait_event.set()
2723 	def RemoveFromBuffer(self):  argument
2724 		pos = self.local_tail
2725 		if len(self.buffer) - pos < glb_nsz:
2727 		n = pickle.loads(self.buffer[pos : pos + glb_nsz])
2730 			n = pickle.loads(self.buffer[0 : glb_nsz])
2732 		obj = pickle.loads(self.buffer[pos : pos + n])
2733 		self.local_tail = pos + n
2736 	def ProcessData(self, count):  argument
2738 			obj = self.RemoveFromBuffer()
2739 			self.process_data(obj)
2740 		self.tail.value = self.local_tail
2741 		self.wait_event.set()
2742 		self.done.emit(count)
2748 	def __init__(self, model, parent):  argument
2749 		self.model = model
2751 		self.label = QLabel("Number of records (x " + "{:,}".format(glb_chunk_sz) + ") to fetch:")
2752 		self.label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
2754 		self.fetch_count = QSpinBox()
2755 		self.fetch_count.setRange(1, 1000000)
2756 		self.fetch_count.setValue(10)
2757 		self.fetch_count.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
2759 		self.fetch = QPushButton("Go!")
2760 		self.fetch.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
2761 		self.fetch.released.connect(self.FetchMoreRecords)
2763 		self.progress = QProgressBar()
2764 		self.progress.setRange(0, 100)
2765 		self.progress.hide()
2767 		self.done_label = QLabel("All records fetched")
2768 		self.done_label.hide()
2770 		self.spacer = QLabel("")
2772 		self.close_button = QToolButton()
2773 		self.close_button.setIcon(parent.style().standardIcon(QStyle.SP_DockWidgetCloseButton))
2774 		self.close_button.released.connect(self.Deactivate)
2776 		self.hbox = QHBoxLayout()
2777 		self.hbox.setContentsMargins(0, 0, 0, 0)
2779 		self.hbox.addWidget(self.label)
2780 		self.hbox.addWidget(self.fetch_count)
2781 		self.hbox.addWidget(self.fetch)
2782 		self.hbox.addWidget(self.spacer)
2783 		self.hbox.addWidget(self.progress)
2784 		self.hbox.addWidget(self.done_label)
2785 		self.hbox.addWidget(self.close_button)
2787 		self.bar = QWidget()
2788 		self.bar.setLayout(self.hbox)
2789 		self.bar.show()
2791 		self.in_progress = False
2792 		self.model.progress.connect(self.Progress)
2794 		self.done = False
2797 			self.Done()
2799 	def Widget(self):  argument
2800 		return self.bar
2802 	def Activate(self):  argument
2803 		self.bar.show()
2804 		self.fetch.setFocus()
2806 	def Deactivate(self):  argument
2807 		self.bar.hide()
2809 	def Enable(self, enable):  argument
2810 		self.fetch.setEnabled(enable)
2811 		self.fetch_count.setEnabled(enable)
2813 	def Busy(self):  argument
2814 		self.Enable(False)
2815 		self.fetch.hide()
2816 		self.spacer.hide()
2817 		self.progress.show()
2819 	def Idle(self):  argument
2820 		self.in_progress = False
2821 		self.Enable(True)
2822 		self.progress.hide()
2823 		self.fetch.show()
2824 		self.spacer.show()
2826 	def Target(self):  argument
2827 		return self.fetch_count.value() * glb_chunk_sz
2829 	def Done(self):  argument
2830 		self.done = True
2831 		self.Idle()
2832 		self.label.hide()
2833 		self.fetch_count.hide()
2834 		self.fetch.hide()
2835 		self.spacer.hide()
2836 		self.done_label.show()
2838 	def Progress(self, count):  argument
2839 		if self.in_progress:
2841 				percent = ((count - self.start) * 100) / self.Target()
2843 					self.Idle()
2845 					self.progress.setValue(percent)
2848 			self.Done()
2850 	def FetchMoreRecords(self):  argument
2851 		if self.done:
2853 		self.progress.setValue(0)
2854 		self.Busy()
2855 		self.in_progress = True
2856 		self.start = self.model.FetchMoreRecords(self.Target())
2862 	def __init__(self, row, col, text, parent_item):  argument
2863 		self.row = row
2864 		self.parent_item = parent_item
2865 		self.data = [""] * (col + 1)
2866 		self.data[col] = text
2867 		self.level = 2
2869 	def getParentItem(self):  argument
2870 		return self.parent_item
2872 	def getRow(self):  argument
2873 		return self.row
2875 	def childCount(self):  argument
2878 	def hasChildren(self):  argument
2881 	def getData(self, column):  argument
2882 		return self.data[column]
2888 	def __init__(self, glb, row, data, parent_item):  argument
2889 		self.glb = glb
2890 		self.row = row
2891 		self.parent_item = parent_item
2892 		self.child_count = 0
2893 		self.child_items = []
2894 		self.data = data[1:]
2895 		self.dbid = data[0]
2896 		self.level = 1
2897 		self.query_done = False
2898 		self.br_col = len(self.data) - 1
2900 	def getChildItem(self, row):  argument
2901 		return self.child_items[row]
2903 	def getParentItem(self):  argument
2904 		return self.parent_item
2906 	def getRow(self):  argument
2907 		return self.row
2909 	def Select(self):  argument
2910 		self.query_done = True
2912 		if not self.glb.have_disassembler:
2915 		query = QSqlQuery(self.glb.db)
2921 				  " WHERE samples.id = " + str(self.dbid))
2939 				  " WHERE samples.id > " + str(self.dbid) + " AND cpu = " + str(cpu) +
2956 		inst = self.glb.disassembler.Instruction()
2957 		f = self.glb.FileFromNamesAndBuildId(short_name, long_name, build_id)
2961 		self.glb.disassembler.SetMode(inst, mode)
2970 			cnt, text = self.glb.disassembler.DisassembleOne(inst, buf_ptr, buf_sz, ip)
2979 				self.child_items.append(BranchLevelTwoItem(0, self.br_col, byte_str + " " + text, self))
2980 				self.child_count += 1
2988 	def childCount(self):  argument
2989 		if not self.query_done:
2990 			self.Select()
2991 			if not self.child_count:
2993 		return self.child_count
2995 	def hasChildren(self):  argument
2996 		if not self.query_done:
2998 		return self.child_count > 0
3000 	def getData(self, column):  argument
3001 		return self.data[column]
3007 	def __init__(self):  argument
3008 		self.child_count = 0
3009 		self.child_items = []
3010 		self.level = 0
3012 	def getChildItem(self, row):  argument
3013 		return self.child_items[row]
3015 	def getParentItem(self):  argument
3018 	def getRow(self):  argument
3021 	def childCount(self):  argument
3022 		return self.child_count
3024 	def hasChildren(self):  argument
3025 		return self.child_count > 0
3027 	def getData(self, column):  argument
3098 	def __init__(self, glb, event_id, where_clause, parent=None):  argument
3099 		super(BranchModel, self).__init__(glb, None, parent)
3100 		self.event_id = event_id
3101 		self.more = True
3102 		self.populated = 0
3103 		self.have_ipc = IsSelectable(glb.db, "samples", columns = "insn_count, cyc_count")
3104 		if self.have_ipc:
3126 			" AND evsel_id = " + str(self.event_id) +
3133 		self.fetcher = SQLFetcher(glb, sql, prep, self.AddSample)
3134 		self.fetcher.done.connect(self.Update)
3135 		self.fetcher.Fetch(glb_chunk_sz)
3137 	def GetRoot(self):  argument
3140 	def columnCount(self, parent=None):  argument
3141 		if self.have_ipc:
3146 	def columnHeader(self, column):  argument
3147 		if self.have_ipc:
3152 	def columnFont(self, column):  argument
3153 		if self.have_ipc:
3161 	def DisplayData(self, item, index):  argument
3163 			self.FetchIfNeeded(item.row)
3166 	def AddSample(self, data):  argument
3167 		child = BranchLevelOneItem(self.glb, self.populated, data, self.root)
3168 		self.root.child_items.append(child)
3169 		self.populated += 1
3171 	def Update(self, fetched):  argument
3173 			self.more = False
3174 			self.progress.emit(0)
3175 		child_count = self.root.child_count
3176 		count = self.populated - child_count
3179 			self.beginInsertRows(parent, child_count, child_count + count - 1)
3180 			self.insertRows(child_count, count, parent)
3181 			self.root.child_count += count
3182 			self.endInsertRows()
3183 			self.progress.emit(self.root.child_count)
3185 	def FetchMoreRecords(self, count):  argument
3186 		current = self.root.child_count
3187 		if self.more:
3188 			self.fetcher.Fetch(count)
3190 			self.progress.emit(0)
3193 	def HasMoreRecords(self):  argument
3194 		return self.more
3200 	def __init__(self, name = "", where_clause = "", limit = ""):  argument
3201 		self.name = name
3202 		self.where_clause = where_clause
3203 		self.limit = limit
3205 	def UniqueId(self):  argument
3206 		return str(self.where_clause + ";" + self.limit)
3212 	def __init__(self, glb, event_id, report_vars, parent=None):  argument
3213 		super(BranchWindow, self).__init__(parent)
3217 …self.model = LookupCreateModel(model_name, lambda: BranchModel(glb, event_id, report_vars.where_cl…
3219 		self.view = QTreeView()
3220 		self.view.setUniformRowHeights(True)
3221 		self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
3222 		self.view.CopyCellsToClipboard = CopyTreeCellsToClipboard
3223 		self.view.setModel(self.model)
3225 		self.ResizeColumnsToContents()
3227 		self.context_menu = TreeContextMenu(self.view)
3229 		self.find_bar = FindBar(self, self, True)
3231 		self.finder = ChildDataItemFinder(self.model.root)
3233 		self.fetch_bar = FetchMoreRecordsBar(self.model, self)
3235 		self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())
3237 		self.setWidget(self.vbox.Widget())
3239 		AddSubWindow(glb.mainwindow.mdi_area, self, report_vars.name + " Branch Events")
3241 	def ResizeColumnToContents(self, column, n):  argument
3245 		font = self.view.font()
3249 			val = self.model.root.child_items[row].data[column]
3252 		val = self.model.columnHeader(column)
3255 		self.view.setColumnWidth(column, max)
3257 	def ResizeColumnsToContents(self):  argument
3258 		n = min(self.model.root.child_count, 100)
3261 			self.model.rowsInserted.connect(self.UpdateColumnWidths)
3263 		columns = self.model.columnCount()
3265 			self.ResizeColumnToContents(i, n)
3267 	def UpdateColumnWidths(self, *x):  argument
3269 		self.model.rowsInserted.disconnect(self.UpdateColumnWidths)
3270 		self.ResizeColumnsToContents()
3272 	def Find(self, value, direction, pattern, context):  argument
3273 		self.view.setFocus()
3274 		self.find_bar.Busy()
3275 		self.finder.Find(value, direction, pattern, context, self.FindDone)
3277 	def FindDone(self, row):  argument
3278 		self.find_bar.Idle()
3280 			self.view.setCurrentIndex(self.model.index(row, 0, QModelIndex()))
3282 			self.find_bar.NotFound()
3288 	def __init__(self, glb, label, placeholder_text, parent, id = "", default = ""):  argument
3289 		self.glb = glb
3290 		self.label = label
3291 		self.placeholder_text = placeholder_text
3292 		self.parent = parent
3293 		self.id = id
3295 		self.value = default
3297 		self.widget = QLineEdit(default)
3298 		self.widget.editingFinished.connect(self.Validate)
3299 		self.widget.textChanged.connect(self.Invalidate)
3300 		self.red = False
3301 		self.error = ""
3302 		self.validated = True
3305 			self.widget.setPlaceholderText(placeholder_text)
3307 	def TurnTextRed(self):  argument
3308 		if not self.red:
3311 			self.widget.setPalette(palette)
3312 			self.red = True
3314 	def TurnTextNormal(self):  argument
3315 		if self.red:
3317 			self.widget.setPalette(palette)
3318 			self.red = False
3320 	def InvalidValue(self, value):  argument
3321 		self.value = ""
3322 		self.TurnTextRed()
3323 		self.error = self.label + " invalid value '" + value + "'"
3324 		self.parent.ShowMessage(self.error)
3326 	def Invalidate(self):  argument
3327 		self.validated = False
3329 	def DoValidate(self, input_string):  argument
3330 		self.value = input_string.strip()
3332 	def Validate(self):  argument
3333 		self.validated = True
3334 		self.error = ""
3335 		self.TurnTextNormal()
3336 		self.parent.ClearMessage()
3337 		input_string = self.widget.text()
3339 			self.value = ""
3341 		self.DoValidate(input_string)
3343 	def IsValid(self):  argument
3344 		if not self.validated:
3345 			self.Validate()
3346 		if len(self.error):
3347 			self.parent.ShowMessage(self.error)
3351 	def IsNumber(self, value):  argument
3362 	def __init__(self, glb, label, placeholder_text, column_name, parent):  argument
3363 		super(NonNegativeIntegerRangesDataItem, self).__init__(glb, label, placeholder_text, parent)
3365 		self.column_name = column_name
3367 	def DoValidate(self, input_string):  argument
3373 				if len(vrange) != 2 or not self.IsNumber(vrange[0]) or not self.IsNumber(vrange[1]):
3374 					return self.InvalidValue(value)
3377 				if not self.IsNumber(value):
3378 					return self.InvalidValue(value)
3380 …ranges = [("(" + self.column_name + " >= " + r[0] + " AND " + self.column_name + " <= " + r[1] + "…
3382 			ranges.append(self.column_name + " IN (" + ",".join(singles) + ")")
3383 		self.value = " OR ".join(ranges)
3389 	def __init__(self, glb, label, placeholder_text, parent, id = "", default = ""):  argument
3390 		super(PositiveIntegerDataItem, self).__init__(glb, label, placeholder_text, parent, id, default)
3392 	def DoValidate(self, input_string):  argument
3393 		if not self.IsNumber(input_string.strip()):
3394 			return self.InvalidValue(input_string)
3397 			return self.InvalidValue(input_string)
3398 		self.value = str(value)
3404 …def __init__(self, glb, label, placeholder_text, table_name, match_column, column_name1, column_na…  argument
3405 		super(SQLTableDataItem, self).__init__(glb, label, placeholder_text, parent)
3407 		self.table_name = table_name
3408 		self.match_column = match_column
3409 		self.column_name1 = column_name1
3410 		self.column_name2 = column_name2
3412 	def ValueToIds(self, value):  argument
3414 		query = QSqlQuery(self.glb.db)
3415 		stmt = "SELECT id FROM " + self.table_name + " WHERE " + self.match_column + " = '" + value + "'"
3422 	def DoValidate(self, input_string):  argument
3425 			ids = self.ValueToIds(value)
3429 				return self.InvalidValue(value)
3430 		self.value = self.column_name1 + " IN (" + ",".join(all_ids) + ")"
3431 		if self.column_name2:
3432 			self.value = "( " + self.value + " OR " + self.column_name2 + " IN (" + ",".join(all_ids) + ") )"
3438 	def __init__(self, glb, label, placeholder_text, column_name, parent):  argument
3439 		self.column_name = column_name
3441 		self.last_id = 0
3442 		self.first_time = 0
3443 		self.last_time = 2 ** 64
3448 			self.last_id = int(query.value(0))
3449 		self.first_time = int(glb.HostStartTime())
3450 		self.last_time = int(glb.HostFinishTime())
3452 			placeholder_text += ", between " + str(self.first_time) + " and " + str(self.last_time)
3454 		super(SampleTimeRangesDataItem, self).__init__(glb, label, placeholder_text, parent)
3456 	def IdBetween(self, query, lower_id, higher_id, order):  argument
3463 	def BinarySearchTime(self, lower_id, higher_id, target_time, get_floor):  argument
3464 		query = QSqlQuery(self.glb.db)
3469 				ok, dbid = self.IdBetween(query, lower_id, next_id, "DESC")
3471 					ok, dbid = self.IdBetween(query, next_id, higher_id, "")
3492 	def ConvertRelativeTime(self, val):  argument
3504 		if not self.IsNumber(val):
3508 			val += self.first_time
3510 			val += self.last_time
3513 	def ConvertTimeRange(self, vrange):  argument
3515 			vrange[0] = str(self.first_time)
3517 			vrange[1] = str(self.last_time)
3518 		vrange[0] = self.ConvertRelativeTime(vrange[0])
3519 		vrange[1] = self.ConvertRelativeTime(vrange[1])
3520 		if not self.IsNumber(vrange[0]) or not self.IsNumber(vrange[1]):
3522 		beg_range = max(int(vrange[0]), self.first_time)
3523 		end_range = min(int(vrange[1]), self.last_time)
3524 		if beg_range > self.last_time or end_range < self.first_time:
3526 		vrange[0] = self.BinarySearchTime(0, self.last_id, beg_range, True)
3527 		vrange[1] = self.BinarySearchTime(1, self.last_id + 1, end_range, False)
3530 	def AddTimeRange(self, value, ranges):  argument
3543 		if self.ConvertTimeRange(vrange):
3548 	def DoValidate(self, input_string):  argument
3551 			if not self.AddTimeRange(value, ranges):
3552 				return self.InvalidValue(value)
3553 …ranges = [("(" + self.column_name + " >= " + r[0] + " AND " + self.column_name + " <= " + r[1] + "…
3554 		self.value = " OR ".join(ranges)
3560 	def __init__(self, glb, title, items, partial, parent=None):  argument
3561 		super(ReportDialogBase, self).__init__(parent)
3563 		self.glb = glb
3565 		self.report_vars = ReportVars()
3567 		self.setWindowTitle(title)
3568 		self.setMinimumWidth(600)
3570 		self.data_items = [x(glb, self) for x in items]
3572 		self.partial = partial
3574 		self.grid = QGridLayout()
3576 		for row in xrange(len(self.data_items)):
3577 			self.grid.addWidget(QLabel(self.data_items[row].label), row, 0)
3578 			self.grid.addWidget(self.data_items[row].widget, row, 1)
3580 		self.status = QLabel()
3582 		self.ok_button = QPushButton("Ok", self)
3583 		self.ok_button.setDefault(True)
3584 		self.ok_button.released.connect(self.Ok)
3585 		self.ok_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
3587 		self.cancel_button = QPushButton("Cancel", self)
3588 		self.cancel_button.released.connect(self.reject)
3589 		self.cancel_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
3591 		self.hbox = QHBoxLayout()
3592 		#self.hbox.addStretch()
3593 		self.hbox.addWidget(self.status)
3594 		self.hbox.addWidget(self.ok_button)
3595 		self.hbox.addWidget(self.cancel_button)
3597 		self.vbox = QVBoxLayout()
3598 		self.vbox.addLayout(self.grid)
3599 		self.vbox.addLayout(self.hbox)
3601 		self.setLayout(self.vbox)
3603 	def Ok(self):  argument
3604 		vars = self.report_vars
3605 		for d in self.data_items:
3609 			self.ShowMessage("Report name is required")
3611 		for d in self.data_items:
3614 		for d in self.data_items[1:]:
3622 			if self.partial:
3626 		self.accept()
3628 	def ShowMessage(self, msg):  argument
3629 		self.status.setText("<font color=#FF0000>" + msg)
3631 	def ClearMessage(self):  argument
3632 		self.status.setText("")
3638 	def __init__(self, glb, parent=None):  argument
3649 		super(SelectedBranchDialog, self).__init__(glb, title, items, True, parent)
3675 	def __init__(self, row, data):  argument
3676 		self.row = row
3677 		self.data = data
3679 	def getData(self, column):  argument
3680 		return self.data[column]
3688 	def __init__(self, glb, sql, column_headers, parent=None):  argument
3689 		super(SQLTableModel, self).__init__(parent)
3690 		self.glb = glb
3691 		self.more = True
3692 		self.populated = 0
3693 		self.column_headers = column_headers
3694 …self.fetcher = SQLFetcher(glb, sql, lambda x, y=len(column_headers): self.SQLTableDataPrep(x, y), …
3695 		self.fetcher.done.connect(self.Update)
3696 		self.fetcher.Fetch(glb_chunk_sz)
3698 	def DisplayData(self, item, index):  argument
3699 		self.FetchIfNeeded(item.row)
3702 	def AddSample(self, data):  argument
3703 		child = SQLTableItem(self.populated, data)
3704 		self.child_items.append(child)
3705 		self.populated += 1
3707 	def Update(self, fetched):  argument
3709 			self.more = False
3710 			self.progress.emit(0)
3711 		child_count = self.child_count
3712 		count = self.populated - child_count
3715 			self.beginInsertRows(parent, child_count, child_count + count - 1)
3716 			self.insertRows(child_count, count, parent)
3717 			self.child_count += count
3718 			self.endInsertRows()
3719 			self.progress.emit(self.child_count)
3721 	def FetchMoreRecords(self, count):  argument
3722 		current = self.child_count
3723 		if self.more:
3724 			self.fetcher.Fetch(count)
3726 			self.progress.emit(0)
3729 	def HasMoreRecords(self):  argument
3730 		return self.more
3732 	def columnCount(self, parent=None):  argument
3733 		return len(self.column_headers)
3735 	def columnHeader(self, column):  argument
3736 		return self.column_headers[column]
3738 	def SQLTableDataPrep(self, query, count):  argument
3748 	def __init__(self, glb, table_name, parent=None):  argument
3774 				self.SQLTableDataPrep = self.samples_view_DataPrep
3776 				self.SQLTableDataPrep = self.samples_DataPrep
3777 		super(SQLAutoTableModel, self).__init__(glb, sql, column_headers, parent)
3779 	def samples_view_DataPrep(self, query, count):  argument
3788 	def samples_DataPrep(self, query, count):  argument
3802 	def __init__(self, parent=None):  argument
3803 		super(ResizeColumnsToContentsBase, self).__init__(parent)
3805 	def ResizeColumnToContents(self, column, n):  argument
3808 		font = self.view.font()
3812 			val = self.data_model.child_items[row].data[column]
3815 		val = self.data_model.columnHeader(column)
3818 		self.view.setColumnWidth(column, max)
3820 	def ResizeColumnsToContents(self):  argument
3821 		n = min(self.data_model.child_count, 100)
3824 			self.data_model.rowsInserted.connect(self.UpdateColumnWidths)
3826 		columns = self.data_model.columnCount()
3828 			self.ResizeColumnToContents(i, n)
3830 	def UpdateColumnWidths(self, *x):  argument
3832 		self.data_model.rowsInserted.disconnect(self.UpdateColumnWidths)
3833 		self.ResizeColumnsToContents()
4040 	def __init__(self, view):  argument
4041 		self.view = view
4042 		self.view.setContextMenuPolicy(Qt.CustomContextMenu)
4043 		self.view.customContextMenuRequested.connect(self.ShowContextMenu)
4045 	def ShowContextMenu(self, pos):  argument
4046 		menu = QMenu(self.view)
4047 		self.AddActions(menu)
4048 		menu.exec_(self.view.mapToGlobal(pos))
4050 	def AddCopy(self, menu):  argument
4051 …ion("&Copy selection", "Copy to clipboard", lambda: CopyCellsToClipboardHdr(self.view), self.view))
4052 …ction as CS&V", "Copy to clipboard as CSV", lambda: CopyCellsToClipboardCSV(self.view), self.view))
4054 	def AddActions(self, menu):  argument
4055 		self.AddCopy(menu)
4059 	def __init__(self, view):  argument
4060 		super(TreeContextMenu, self).__init__(view)
4062 	def AddActions(self, menu):  argument
4063 		i = self.view.currentIndex()
4066 …y "' + text + '"', "Copy to clipboard", lambda: QApplication.clipboard().setText(text), self.view))
4067 		self.AddCopy(menu)
4073 	def __init__(self, glb, table_name, parent=None):  argument
4074 		super(TableWindow, self).__init__(parent)
4076 …self.data_model = LookupCreateModel(table_name + " Table", lambda: SQLAutoTableModel(glb, table_na…
4078 		self.model = QSortFilterProxyModel()
4079 		self.model.setSourceModel(self.data_model)
4081 		self.view = QTableView()
4082 		self.view.setModel(self.model)
4083 		self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
4084 		self.view.verticalHeader().setVisible(False)
4085 		self.view.sortByColumn(-1, Qt.AscendingOrder)
4086 		self.view.setSortingEnabled(True)
4087 		self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
4088 		self.view.CopyCellsToClipboard = CopyTableCellsToClipboard
4090 		self.ResizeColumnsToContents()
4092 		self.context_menu = ContextMenu(self.view)
4094 		self.find_bar = FindBar(self, self, True)
4096 		self.finder = ChildDataItemFinder(self.data_model)
4098 		self.fetch_bar = FetchMoreRecordsBar(self.data_model, self)
4100 		self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())
4102 		self.setWidget(self.vbox.Widget())
4104 		AddSubWindow(glb.mainwindow.mdi_area, self, table_name + " Table")
4106 	def Find(self, value, direction, pattern, context):  argument
4107 		self.view.setFocus()
4108 		self.find_bar.Busy()
4109 		self.finder.Find(value, direction, pattern, context, self.FindDone)
4111 	def FindDone(self, row):  argument
4112 		self.find_bar.Idle()
4114 			self.view.setCurrentIndex(self.model.mapFromSource(self.data_model.index(row, 0, QModelIndex())))
4116 			self.find_bar.NotFound()
4141 	def __init__(self, glb, report_vars, parent=None):  argument
4171 …self.alignment = (Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLe…
4172 		super(TopCallsModel, self).__init__(glb, sql, column_headers, parent)
4174 	def columnAlignment(self, column):  argument
4175 		return self.alignment[column]
4181 	def __init__(self, glb, parent=None):  argument
4191 		super(TopCallsDialog, self).__init__(glb, title, items, False, parent)
4197 	def __init__(self, glb, report_vars, parent=None):  argument
4198 		super(TopCallsWindow, self).__init__(parent)
4200 …self.data_model = LookupCreateModel("Top Calls " + report_vars.UniqueId(), lambda: TopCallsModel(g…
4201 		self.model = self.data_model
4203 		self.view = QTableView()
4204 		self.view.setModel(self.model)
4205 		self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
4206 		self.view.verticalHeader().setVisible(False)
4207 		self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
4208 		self.view.CopyCellsToClipboard = CopyTableCellsToClipboard
4210 		self.context_menu = ContextMenu(self.view)
4212 		self.ResizeColumnsToContents()
4214 		self.find_bar = FindBar(self, self, True)
4216 		self.finder = ChildDataItemFinder(self.model)
4218 		self.fetch_bar = FetchMoreRecordsBar(self.data_model, self)
4220 		self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())
4222 		self.setWidget(self.vbox.Widget())
4224 		AddSubWindow(glb.mainwindow.mdi_area, self, report_vars.name)
4226 	def Find(self, value, direction, pattern, context):  argument
4227 		self.view.setFocus()
4228 		self.find_bar.Busy()
4229 		self.finder.Find(value, direction, pattern, context, self.FindDone)
4231 	def FindDone(self, row):  argument
4232 		self.find_bar.Idle()
4234 			self.view.setCurrentIndex(self.model.index(row, 0, QModelIndex()))
4236 			self.find_bar.NotFound()
4277 	def __init__(self, mdi_area, menu):  argument
4278 		self.mdi_area = mdi_area
4279 		self.window_menu = menu.addMenu("&Windows")
4280 		self.close_active_window = CreateCloseActiveWindowAction(mdi_area)
4281 		self.close_all_windows = CreateCloseAllWindowsAction(mdi_area)
4282 		self.tile_windows = CreateTileWindowsAction(mdi_area)
4283 		self.cascade_windows = CreateCascadeWindowsAction(mdi_area)
4284 		self.next_window = CreateNextWindowAction(mdi_area)
4285 		self.previous_window = CreatePreviousWindowAction(mdi_area)
4286 		self.window_menu.aboutToShow.connect(self.Update)
4288 	def Update(self):  argument
4289 		self.window_menu.clear()
4290 		sub_window_count = len(self.mdi_area.subWindowList())
4292 		self.close_active_window.setEnabled(have_sub_windows)
4293 		self.close_all_windows.setEnabled(have_sub_windows)
4294 		self.tile_windows.setEnabled(have_sub_windows)
4295 		self.cascade_windows.setEnabled(have_sub_windows)
4296 		self.next_window.setEnabled(have_sub_windows)
4297 		self.previous_window.setEnabled(have_sub_windows)
4298 		self.window_menu.addAction(self.close_active_window)
4299 		self.window_menu.addAction(self.close_all_windows)
4300 		self.window_menu.addSeparator()
4301 		self.window_menu.addAction(self.tile_windows)
4302 		self.window_menu.addAction(self.cascade_windows)
4303 		self.window_menu.addSeparator()
4304 		self.window_menu.addAction(self.next_window)
4305 		self.window_menu.addAction(self.previous_window)
4308 		self.window_menu.addSeparator()
4310 		for sub_window in self.mdi_area.subWindowList():
4314 			action = self.window_menu.addAction(label)
4316 			action.setChecked(sub_window == self.mdi_area.activeSubWindow())
4317 			action.triggered.connect(lambda a=None,x=nr: self.setActiveSubWindow(x))
4318 			self.window_menu.addAction(action)
4321 	def setActiveSubWindow(self, nr):  argument
4322 		self.mdi_area.setActiveSubWindow(self.mdi_area.subWindowList()[nr - 1])
4475 	def __init__(self, glb, parent=None):  argument
4476 		super(HelpWindow, self).__init__(parent)
4478 		self.text = QTextBrowser()
4479 		self.text.setHtml(glb_help_text)
4480 		self.text.setReadOnly(True)
4481 		self.text.setOpenExternalLinks(True)
4483 		self.setWidget(self.text)
4485 		AddSubWindow(glb.mainwindow.mdi_area, self, "Exported SQL Viewer Help")
4491 	def __init__(self, parent=None):  argument
4492 		super(HelpOnlyWindow, self).__init__(parent)
4494 		self.setMinimumSize(200, 100)
4495 		self.resize(800, 600)
4496 		self.setWindowTitle("Exported SQL Viewer Help")
4497 		self.setWindowIcon(self.style().standardIcon(QStyle.SP_MessageBoxInformation))
4499 		self.text = QTextBrowser()
4500 		self.text.setHtml(glb_help_text)
4501 		self.text.setReadOnly(True)
4502 		self.text.setOpenExternalLinks(True)
4504 		self.setCentralWidget(self.text)
4532 	def __init__(self, glb, parent=None):  argument
4533 		super(AboutDialog, self).__init__(parent)
4535 		self.setWindowTitle("About Exported SQL Viewer")
4536 		self.setMinimumWidth(300)
4550 		self.text = QTextBrowser()
4551 		self.text.setHtml(text)
4552 		self.text.setReadOnly(True)
4553 		self.text.setOpenExternalLinks(True)
4555 		self.vbox = QVBoxLayout()
4556 		self.vbox.addWidget(self.text)
4558 		self.setLayout(self.vbox)
4611 	def __init__(self, glb, parent=None):  argument
4612 		super(MainWindow, self).__init__(parent)
4614 		self.glb = glb
4616 		self.setWindowTitle("Exported SQL Viewer: " + glb.dbname)
4617 		self.setWindowIcon(self.style().standardIcon(QStyle.SP_ComputerIcon))
4618 		self.setMinimumSize(200, 100)
4620 		self.mdi_area = QMdiArea()
4621 		self.mdi_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
4622 		self.mdi_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
4624 		self.setCentralWidget(self.mdi_area)
4626 		menu = self.menuBar()
4629 		file_menu.addAction(CreateExitAction(glb.app, self))
4632 …edit_menu.addAction(CreateAction("&Copy", "Copy to clipboard", self.CopyToClipboard, self, QKeySeq…
4633 ….addAction(CreateAction("Copy as CS&V", "Copy to clipboard as CSV", self.CopyToClipboardCSV, self))
4634 		edit_menu.addAction(CreateAction("&Find...", "Find items", self.Find, self, QKeySequence.Find))
4635 …n(CreateAction("Fetch &more records...", "Fetch more records", self.FetchMoreRecords, self, [QKeyS…
4636 …edit_menu.addAction(CreateAction("&Shrink Font", "Make text smaller", self.ShrinkFont, self, [QKey…
4637 …edit_menu.addAction(CreateAction("&Enlarge Font", "Make text bigger", self.EnlargeFont, self, [QKe…
4641 …&Graph", "Create a new window containing a context-sensitive call graph", self.NewCallGraph, self))
4644 …n(CreateAction("Call &Tree", "Create a new window containing a call tree", self.NewCallTree, self))
4646 		self.EventMenu(GetEventList(glb.db), reports_menu)
4649 …elapsed time", "Create a new window displaying top calls by elapsed time", self.NewTopCalls, self))
4653 …ime chart by CPU", "Create a new window displaying time charts by CPU", self.TimeChartByCPU, self))
4655 		self.TableMenu(GetTableList(glb), menu)
4657 		self.window_menu = WindowMenu(self.mdi_area, menu)
4660 …ion(CreateAction("&Exported SQL Viewer Help", "Helpful information", self.Help, self, QKeySequence…
4661 …u.addAction(CreateAction("&About Exported SQL Viewer", "About this application", self.About, self))
4663 	def Try(self, fn):  argument
4664 		win = self.mdi_area.activeSubWindow()
4671 	def CopyToClipboard(self):  argument
4672 		self.Try(CopyCellsToClipboardHdr)
4674 	def CopyToClipboardCSV(self):  argument
4675 		self.Try(CopyCellsToClipboardCSV)
4677 	def Find(self):  argument
4678 		win = self.mdi_area.activeSubWindow()
4685 	def FetchMoreRecords(self):  argument
4686 		win = self.mdi_area.activeSubWindow()
4693 	def ShrinkFont(self):  argument
4694 		self.Try(ShrinkFont)
4696 	def EnlargeFont(self):  argument
4697 		self.Try(EnlargeFont)
4699 	def EventMenu(self, events, reports_menu):  argument
4711 …"Create a new window displaying branch events", lambda a=None,x=dbid: self.NewBranchView(x), self))
4713 …a new window displaying branch events", lambda a=None,x=dbid: self.NewSelectedBranchView(x), self))
4715 	def TimeChartByCPU(self):  argument
4716 		TimeChartByCPUWindow(self.glb, self)
4718 	def TableMenu(self, tables, menu):  argument
4721 … "Create a new window containing a table view", lambda a=None,t=table: self.NewTableView(t), self))
4723 	def NewCallGraph(self):  argument
4724 		CallGraphWindow(self.glb, self)
4726 	def NewCallTree(self):  argument
4727 		CallTreeWindow(self.glb, self)
4729 	def NewTopCalls(self):  argument
4730 		dialog = TopCallsDialog(self.glb, self)
4733 			TopCallsWindow(self.glb, dialog.report_vars, self)
4735 	def NewBranchView(self, event_id):  argument
4736 		BranchWindow(self.glb, event_id, ReportVars(), self)
4738 	def NewSelectedBranchView(self, event_id):  argument
4739 		dialog = SelectedBranchDialog(self.glb, self)
4742 			BranchWindow(self.glb, event_id, dialog.report_vars, self)
4744 	def NewTableView(self, table_name):  argument
4745 		TableWindow(self.glb, table_name, self)
4747 	def Help(self):  argument
4748 		HelpWindow(self.glb, self)
4750 	def About(self):  argument
4751 		dialog = AboutDialog(self.glb, self)
4784 	def __init__(self, dbref, db, dbname):  argument
4785 		self.dbref = dbref
4786 		self.db = db
4787 		self.dbname = dbname
4788 		self.home_dir = os.path.expanduser("~")
4789 		self.buildid_dir = os.getenv("PERF_BUILDID_DIR")
4790 		if self.buildid_dir:
4791 			self.buildid_dir += "/.build-id/"
4793 			self.buildid_dir = self.home_dir + "/.debug/.build-id/"
4794 		self.app = None
4795 		self.mainwindow = None
4796 		self.instances_to_shutdown_on_exit = weakref.WeakSet()
4798 			self.disassembler = LibXED()
4799 			self.have_disassembler = True
4801 			self.have_disassembler = False
4802 		self.host_machine_id = 0
4803 		self.host_start_time = 0
4804 		self.host_finish_time = 0
4806 	def FileFromBuildId(self, build_id):  argument
4807 		file_name = self.buildid_dir + build_id[0:2] + "/" + build_id[2:] + "/elf"
4810 	def FileFromNamesAndBuildId(self, short_name, long_name, build_id):  argument
4821 		f = self.FileFromBuildId(build_id)
4826 	def AddInstanceToShutdownOnExit(self, instance):  argument
4827 		self.instances_to_shutdown_on_exit.add(instance)
4830 	def ShutdownInstances(self):  argument
4831 		for x in self.instances_to_shutdown_on_exit:
4837 	def GetHostMachineId(self):  argument
4838 		query = QSqlQuery(self.db)
4841 			self.host_machine_id = query.value(0)
4843 			self.host_machine_id = 0
4844 		return self.host_machine_id
4846 	def HostMachineId(self):  argument
4847 		if self.host_machine_id:
4848 			return self.host_machine_id
4849 		return self.GetHostMachineId()
4851 	def SelectValue(self, sql):  argument
4852 		query = QSqlQuery(self.db)
4861 	def SwitchesMinTime(self, machine_id):  argument
4862 		return self.SelectValue("SELECT time"
4867 	def SwitchesMaxTime(self, machine_id):  argument
4868 		return self.SelectValue("SELECT time"
4873 	def SamplesMinTime(self, machine_id):  argument
4874 		return self.SelectValue("SELECT time"
4879 	def SamplesMaxTime(self, machine_id):  argument
4880 		return self.SelectValue("SELECT time"
4885 	def CallsMinTime(self, machine_id):  argument
4886 		return self.SelectValue("SELECT calls.call_time"
4892 	def CallsMaxTime(self, machine_id):  argument
4893 		return self.SelectValue("SELECT calls.return_time"
4899 	def GetStartTime(self, machine_id):  argument
4900 		t0 = self.SwitchesMinTime(machine_id)
4901 		t1 = self.SamplesMinTime(machine_id)
4902 		t2 = self.CallsMinTime(machine_id)
4909 	def GetFinishTime(self, machine_id):  argument
4910 		t0 = self.SwitchesMaxTime(machine_id)
4911 		t1 = self.SamplesMaxTime(machine_id)
4912 		t2 = self.CallsMaxTime(machine_id)
4919 	def HostStartTime(self):  argument
4920 		if self.host_start_time:
4921 			return self.host_start_time
4922 		self.host_start_time = self.GetStartTime(self.HostMachineId())
4923 		return self.host_start_time
4925 	def HostFinishTime(self):  argument
4926 		if self.host_finish_time:
4927 			return self.host_finish_time
4928 		self.host_finish_time = self.GetFinishTime(self.HostMachineId())
4929 		return self.host_finish_time
4931 	def StartTime(self, machine_id):  argument
4932 		if machine_id == self.HostMachineId():
4933 			return self.HostStartTime()
4934 		return self.GetStartTime(machine_id)
4936 	def FinishTime(self, machine_id):  argument
4937 		if machine_id == self.HostMachineId():
4938 			return self.HostFinishTime()
4939 		return self.GetFinishTime(machine_id)
4945 	def __init__(self, is_sqlite3, dbname):  argument
4946 		self.is_sqlite3 = is_sqlite3
4947 		self.dbname = dbname
4948 		self.TRUE = "TRUE"
4949 		self.FALSE = "FALSE"
4951 		if self.is_sqlite3:
4952 			self.TRUE = "1"
4953 			self.FALSE = "0"
4955 	def Open(self, connection_name):  argument
4956 		dbname = self.dbname
4957 		if self.is_sqlite3: