#!/usr/bin/env python
# SPDX-License-Identifier: GPL-2.0
"""exported-sql-viewer.py: view data from sql database."""
# Copyright (c) 2014-2018, Intel Corporation.

# To use this script you will need to have exported data using either the
# export-to-sqlite.py or the export-to-postgresql.py script.  Refer to those
# scripts for details.
#
# Following on from the example in the export scripts, a
# call-graph can be displayed for the pt_example database like this:
#
#	python exported-sql-viewer.py pt_example
#
# Note that for PostgreSQL, this script supports connecting to remote databases
# by setting hostname, port, username, password, and dbname e.g.
#
#	python exported-sql-viewer.py \
#		"hostname=myhost username=myuser password=mypassword dbname=pt_example"
#
# The result is a GUI window with a tree representing a context-sensitive
# call-graph.  Expanding a couple of levels of the tree and adjusting column
# widths to suit will display something like:
#
#                                         Call Graph: pt_example
# Call Path                          Object      Count   Time(ns)  Time(%)  Branch Count   Branch Count(%)
# v- ls
#     v- 2638:2638
#         v- _start                  ld-2.19.so    1     10074071   100.0         211135            100.0
#           |- unknown               unknown       1        13198     0.1              1              0.0
#           >- _dl_start             ld-2.19.so    1      1400980    13.9          19637              9.3
#           >- _d_linit_internal     ld-2.19.so    1       448152     4.4          11094              5.3
#           v-__libc_start_main@plt  ls            1      8211741    81.5         180397             85.4
#              >- _dl_fixup          ld-2.19.so    1         7607     0.1            108              0.1
#              >- __cxa_atexit       libc-2.19.so  1        11737     0.1             10              0.0
#              >- __libc_csu_init    ls            1        10354     0.1             10              0.0
#              |- _setjmp            libc-2.19.so  1            0     0.0              4              0.0
#              v- main               ls            1      8182043    99.6         180254             99.9
#
# Points to note:
#	The top level is a command name (comm)
#	The next level is a thread (pid:tid)
#	Subsequent levels are functions
#	'Count' is the number of calls
#	'Time' is the elapsed time until the function returns
#	Percentages are relative to the level above
#	'Branch Count' is the total number of branches for that function and all
#       functions that it calls

# There is also a "All branches" report, which displays branches and
# possibly disassembly.  However, presently, the only supported disassembler is
# Intel XED, and additionally the object code must be present in perf build ID
# cache. To use Intel XED, libxed.so must be present. To build and install
# libxed.so:
#            git clone https://github.com/intelxed/mbuild.git mbuild
#            git clone https://github.com/intelxed/xed
#            cd xed
#            ./mfile.py --share
#            sudo ./mfile.py --prefix=/usr/local install
#            sudo ldconfig
#
# Example report:
#
# Time           CPU  Command  PID    TID    Branch Type            In Tx  Branch
# 8107675239590  2    ls       22011  22011  return from interrupt  No     ffffffff86a00a67 native_irq_return_iret ([kernel]) -> 7fab593ea260 _start (ld-2.19.so)
#                                                                              7fab593ea260 48 89 e7                                        mov %rsp, %rdi
# 8107675239899  2    ls       22011  22011  hardware interrupt     No         7fab593ea260 _start (ld-2.19.so) -> ffffffff86a012e0 page_fault ([kernel])
# 8107675241900  2    ls       22011  22011  return from interrupt  No     ffffffff86a00a67 native_irq_return_iret ([kernel]) -> 7fab593ea260 _start (ld-2.19.so)
#                                                                              7fab593ea260 48 89 e7                                        mov %rsp, %rdi
#                                                                              7fab593ea263 e8 c8 06 00 00                                  callq  0x7fab593ea930
# 8107675241900  2    ls       22011  22011  call                   No         7fab593ea263 _start+0x3 (ld-2.19.so) -> 7fab593ea930 _dl_start (ld-2.19.so)
#                                                                              7fab593ea930 55                                              pushq  %rbp
#                                                                              7fab593ea931 48 89 e5                                        mov %rsp, %rbp
#                                                                              7fab593ea934 41 57                                           pushq  %r15
#                                                                              7fab593ea936 41 56                                           pushq  %r14
#                                                                              7fab593ea938 41 55                                           pushq  %r13
#                                                                              7fab593ea93a 41 54                                           pushq  %r12
#                                                                              7fab593ea93c 53                                              pushq  %rbx
#                                                                              7fab593ea93d 48 89 fb                                        mov %rdi, %rbx
#                                                                              7fab593ea940 48 83 ec 68                                     sub $0x68, %rsp
#                                                                              7fab593ea944 0f 31                                           rdtsc
#                                                                              7fab593ea946 48 c1 e2 20                                     shl $0x20, %rdx
#                                                                              7fab593ea94a 89 c0                                           mov %eax, %eax
#                                                                              7fab593ea94c 48 09 c2                                        or %rax, %rdx
#                                                                              7fab593ea94f 48 8b 05 1a 15 22 00                            movq  0x22151a(%rip), %rax
# 8107675242232  2    ls       22011  22011  hardware interrupt     No         7fab593ea94f _dl_start+0x1f (ld-2.19.so) -> ffffffff86a012e0 page_fault ([kernel])
# 8107675242900  2    ls       22011  22011  return from interrupt  No     ffffffff86a00a67 native_irq_return_iret ([kernel]) -> 7fab593ea94f _dl_start+0x1f (ld-2.19.so)
#                                                                              7fab593ea94f 48 8b 05 1a 15 22 00                            movq  0x22151a(%rip), %rax
#                                                                              7fab593ea956 48 89 15 3b 13 22 00                            movq  %rdx, 0x22133b(%rip)
# 8107675243232  2    ls       22011  22011  hardware interrupt     No         7fab593ea956 _dl_start+0x26 (ld-2.19.so) -> ffffffff86a012e0 page_fault ([kernel])

from __future__ import print_function

import sys
# Only change warnings if the python -W option was not used
if not sys.warnoptions:
    import warnings
    # PySide2 causes deprecation warnings, ignore them.
    warnings.filterwarnings("ignore", category=DeprecationWarning)
import argparse
import weakref
import threading
import pickle
glb_nsz = 16
import re
import os
import random
import copy
import math
from libxed import LibXED

import importlib
from typing import Any

class _QtBase:
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        pass
    def __call__(self, *args: Any, **kwargs: Any) -> Any:
        return self
    def __getattr__(self, name: str) -> Any:
        return _QtBase()
    def mousePressEvent(self, event: Any) -> None:
        pass
    def mouseMoveEvent(self, event: Any) -> None:
        pass
    def mouseReleaseEvent(self, event: Any) -> None:
        pass
    def resizeEvent(self, event: Any) -> None:
        pass
    def changeEvent(self, event: Any) -> None:
        pass

class _QtWidget(_QtBase):
    pass

class _QtMdiSubWindow(_QtWidget):
    pass

QAbstractItemModel: Any = _QtBase
QAbstractItemView: Any = _QtBase
QAbstractTableModel: Any = _QtBase
QAction: Any = _QtBase
QApplication: Any = _QtBase
QCheckBox: Any = _QtBase
QColor: Any = _QtBase
QComboBox: Any = _QtBase
QDialog: Any = _QtWidget
QEvent: Any = _QtBase
QFont: Any = _QtBase
QFontMetrics: Any = _QtBase
QGraphicsItem: Any = _QtBase
QGraphicsLineItem: Any = _QtBase
QGraphicsScene: Any = _QtBase
QGraphicsSimpleTextItem: Any = _QtBase
QGraphicsView: Any = _QtBase
QGridLayout: Any = _QtBase
QHBoxLayout: Any = _QtBase
QKeySequence: Any = _QtBase
QLabel: Any = _QtBase
QLineEdit: Any = _QtBase
QMainWindow: Any = _QtWidget
QMdiArea: Any = _QtBase
QMdiSubWindow: Any = _QtMdiSubWindow
QMenu: Any = _QtBase
QMessageBox: Any = _QtBase
QModelIndex: Any = _QtBase
QObject: Any = _QtBase
QPalette: Any = _QtBase
QPoint: Any = _QtBase
QPointF: Any = _QtBase
QProgressBar: Any = _QtBase
QPushButton: Any = _QtBase
QRect: Any = _QtBase
QRectF: Any = _QtBase
QRubberBand: Any = _QtBase
QSize: Any = _QtBase
QSizePolicy: Any = _QtBase
QSortFilterProxyModel: Any = _QtBase
QSpinBox: Any = _QtBase
QSplitter: Any = _QtWidget
QSqlDatabase: Any = _QtBase
QSqlQuery: Any = _QtBase
QStyle: Any = _QtBase
Qt: Any = _QtBase
QTableView: Any = _QtWidget
QTextBrowser: Any = _QtWidget
QThread: Any = _QtBase
QToolButton: Any = _QtBase
QTreeView: Any = _QtWidget
QVBoxLayout: Any = _QtBase
qVersion: Any = _QtBase
QWidget: Any = _QtWidget
Signal: Any = _QtBase

pyside_version_1 = False
for _pkg in ("PySide6", "PySide2"):
    try:
        for _mod_name in ("QtCore", "QtGui", "QtSql", "QtWidgets"):
            _mod = importlib.import_module(f"{_pkg}.{_mod_name}")
            for _sym in dir(_mod):
                if not _sym.startswith("_"):
                    globals()[_sym] = getattr(_mod, _sym)
        break
    except ImportError:
        pass


from decimal import Decimal, ROUND_HALF_UP
from ctypes import create_string_buffer, addressof, sizeof, \
           c_void_p, c_bool, c_char, c_longlong
from multiprocessing import Process, Array, Value, Event


def printerr(*args, **keyword_args):
    print(*args, file=sys.stderr, **keyword_args)

# Data formatting helpers

def tohex(ip):
    if ip < 0:
        ip += 1 << 64
    return "%x" % ip

def offstr(offset):
    if offset:
        return "+0x%x" % offset
    return ""

def dsoname(name):
    if name == "[kernel.kallsyms]":
        return "[kernel]"
    return name

def findnth(s, sub, n, offs=0):
    pos = s.find(sub)
    if pos < 0:
        return pos
    if n <= 1:
        return offs + pos
    return findnth(s[pos + 1:], sub, n - 1, offs + pos + 1)

# Percent to one decimal place

def PercentToOneDP(n, d):
    if not d:
        return "0.0"
    x = (n * Decimal(100)) / d
    return str(x.quantize(Decimal(".1"), rounding=ROUND_HALF_UP))

# Helper for queries that must not fail

def QueryExec(query, stmt):
    ret = query.exec_(stmt)
    if not ret:
        raise RuntimeError("Query failed: " + query.lastError().text())

# Background thread

class Thread(QThread):

    done = Signal(object)

    def __init__(self, task, param=None, parent=None):
        super(Thread, self).__init__(parent)
        self.task = task
        self.param = param

    def run(self):
        while True:
            if self.param is None:
                done, result = self.task()
            else:
                done, result = self.task(self.param)
            self.done.emit(result)
            if done:
                break

# Tree data model

class TreeModel(QAbstractItemModel):

    def __init__(self, glb, params, parent=None):
        super(TreeModel, self).__init__(parent)
        self.glb = glb
        self.params = params
        self.root = self.GetRoot()
        self.last_row_read = 0

    def Item(self, parent):
        if parent.isValid():
            return parent.internalPointer()
        else:
            return self.root

    def rowCount(self, parent):
        result = self.Item(parent).childCount()
        if result < 0:
            result = 0
            self.dataChanged.emit(parent, parent)
        return result

    def hasChildren(self, parent):
        return self.Item(parent).hasChildren()

    def headerData(self, section, orientation, role):
        if role == Qt.TextAlignmentRole:
            return self.columnAlignment(section)
        if role != Qt.DisplayRole:
            return None
        if orientation != Qt.Horizontal:
            return None
        return self.columnHeader(section)

    def parent(self, child):
        child_item = child.internalPointer()
        if child_item is self.root:
            return QModelIndex()
        parent_item = child_item.getParentItem()
        return self.createIndex(parent_item.getRow(), 0, parent_item)

    def index(self, row, column, parent):
        child_item = self.Item(parent).getChildItem(row)
        return self.createIndex(row, column, child_item)

    def DisplayData(self, item, index):
        return item.getData(index.column())

    def FetchIfNeeded(self, row):
        if row > self.last_row_read:
            self.last_row_read = row
            if row + 10 >= self.root.child_count:
                self.fetcher.Fetch(glb_chunk_sz)

    def columnAlignment(self, _column):
        return Qt.AlignLeft

    def columnFont(self, _column):
        return None

    def data(self, index, role):
        if role == Qt.TextAlignmentRole:
            return self.columnAlignment(index.column())
        if role == Qt.FontRole:
            return self.columnFont(index.column())
        if role != Qt.DisplayRole:
            return None
        item = index.internalPointer()
        return self.DisplayData(item, index)

# Table data model

class TableModel(QAbstractTableModel):

    def __init__(self, parent=None):
        super(TableModel, self).__init__(parent)
        self.child_count = 0
        self.child_items = []
        self.last_row_read = 0

    def Item(self, parent):
        if parent.isValid():
            return parent.internalPointer()
        else:
            return self

    def rowCount(self, _parent):
        return self.child_count

    def headerData(self, section, orientation, role):
        if role == Qt.TextAlignmentRole:
            return self.columnAlignment(section)
        if role != Qt.DisplayRole:
            return None
        if orientation != Qt.Horizontal:
            return None
        return self.columnHeader(section)

    def index(self, row, column, _parent):
        return self.createIndex(row, column, self.child_items[row])

    def DisplayData(self, item, index):
        return item.getData(index.column())

    def FetchIfNeeded(self, row):
        if row > self.last_row_read:
            self.last_row_read = row
            if row + 10 >= self.child_count:
                self.fetcher.Fetch(glb_chunk_sz)

    def columnAlignment(self, _column):
        return Qt.AlignLeft

    def columnFont(self, _column):
        return None

    def data(self, index, role):
        if role == Qt.TextAlignmentRole:
            return self.columnAlignment(index.column())
        if role == Qt.FontRole:
            return self.columnFont(index.column())
        if role != Qt.DisplayRole:
            return None
        item = index.internalPointer()
        return self.DisplayData(item, index)

# Model cache

model_cache: Any = weakref.WeakValueDictionary()
model_cache_lock = threading.Lock()

def LookupCreateModel(model_name, create_fn):
    model_cache_lock.acquire()
    try:
        model = model_cache[model_name]
    except KeyError:
        model = None
    if model is None:
        model = create_fn()
        model_cache[model_name] = model
    model_cache_lock.release()
    return model

def LookupModel(model_name):
    model_cache_lock.acquire()
    try:
        model = model_cache[model_name]
    except KeyError:
        model = None
    model_cache_lock.release()
    return model

# Find bar

class FindBar():

    def __init__(self, parent, finder, is_reg_expr=False):
        self.finder = finder
        self.context = []
        self.last_value = None
        self.last_pattern = None

        label = QLabel("Find:")
        label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)

        self.textbox = QComboBox()
        self.textbox.setEditable(True)
        self.textbox.currentIndexChanged.connect(self.ValueChanged)

        self.progress = QProgressBar()
        self.progress.setRange(0, 0)
        self.progress.hide()

        if is_reg_expr:
            self.pattern = QCheckBox("Regular Expression")
        else:
            self.pattern = QCheckBox("Pattern")
        self.pattern.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)

        self.next_button = QToolButton()
        self.next_button.setIcon(parent.style().standardIcon(QStyle.SP_ArrowDown))
        self.next_button.released.connect(lambda: self.NextPrev(1))

        self.prev_button = QToolButton()
        self.prev_button.setIcon(parent.style().standardIcon(QStyle.SP_ArrowUp))
        self.prev_button.released.connect(lambda: self.NextPrev(-1))

        self.close_button = QToolButton()
        self.close_button.setIcon(parent.style().standardIcon(QStyle.SP_DockWidgetCloseButton))
        self.close_button.released.connect(self.Deactivate)

        self.hbox = QHBoxLayout()
        self.hbox.setContentsMargins(0, 0, 0, 0)

        self.hbox.addWidget(label)
        self.hbox.addWidget(self.textbox)
        self.hbox.addWidget(self.progress)
        self.hbox.addWidget(self.pattern)
        self.hbox.addWidget(self.next_button)
        self.hbox.addWidget(self.prev_button)
        self.hbox.addWidget(self.close_button)

        self.bar = QWidget()
        self.bar.setLayout(self.hbox)
        self.bar.hide()

    def Widget(self):
        return self.bar

    def Activate(self):
        self.bar.show()
        self.textbox.lineEdit().selectAll()
        self.textbox.setFocus()

    def Deactivate(self):
        self.bar.hide()

    def Busy(self):
        self.textbox.setEnabled(False)
        self.pattern.hide()
        self.next_button.hide()
        self.prev_button.hide()
        self.progress.show()

    def Idle(self):
        self.textbox.setEnabled(True)
        self.progress.hide()
        self.pattern.show()
        self.next_button.show()
        self.prev_button.show()

    def Find(self, direction):
        value = self.textbox.currentText()
        pattern = self.pattern.isChecked()
        self.last_value = value
        self.last_pattern = pattern
        self.finder.Find(value, direction, pattern, self.context)

    def ValueChanged(self):
        _value = self.textbox.currentText()
        pattern = self.pattern.isChecked()
        index = self.textbox.currentIndex()
        data = self.textbox.itemData(index)
        # Store the pattern in the combo box to keep it with the text value
        if data == None:
            self.textbox.setItemData(index, pattern)
        else:
            self.pattern.setChecked(data)
        self.Find(0)

    def NextPrev(self, direction):
        value = self.textbox.currentText()
        pattern = self.pattern.isChecked()
        if value != self.last_value:
            index = self.textbox.findText(value)
            # Allow for a button press before the value has been added to the combo box
            if index < 0:
                index = self.textbox.count()
                self.textbox.addItem(value, pattern)
                self.textbox.setCurrentIndex(index)
                return
            else:
                self.textbox.setItemData(index, pattern)
        elif pattern != self.last_pattern:
            # Keep the pattern recorded in the combo box up to date
            index = self.textbox.currentIndex()
            self.textbox.setItemData(index, pattern)
        self.Find(direction)

    def NotFound(self):
        QMessageBox.information(self.bar, "Find", "'" + self.textbox.currentText() + "' not found")

# Context-sensitive call graph data model item base

class CallGraphLevelItemBase(object):
    def Select(self) -> None:
        pass
    def data(self, _column: int, _role: int) -> Any:
        return None

    def __init__(self, glb, params, row, parent_item):
        self.glb = glb
        self.params = params
        self.row = row
        self.parent_item = parent_item
        self.query_done = False
        self.child_count = 0
        self.child_items = []
        if parent_item:
            self.level = parent_item.level + 1
        else:
            self.level = 0

    def getChildItem(self, row):
        return self.child_items[row]

    def getParentItem(self):
        return self.parent_item

    def getRow(self):
        return self.row

    def childCount(self):
        if not self.query_done:
            self.Select()
            if not self.child_count:
                return -1
        return self.child_count

    def hasChildren(self):
        if not self.query_done:
            return True
        return self.child_count > 0

    def getData(self, column):
        return self.data[column]

# Context-sensitive call graph data model level 2+ item base

class CallGraphLevelTwoPlusItemBase(CallGraphLevelItemBase):

    def __init__(self, glb, params, row, comm_id, thread_id, call_path_id, time, insn_cnt, cyc_cnt, branch_count, parent_item):
        super(CallGraphLevelTwoPlusItemBase, self).__init__(glb, params, row, parent_item)
        self.comm_id = comm_id
        self.thread_id = thread_id
        self.call_path_id = call_path_id
        self.insn_cnt = insn_cnt
        self.cyc_cnt = cyc_cnt
        self.branch_count = branch_count
        self.time = time

    def Select(self):
        self.query_done = True
        query = QSqlQuery(self.glb.db)
        if self.params.have_ipc:
            ipc_str = ", SUM(insn_count), SUM(cyc_count)"
        else:
            ipc_str = ""
        QueryExec(query, "SELECT call_path_id, name, short_name, COUNT(calls.id), SUM(return_time - call_time)" + ipc_str + ", SUM(branch_count)"
                    " FROM calls"
                    " INNER JOIN call_paths ON calls.call_path_id = call_paths.id"
                    " INNER JOIN symbols ON call_paths.symbol_id = symbols.id"
                    " INNER JOIN dsos ON symbols.dso_id = dsos.id"
                    " WHERE parent_call_path_id = " + str(self.call_path_id) +
                    " AND comm_id = " + str(self.comm_id) +
                    " AND thread_id = " + str(self.thread_id) +
                    " GROUP BY call_path_id, name, short_name"
                    " ORDER BY call_path_id")
        while query.next():
            if self.params.have_ipc:
                insn_cnt = int(query.value(5))
                cyc_cnt = int(query.value(6))
                branch_count = int(query.value(7))
            else:
                insn_cnt = 0
                cyc_cnt = 0
                branch_count = int(query.value(5))
            child_item = CallGraphLevelThreeItem(self.glb, self.params, self.child_count, self.comm_id, self.thread_id, query.value(0), query.value(1), query.value(2), query.value(3), int(query.value(4)), insn_cnt, cyc_cnt, branch_count, self)
            self.child_items.append(child_item)
            self.child_count += 1

# Context-sensitive call graph data model level three item

class CallGraphLevelThreeItem(CallGraphLevelTwoPlusItemBase):

    def __init__(self, glb, params, row, comm_id, thread_id, call_path_id, name, dso, count, time, insn_cnt, cyc_cnt, branch_count, parent_item):
        super(CallGraphLevelThreeItem, self).__init__(glb, params, row, comm_id, thread_id, call_path_id, time, insn_cnt, cyc_cnt, branch_count, parent_item)
        dso = dsoname(dso)
        if self.params.have_ipc:
            insn_pcnt = PercentToOneDP(insn_cnt, parent_item.insn_cnt)
            cyc_pcnt = PercentToOneDP(cyc_cnt, parent_item.cyc_cnt)
            br_pcnt = PercentToOneDP(branch_count, parent_item.branch_count)
            ipc = CalcIPC(cyc_cnt, insn_cnt)
            self.data = [ name, dso, str(count), str(time), PercentToOneDP(time, parent_item.time), str(insn_cnt), insn_pcnt, str(cyc_cnt), cyc_pcnt, ipc, str(branch_count), br_pcnt ]
        else:
            self.data = [ name, dso, str(count), str(time), PercentToOneDP(time, parent_item.time), str(branch_count), PercentToOneDP(branch_count, parent_item.branch_count) ]
        self.dbid = call_path_id

# Context-sensitive call graph data model level two item

class CallGraphLevelTwoItem(CallGraphLevelTwoPlusItemBase):

    def __init__(self, glb, params, row, comm_id, thread_id, pid, tid, parent_item):
        super(CallGraphLevelTwoItem, self).__init__(glb, params, row, comm_id, thread_id, 1, 0, 0, 0, 0, parent_item)
        if self.params.have_ipc:
            self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", "", "", "", "", "", ""]
        else:
            self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", ""]
        self.dbid = thread_id

    def Select(self):
        super(CallGraphLevelTwoItem, self).Select()
        for child_item in self.child_items:
            self.time += child_item.time
            self.insn_cnt += child_item.insn_cnt
            self.cyc_cnt += child_item.cyc_cnt
            self.branch_count += child_item.branch_count
        for child_item in self.child_items:
            child_item.data[4] = PercentToOneDP(child_item.time, self.time)
            if self.params.have_ipc:
                child_item.data[6] = PercentToOneDP(child_item.insn_cnt, self.insn_cnt)
                child_item.data[8] = PercentToOneDP(child_item.cyc_cnt, self.cyc_cnt)
                child_item.data[11] = PercentToOneDP(child_item.branch_count, self.branch_count)
            else:
                child_item.data[6] = PercentToOneDP(child_item.branch_count, self.branch_count)

# Context-sensitive call graph data model level one item

class CallGraphLevelOneItem(CallGraphLevelItemBase):

    def __init__(self, glb, params, row, comm_id, comm, parent_item):
        super(CallGraphLevelOneItem, self).__init__(glb, params, row, parent_item)
        if self.params.have_ipc:
            self.data = [comm, "", "", "", "", "", "", "", "", "", "", ""]
        else:
            self.data = [comm, "", "", "", "", "", ""]
        self.dbid = comm_id

    def Select(self):
        self.query_done = True
        query = QSqlQuery(self.glb.db)
        QueryExec(query, "SELECT thread_id, pid, tid"
                    " FROM comm_threads"
                    " INNER JOIN threads ON thread_id = threads.id"
                    " WHERE comm_id = " + str(self.dbid))
        while query.next():
            child_item = CallGraphLevelTwoItem(self.glb, self.params, self.child_count, self.dbid, query.value(0), query.value(1), query.value(2), self)
            self.child_items.append(child_item)
            self.child_count += 1

# Context-sensitive call graph data model root item

class CallGraphRootItem(CallGraphLevelItemBase):

    def __init__(self, glb, params):
        super(CallGraphRootItem, self).__init__(glb, params, 0, None)
        self.dbid = 0
        self.query_done = True
        if_has_calls = ""
        if IsSelectable(glb.db, "comms", columns = "has_calls"):
            if_has_calls = " WHERE has_calls = " + glb.dbref.TRUE
        query = QSqlQuery(glb.db)
        QueryExec(query, "SELECT id, comm FROM comms" + if_has_calls)
        while query.next():
            if not query.value(0):
                continue
            child_item = CallGraphLevelOneItem(glb, params, self.child_count, query.value(0), query.value(1), self)
            self.child_items.append(child_item)
            self.child_count += 1

# Call graph model parameters

class CallGraphModelParams():

    def __init__(self, glb, _parent=None):
        self.have_ipc = IsSelectable(glb.db, "calls", columns = "insn_count, cyc_count")

# Context-sensitive call graph data model base

class CallGraphModelBase(TreeModel):

    def __init__(self, glb, parent=None):
        super(CallGraphModelBase, self).__init__(glb, CallGraphModelParams(glb), parent)

    def FindSelect(self, value, pattern, query):
        if pattern:
            # postgresql and sqlite pattern patching differences:
            #   postgresql LIKE is case sensitive but sqlite LIKE is not
            #   postgresql LIKE allows % and _ to be escaped with \ but sqlite LIKE does not
            #   postgresql supports ILIKE which is case insensitive
            #   sqlite supports GLOB (text only) which uses * and ? and is case sensitive
            if not self.glb.dbref.is_sqlite3:
                # Escape % and _
                s = value.replace("%", "\\%")
                s = s.replace("_", "\\_")
                # Translate * and ? into SQL LIKE pattern characters % and _
                if sys.version_info[0] == 3:
                    trans = str.maketrans("*?", "%_")
                else:
                    trans = bytes.maketrans("*?", "%_")
                match = " LIKE '" + str(s).translate(trans) + "'"
            else:
                match = " GLOB '" + str(value) + "'"
        else:
            match = " = '" + str(value) + "'"
        self.DoFindSelect(query, match)

    def Found(self, query, found):
        if found:
            return self.FindPath(query)
        return []

    def FindValue(self, value, pattern, query, last_value, last_pattern):
        if last_value == value and pattern == last_pattern:
            found = query.first()
        else:
            self.FindSelect(value, pattern, query)
            found = query.next()
        return self.Found(query, found)

    def FindNext(self, query):
        found = query.next()
        if not found:
            found = query.first()
        return self.Found(query, found)

    def FindPrev(self, query):
        found = query.previous()
        if not found:
            found = query.last()
        return self.Found(query, found)

    def FindThread(self, c):
        if c.direction == 0 or c.value != c.last_value or c.pattern != c.last_pattern:
            ids = self.FindValue(c.value, c.pattern, c.query, c.last_value, c.last_pattern)
        elif c.direction > 0:
            ids = self.FindNext(c.query)
        else:
            ids = self.FindPrev(c.query)
        return (True, ids)

    def Find(self, value, direction, pattern, context, callback):
        class Context():
            def __init__(self, *x):
                self.value, self.direction, self.pattern, self.query, self.last_value, self.last_pattern = x
            def Update(self, *x):
                self.value, self.direction, self.pattern, self.last_value, self.last_pattern = x + (self.value, self.pattern)
        if len(context):
            context[0].Update(value, direction, pattern)
        else:
            context.append(Context(value, direction, pattern, QSqlQuery(self.glb.db), None, None))
        # Use a thread so the UI is not blocked during the SELECT
        thread = Thread(self.FindThread, context[0])
        thread.done.connect(lambda ids, t=thread, c=callback: self.FindDone(t, c, ids), Qt.QueuedConnection)
        thread.start()

    def FindDone(self, _thread, callback, ids):
        callback(ids)

# Context-sensitive call graph data model

class CallGraphModel(CallGraphModelBase):

    def GetRoot(self):
        return CallGraphRootItem(self.glb, self.params)

    def columnCount(self, _parent=None):
        if self.params.have_ipc:
            return 12
        else:
            return 7

    def columnHeader(self, column):
        if self.params.have_ipc:
            headers = ["Call Path", "Object", "Count ", "Time (ns) ", "Time (%) ", "Insn Cnt", "Insn Cnt (%)", "Cyc Cnt", "Cyc Cnt (%)", "IPC", "Branch Count ", "Branch Count (%) "]
        else:
            headers = ["Call Path", "Object", "Count ", "Time (ns) ", "Time (%) ", "Branch Count ", "Branch Count (%) "]
        return headers[column]

    def columnAlignment(self, column):
        if self.params.have_ipc:
            alignment = [ Qt.AlignLeft, Qt.AlignLeft, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight ]
        else:
            alignment = [ Qt.AlignLeft, Qt.AlignLeft, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight ]
        return alignment[column]

    def DoFindSelect(self, query, match):
        QueryExec(query, "SELECT call_path_id, comm_id, thread_id"
                        " FROM calls"
                        " INNER JOIN call_paths ON calls.call_path_id = call_paths.id"
                        " INNER JOIN symbols ON call_paths.symbol_id = symbols.id"
                        " WHERE calls.id <> 0"
                        " AND symbols.name" + match +
                        " GROUP BY comm_id, thread_id, call_path_id"
                        " ORDER BY comm_id, thread_id, call_path_id")

    def FindPath(self, query):
        # Turn the query result into a list of ids that the tree view can walk
        # to open the tree at the right place.
        ids = []
        parent_id = query.value(0)
        while parent_id:
            ids.insert(0, parent_id)
            q2 = QSqlQuery(self.glb.db)
            QueryExec(q2, "SELECT parent_id"
                    " FROM call_paths"
                    " WHERE id = " + str(parent_id))
            if not q2.next():
                break
            parent_id = q2.value(0)
        # The call path root is not used
        if ids[0] == 1:
            del ids[0]
        ids.insert(0, query.value(2))
        ids.insert(0, query.value(1))
        return ids

# Call tree data model level 2+ item base

class CallTreeLevelTwoPlusItemBase(CallGraphLevelItemBase):

    def __init__(self, glb, params, row, comm_id, thread_id, calls_id, call_time, time, insn_cnt, cyc_cnt, branch_count, parent_item):
        super(CallTreeLevelTwoPlusItemBase, self).__init__(glb, params, row, parent_item)
        self.comm_id = comm_id
        self.thread_id = thread_id
        self.calls_id = calls_id
        self.call_time = call_time
        self.time = time
        self.insn_cnt = insn_cnt
        self.cyc_cnt = cyc_cnt
        self.branch_count = branch_count

    def Select(self):
        self.query_done = True
        if self.calls_id == 0:
            comm_thread = " AND comm_id = " + str(self.comm_id) + " AND thread_id = " + str(self.thread_id)
        else:
            comm_thread = ""
        if self.params.have_ipc:
            ipc_str = ", insn_count, cyc_count"
        else:
            ipc_str = ""
        query = QSqlQuery(self.glb.db)
        QueryExec(query, "SELECT calls.id, name, short_name, call_time, return_time - call_time" + ipc_str + ", branch_count"
                    " FROM calls"
                    " INNER JOIN call_paths ON calls.call_path_id = call_paths.id"
                    " INNER JOIN symbols ON call_paths.symbol_id = symbols.id"
                    " INNER JOIN dsos ON symbols.dso_id = dsos.id"
                    " WHERE calls.parent_id = " + str(self.calls_id) + comm_thread +
                    " ORDER BY call_time, calls.id")
        while query.next():
            if self.params.have_ipc:
                insn_cnt = int(query.value(5))
                cyc_cnt = int(query.value(6))
                branch_count = int(query.value(7))
            else:
                insn_cnt = 0
                cyc_cnt = 0
                branch_count = int(query.value(5))
            child_item = CallTreeLevelThreeItem(self.glb, self.params, self.child_count, self.comm_id, self.thread_id, query.value(0), query.value(1), query.value(2), query.value(3), int(query.value(4)), insn_cnt, cyc_cnt, branch_count, self)
            self.child_items.append(child_item)
            self.child_count += 1

# Call tree data model level three item

class CallTreeLevelThreeItem(CallTreeLevelTwoPlusItemBase):

    def __init__(self, glb, params, row, comm_id, thread_id, calls_id, name, dso, call_time, time, insn_cnt, cyc_cnt, branch_count, parent_item):
        super(CallTreeLevelThreeItem, self).__init__(glb, params, row, comm_id, thread_id, calls_id, call_time, time, insn_cnt, cyc_cnt, branch_count, parent_item)
        dso = dsoname(dso)
        if self.params.have_ipc:
            insn_pcnt = PercentToOneDP(insn_cnt, parent_item.insn_cnt)
            cyc_pcnt = PercentToOneDP(cyc_cnt, parent_item.cyc_cnt)
            br_pcnt = PercentToOneDP(branch_count, parent_item.branch_count)
            ipc = CalcIPC(cyc_cnt, insn_cnt)
            self.data = [ name, dso, str(call_time), str(time), PercentToOneDP(time, parent_item.time), str(insn_cnt), insn_pcnt, str(cyc_cnt), cyc_pcnt, ipc, str(branch_count), br_pcnt ]
        else:
            self.data = [ name, dso, str(call_time), str(time), PercentToOneDP(time, parent_item.time), str(branch_count), PercentToOneDP(branch_count, parent_item.branch_count) ]
        self.dbid = calls_id

# Call tree data model level two item

class CallTreeLevelTwoItem(CallTreeLevelTwoPlusItemBase):

    def __init__(self, glb, params, row, comm_id, thread_id, pid, tid, parent_item):
        super(CallTreeLevelTwoItem, self).__init__(glb, params, row, comm_id, thread_id, 0, 0, 0, 0, 0, 0, parent_item)
        if self.params.have_ipc:
            self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", "", "", "", "", "", ""]
        else:
            self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", ""]
        self.dbid = thread_id

    def Select(self):
        super(CallTreeLevelTwoItem, self).Select()
        for child_item in self.child_items:
            self.time += child_item.time
            self.insn_cnt += child_item.insn_cnt
            self.cyc_cnt += child_item.cyc_cnt
            self.branch_count += child_item.branch_count
        for child_item in self.child_items:
            child_item.data[4] = PercentToOneDP(child_item.time, self.time)
            if self.params.have_ipc:
                child_item.data[6] = PercentToOneDP(child_item.insn_cnt, self.insn_cnt)
                child_item.data[8] = PercentToOneDP(child_item.cyc_cnt, self.cyc_cnt)
                child_item.data[11] = PercentToOneDP(child_item.branch_count, self.branch_count)
            else:
                child_item.data[6] = PercentToOneDP(child_item.branch_count, self.branch_count)

# Call tree data model level one item

class CallTreeLevelOneItem(CallGraphLevelItemBase):

    def __init__(self, glb, params, row, comm_id, comm, parent_item):
        super(CallTreeLevelOneItem, self).__init__(glb, params, row, parent_item)
        if self.params.have_ipc:
            self.data = [comm, "", "", "", "", "", "", "", "", "", "", ""]
        else:
            self.data = [comm, "", "", "", "", "", ""]
        self.dbid = comm_id

    def Select(self):
        self.query_done = True
        query = QSqlQuery(self.glb.db)
        QueryExec(query, "SELECT thread_id, pid, tid"
                    " FROM comm_threads"
                    " INNER JOIN threads ON thread_id = threads.id"
                    " WHERE comm_id = " + str(self.dbid))
        while query.next():
            child_item = CallTreeLevelTwoItem(self.glb, self.params, self.child_count, self.dbid, query.value(0), query.value(1), query.value(2), self)
            self.child_items.append(child_item)
            self.child_count += 1

# Call tree data model root item

class CallTreeRootItem(CallGraphLevelItemBase):

    def __init__(self, glb, params):
        super(CallTreeRootItem, self).__init__(glb, params, 0, None)
        self.dbid = 0
        self.query_done = True
        if_has_calls = ""
        if IsSelectable(glb.db, "comms", columns = "has_calls"):
            if_has_calls = " WHERE has_calls = " + glb.dbref.TRUE
        query = QSqlQuery(glb.db)
        QueryExec(query, "SELECT id, comm FROM comms" + if_has_calls)
        while query.next():
            if not query.value(0):
                continue
            child_item = CallTreeLevelOneItem(glb, params, self.child_count, query.value(0), query.value(1), self)
            self.child_items.append(child_item)
            self.child_count += 1

# Call Tree data model

class CallTreeModel(CallGraphModelBase):

    def GetRoot(self):
        return CallTreeRootItem(self.glb, self.params)

    def columnCount(self, _parent=None):
        if self.params.have_ipc:
            return 12
        else:
            return 7

    def columnHeader(self, column):
        if self.params.have_ipc:
            headers = ["Call Path", "Object", "Call Time", "Time (ns) ", "Time (%) ", "Insn Cnt", "Insn Cnt (%)", "Cyc Cnt", "Cyc Cnt (%)", "IPC", "Branch Count ", "Branch Count (%) "]
        else:
            headers = ["Call Path", "Object", "Call Time", "Time (ns) ", "Time (%) ", "Branch Count ", "Branch Count (%) "]
        return headers[column]

    def columnAlignment(self, column):
        if self.params.have_ipc:
            alignment = [ Qt.AlignLeft, Qt.AlignLeft, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight ]
        else:
            alignment = [ Qt.AlignLeft, Qt.AlignLeft, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight ]
        return alignment[column]

    def DoFindSelect(self, query, match):
        QueryExec(query, "SELECT calls.id, comm_id, thread_id"
                        " FROM calls"
                        " INNER JOIN call_paths ON calls.call_path_id = call_paths.id"
                        " INNER JOIN symbols ON call_paths.symbol_id = symbols.id"
                        " WHERE calls.id <> 0"
                        " AND symbols.name" + match +
                        " ORDER BY comm_id, thread_id, call_time, calls.id")

    def FindPath(self, query):
        # Turn the query result into a list of ids that the tree view can walk
        # to open the tree at the right place.
        ids = []
        parent_id = query.value(0)
        while parent_id:
            ids.insert(0, parent_id)
            q2 = QSqlQuery(self.glb.db)
            QueryExec(q2, "SELECT parent_id"
                    " FROM calls"
                    " WHERE id = " + str(parent_id))
            if not q2.next():
                break
            parent_id = q2.value(0)
        ids.insert(0, query.value(2))
        ids.insert(0, query.value(1))
        return ids

# Vertical layout

class HBoxLayout(QHBoxLayout):

    def __init__(self, *children):
        super(HBoxLayout, self).__init__()

        self.layout().setContentsMargins(0, 0, 0, 0)
        for child in children:
            if child.isWidgetType():
                self.layout().addWidget(child)
            else:
                self.layout().addLayout(child)

# Horizontal layout

class VBoxLayout(QVBoxLayout):

    def __init__(self, *children):
        super(VBoxLayout, self).__init__()

        self.layout().setContentsMargins(0, 0, 0, 0)
        for child in children:
            if child.isWidgetType():
                self.layout().addWidget(child)
            else:
                self.layout().addLayout(child)

# Vertical layout widget

class VBox():

    def __init__(self, *children):
        self.vbox = QWidget()
        self.vbox.setLayout(VBoxLayout(*children))

    def Widget(self):
        return self.vbox

# Tree window base

class TreeWindowBase(QMdiSubWindow):

    def __init__(self, parent=None):
        super(TreeWindowBase, self).__init__(parent)

        self.model = None
        self.find_bar = None

        self.view = QTreeView()
        self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
        self.view.CopyCellsToClipboard = CopyTreeCellsToClipboard

        self.context_menu = TreeContextMenu(self.view)

    def DisplayFound(self, ids):
        if not len(ids):
            return False
        parent = QModelIndex()
        for dbid in ids:
            found = False
            n = self.model.rowCount(parent)
            for row in range(n):
                child = self.model.index(row, 0, parent)
                if child.internalPointer().dbid == dbid:
                    found = True
                    self.view.setExpanded(parent, True)
                    self.view.setCurrentIndex(child)
                    parent = child
                    break
            if not found:
                break
        return found

    def Find(self, value, direction, pattern, context):
        self.view.setFocus()
        self.find_bar.Busy()
        self.model.Find(value, direction, pattern, context, self.FindDone)

    def FindDone(self, ids):
        found = True
        if not self.DisplayFound(ids):
            found = False
        self.find_bar.Idle()
        if not found:
            self.find_bar.NotFound()


# Context-sensitive call graph window

class CallGraphWindow(TreeWindowBase):

    def __init__(self, glb, parent=None):
        super(CallGraphWindow, self).__init__(parent)

        self.model = LookupCreateModel("Context-Sensitive Call Graph", lambda x=glb: CallGraphModel(x))

        self.view.setModel(self.model)

        for c, w in ((0, 250), (1, 100), (2, 60), (3, 70), (4, 70), (5, 100)):
            self.view.setColumnWidth(c, w)

        self.find_bar = FindBar(self, self)

        self.vbox = VBox(self.view, self.find_bar.Widget())

        self.setWidget(self.vbox.Widget())

        AddSubWindow(glb.mainwindow.mdi_area, self, "Context-Sensitive Call Graph")

# Call tree window

class CallTreeWindow(TreeWindowBase):

    def __init__(self, glb, parent=None, thread_at_time=None):
        super(CallTreeWindow, self).__init__(parent)

        self.model = LookupCreateModel("Call Tree", lambda x=glb: CallTreeModel(x))

        self.view.setModel(self.model)

        for c, w in ((0, 230), (1, 100), (2, 100), (3, 70), (4, 70), (5, 100)):
            self.view.setColumnWidth(c, w)

        self.find_bar = FindBar(self, self)

        self.vbox = VBox(self.view, self.find_bar.Widget())

        self.setWidget(self.vbox.Widget())

        AddSubWindow(glb.mainwindow.mdi_area, self, "Call Tree")

        if thread_at_time:
            self.DisplayThreadAtTime(*thread_at_time)

    def DisplayThreadAtTime(self, comm_id, thread_id, time):
        parent = QModelIndex()
        for dbid in (comm_id, thread_id):
            found = False
            n = self.model.rowCount(parent)
            for row in range(n):
                child = self.model.index(row, 0, parent)
                if child.internalPointer().dbid == dbid:
                    found = True
                    self.view.setExpanded(parent, True)
                    self.view.setCurrentIndex(child)
                    parent = child
                    break
            if not found:
                return
        found = False
        while True:
            n = self.model.rowCount(parent)
            if not n:
                return
            last_child = None
            for row in range(n):
                self.view.setExpanded(parent, True)
                child = self.model.index(row, 0, parent)
                child_call_time = child.internalPointer().call_time
                if child_call_time < time:
                    last_child = child
                elif child_call_time == time:
                    self.view.setCurrentIndex(child)
                    return
                elif child_call_time > time:
                    break
            if not last_child:
                if not found:
                    child = self.model.index(0, 0, parent)
                    self.view.setExpanded(parent, True)
                    self.view.setCurrentIndex(child)
                return
            found = True
            self.view.setExpanded(parent, True)
            self.view.setCurrentIndex(last_child)
            parent = last_child

# ExecComm() gets the comm_id of the command string that was set when the process exec'd i.e. the program name

def ExecComm(db, thread_id, time):
    query = QSqlQuery(db)
    QueryExec(query, "SELECT comm_threads.comm_id, comms.c_time, comms.exec_flag"
                " FROM comm_threads"
                " INNER JOIN comms ON comms.id = comm_threads.comm_id"
                " WHERE comm_threads.thread_id = " + str(thread_id) +
                " ORDER BY comms.c_time, comms.id")
    first = None
    last = None
    while query.next():
        if first is None:
            first = query.value(0)
        if query.value(2) and Decimal(query.value(1)) <= Decimal(time):
            last = query.value(0)
    if not(last is None):
        return last
    return first

# Container for (x, y) data

class XY():
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def __str__(self):
        return "XY({}, {})".format(str(self.x), str(self.y))

# Container for sub-range data

class Subrange():
    def __init__(self, lo=0, hi=0):
        self.lo = lo
        self.hi = hi

    def __str__(self):
        return "Subrange({}, {})".format(str(self.lo), str(self.hi))

# Graph data region base class

class GraphDataRegion(object):

    def __init__(self, key, title = "", ordinal = ""):
        self.key = key
        self.title = title
        self.ordinal = ordinal

# Function to sort GraphDataRegion

def GraphDataRegionOrdinal(data_region):
    return data_region.ordinal

# Attributes for a graph region

class GraphRegionAttribute():

    def __init__(self, colour):
        self.colour = colour

# Switch graph data region represents a task

class SwitchGraphDataRegion(GraphDataRegion):

    def __init__(self, key, exec_comm_id, pid, tid, comm, thread_id, comm_id):
        super(SwitchGraphDataRegion, self).__init__(key)

        self.title = str(pid) + " / " + str(tid) + " " + comm
        # Order graph legend within exec comm by pid / tid / time
        self.ordinal = str(pid).rjust(16) + str(exec_comm_id).rjust(8) + str(tid).rjust(16)
        self.exec_comm_id = exec_comm_id
        self.pid = pid
        self.tid = tid
        self.comm = comm
        self.thread_id = thread_id
        self.comm_id = comm_id

# Graph data point

class GraphDataPoint():

    def __init__(self, data, index, x, y, altx=None, alty=None, hregion=None, vregion=None):
        self.data = data
        self.index = index
        self.x = x
        self.y = y
        self.altx = altx
        self.alty = alty
        self.hregion = hregion
        self.vregion = vregion

# Graph data (single graph) base class

class GraphData(object):

    def __init__(self, collection, xbase=Decimal(0), ybase=Decimal(0)):
        self.collection = collection
        self.points = []
        self.xbase = xbase
        self.ybase = ybase
        self.title = ""

    def AddPoint(self, x, y, altx=None, alty=None, hregion=None, vregion=None):
        index = len(self.points)

        x = float(Decimal(x) - self.xbase)
        y = float(Decimal(y) - self.ybase)

        self.points.append(GraphDataPoint(self, index, x, y, altx, alty, hregion, vregion))

    def XToData(self, x):
        return Decimal(x) + self.xbase

    def YToData(self, y):
        return Decimal(y) + self.ybase

# Switch graph data (for one CPU)

class SwitchGraphData(GraphData):

    def __init__(self, db, collection, cpu, xbase):
        super(SwitchGraphData, self).__init__(collection, xbase)

        self.cpu = cpu
        self.title = "CPU " + str(cpu)
        self.SelectSwitches(db)

    def SelectComms(self, db, thread_id, last_comm_id, start_time, end_time):
        query = QSqlQuery(db)
        QueryExec(query, "SELECT id, c_time"
                    " FROM comms"
                    " WHERE c_thread_id = " + str(thread_id) +
                    "   AND exec_flag = " + self.collection.glb.dbref.TRUE +
                    "   AND c_time >= " + str(start_time) +
                    "   AND c_time <= " + str(end_time) +
                    " ORDER BY c_time, id")
        while query.next():
            comm_id = query.value(0)
            if comm_id == last_comm_id:
                continue
            time = query.value(1)
            hregion = self.HRegion(db, thread_id, comm_id, time)
            self.AddPoint(time, 1000, None, None, hregion)

    def SelectSwitches(self, db):
        last_time = None
        last_comm_id = None
        last_thread_id = None
        query = QSqlQuery(db)
        QueryExec(query, "SELECT time, thread_out_id, thread_in_id, comm_out_id, comm_in_id, flags"
                    " FROM context_switches"
                    " WHERE machine_id = " + str(self.collection.machine_id) +
                    "   AND cpu = " + str(self.cpu) +
                    " ORDER BY time, id")
        while query.next():
            flags = int(query.value(5))
            if flags & 1:
                # Schedule-out: detect and add exec's
                if last_thread_id == query.value(1) and last_comm_id is not None and last_comm_id != query.value(3):
                    self.SelectComms(db, last_thread_id, last_comm_id, last_time, query.value(0))
                continue
            # Schedule-in: add data point
            if len(self.points) == 0:
                start_time = self.collection.glb.StartTime(self.collection.machine_id)
                hregion = self.HRegion(db, query.value(1), query.value(3), start_time)
                self.AddPoint(start_time, 1000, None, None, hregion)
            time = query.value(0)
            comm_id = query.value(4)
            thread_id = query.value(2)
            hregion = self.HRegion(db, thread_id, comm_id, time)
            self.AddPoint(time, 1000, None, None, hregion)
            last_time = time
            last_comm_id = comm_id
            last_thread_id = thread_id

    def NewHRegion(self, db, key, thread_id, comm_id, time):
        exec_comm_id = ExecComm(db, thread_id, time)
        query = QSqlQuery(db)
        QueryExec(query, "SELECT pid, tid FROM threads WHERE id = " + str(thread_id))
        if query.next():
            pid = query.value(0)
            tid = query.value(1)
        else:
            pid = -1
            tid = -1
        query = QSqlQuery(db)
        QueryExec(query, "SELECT comm FROM comms WHERE id = " + str(comm_id))
        if query.next():
            comm = query.value(0)
        else:
            comm = ""
        return SwitchGraphDataRegion(key, exec_comm_id, pid, tid, comm, thread_id, comm_id)

    def HRegion(self, db, thread_id, comm_id, time):
        key = str(thread_id) + ":" + str(comm_id)
        hregion = self.collection.LookupHRegion(key)
        if hregion is None:
            hregion = self.NewHRegion(db, key, thread_id, comm_id, time)
            self.collection.AddHRegion(key, hregion)
        return hregion

# Graph data collection (multiple related graphs) base class

class GraphDataCollection(object):

    def __init__(self, glb):
        self.glb = glb
        self.data = []
        self.hregions = {}
        self.xrangelo = None
        self.xrangehi = None
        self.yrangelo = None
        self.yrangehi = None
        self.dp = XY(0, 0)

    def AddGraphData(self, data):
        self.data.append(data)

    def LookupHRegion(self, key):
        if key in self.hregions:
            return self.hregions[key]
        return None

    def AddHRegion(self, key, hregion):
        self.hregions[key] = hregion

# Switch graph data collection (SwitchGraphData for each CPU)

class SwitchGraphDataCollection(GraphDataCollection):

    def __init__(self, glb, db, machine_id):
        super(SwitchGraphDataCollection, self).__init__(glb)

        self.machine_id = machine_id
        self.cpus = self.SelectCPUs(db)

        self.xrangelo = glb.StartTime(machine_id)
        self.xrangehi = glb.FinishTime(machine_id)

        self.yrangelo = Decimal(0)
        self.yrangehi = Decimal(1000)

        for cpu in self.cpus:
            self.AddGraphData(SwitchGraphData(db, self, cpu, self.xrangelo))

    def SelectCPUs(self, db):
        cpus = []
        query = QSqlQuery(db)
        QueryExec(query, "SELECT DISTINCT cpu"
                    " FROM context_switches"
                    " WHERE machine_id = " + str(self.machine_id))
        while query.next():
            cpus.append(int(query.value(0)))
        return sorted(cpus)

# Switch graph data graphics item displays the graphed data

class SwitchGraphDataGraphicsItem(QGraphicsItem):

    def __init__(self, data, graph_width, graph_height, attrs, event_handler, parent=None):
        super(SwitchGraphDataGraphicsItem, self).__init__(parent)

        self.data = data
        self.graph_width = graph_width
        self.graph_height = graph_height
        self.attrs = attrs
        self.event_handler = event_handler
        self.setAcceptHoverEvents(True)

    def boundingRect(self):
        return QRectF(0, 0, self.graph_width, self.graph_height)

    def PaintPoint(self, painter, last, x):
        if not(last is None or last.hregion.pid == 0 or x < self.attrs.subrange.x.lo):
            if last.x < self.attrs.subrange.x.lo:
                x0 = self.attrs.subrange.x.lo
            else:
                x0 = last.x
            if x > self.attrs.subrange.x.hi:
                x1 = self.attrs.subrange.x.hi
            else:
                x1 = x - 1
            x0 = self.attrs.XToPixel(x0)
            x1 = self.attrs.XToPixel(x1)

            y0 = self.attrs.YToPixel(last.y)

            colour = self.attrs.region_attributes[last.hregion.key].colour

            width = x1 - x0 + 1
            if width < 2:
                painter.setPen(colour)
                painter.drawLine(x0, self.graph_height - y0, x0, self.graph_height)
            else:
                painter.fillRect(x0, self.graph_height - y0, width, self.graph_height - 1, colour)

    def paint(self, painter, _option, _widget):
        last = None
        for point in self.data.points:
            self.PaintPoint(painter, last, point.x)
            if point.x > self.attrs.subrange.x.hi:
                break
            last = point
        self.PaintPoint(painter, last, self.attrs.subrange.x.hi + 1)

    def BinarySearchPoint(self, target):
        lower_pos = 0
        higher_pos = len(self.data.points)
        while True:
            pos = int((lower_pos + higher_pos) / 2)
            val = self.data.points[pos].x
            if target >= val:
                lower_pos = pos
            else:
                higher_pos = pos
            if higher_pos <= lower_pos + 1:
                return lower_pos

    def XPixelToData(self, x):
        x = self.attrs.PixelToX(x)
        if x < self.data.points[0].x:
            x = 0
            pos = 0
            low = True
        else:
            pos = self.BinarySearchPoint(x)
            low = False
        return (low, pos, self.data.XToData(x))

    def EventToData(self, event):
        no_data = (None,) * 4
        if len(self.data.points) < 1:
            return no_data
        x = event.pos().x()
        if x < 0:
            return no_data
        _low0, pos0, time_from = self.XPixelToData(x)
        low1, pos1, time_to = self.XPixelToData(x + 1)
        hregions = set()
        hregion_times = []
        if not low1:
            for i in range(pos0, pos1 + 1):
                hregion = self.data.points[i].hregion
                hregions.add(hregion)
                if i == pos0:
                    time = time_from
                else:
                    time = self.data.XToData(self.data.points[i].x)
                hregion_times.append((hregion, time))
        return (time_from, time_to, hregions, hregion_times)

    def hoverMoveEvent(self, event):
        time_from, time_to, hregions, _hregion_times = self.EventToData(event)
        if time_from is not None:
            self.event_handler.PointEvent(self.data.cpu, time_from, time_to, hregions)

    def hoverLeaveEvent(self, _event):
        self.event_handler.NoPointEvent()

    def mousePressEvent(self, event):
        if event.button() != Qt.RightButton:
            super(SwitchGraphDataGraphicsItem, self).mousePressEvent(event)
            return
        _time_from, _time_to, _hregions, hregion_times = self.EventToData(event)
        if hregion_times:
            self.event_handler.RightClickEvent(self.data.cpu, hregion_times, event.screenPos())

# X-axis graphics item

class XAxisGraphicsItem(QGraphicsItem):

    def __init__(self, width, parent=None):
        super(XAxisGraphicsItem, self).__init__(parent)

        self.width = width
        self.max_mark_sz = 4
        self.height = self.max_mark_sz + 1

    def boundingRect(self):
        return QRectF(0, 0, self.width, self.height)

    def Step(self):
        attrs = self.parentItem().attrs
        subrange = attrs.subrange.x
        t = subrange.hi - subrange.lo
        s = (3.0 * t) / self.width
        n = 1.0
        while s > n:
            n = n * 10.0
        return n

    def PaintMarks(self, painter, at_y, lo, hi, step, i):
        attrs = self.parentItem().attrs
        x = lo
        while x <= hi:
            xp = attrs.XToPixel(x)
            if i % 10:
                if i % 5:
                    sz = 1
                else:
                    sz = 2
            else:
                sz = self.max_mark_sz
                i = 0
            painter.drawLine(xp, at_y, xp, at_y + sz)
            x += step
            i += 1

    def paint(self, painter, _option, _widget):
        # Using QPainter::drawLine(int x1, int y1, int x2, int y2) so x2 = width -1
        painter.drawLine(0, 0, self.width - 1, 0)
        n = self.Step()
        attrs = self.parentItem().attrs
        subrange = attrs.subrange.x
        if subrange.lo:
            x_offset = n - (subrange.lo % n)
        else:
            x_offset = 0.0
        x = subrange.lo + x_offset
        i = (x / n) % 10
        self.PaintMarks(painter, 0, x, subrange.hi, n, i)

    def ScaleDimensions(self):
        n = self.Step()
        attrs = self.parentItem().attrs
        lo = attrs.subrange.x.lo
        hi = (n * 10.0) + lo
        width = attrs.XToPixel(hi)
        if width > 500:
            width = 0
        return (n, lo, hi, width)

    def PaintScale(self, painter, at_x, at_y):
        n, lo, hi, width = self.ScaleDimensions()
        if not width:
            return
        painter.drawLine(at_x, at_y, at_x + width, at_y)
        self.PaintMarks(painter, at_y, lo, hi, n, 0)

    def ScaleWidth(self):
        _n, _lo, _hi, width = self.ScaleDimensions()
        return width

    def ScaleHeight(self):
        return self.height

    def ScaleUnit(self):
        return self.Step() * 10

# Scale graphics item base class

class ScaleGraphicsItem(QGraphicsItem):

    def __init__(self, axis, parent=None):
        super(ScaleGraphicsItem, self).__init__(parent)
        self.axis = axis

    def boundingRect(self):
        scale_width = self.axis.ScaleWidth()
        if not scale_width:
            return QRectF()
        return QRectF(0, 0, self.axis.ScaleWidth() + 100, self.axis.ScaleHeight())

    def paint(self, painter, _option, _widget):
        scale_width = self.axis.ScaleWidth()
        if not scale_width:
            return
        self.axis.PaintScale(painter, 0, 5)
        x = scale_width + 4
        painter.drawText(QPointF(x, 10), self.Text())

    def Unit(self):
        return self.axis.ScaleUnit()

    def Text(self):
        return ""

# Switch graph scale graphics item

class SwitchScaleGraphicsItem(ScaleGraphicsItem):

    def Text(self):
        unit = self.Unit()
        if unit >= 1000000000:
            unit = int(unit / 1000000000)
            us = "s"
        elif unit >= 1000000:
            unit = int(unit / 1000000)
            us = "ms"
        elif unit >= 1000:
            unit = int(unit / 1000)
            us = "us"
        else:
            unit = int(unit)
            us = "ns"
        return " = " + str(unit) + " " + us

# Switch graph graphics item contains graph title, scale, x/y-axis, and the graphed data

class SwitchGraphGraphicsItem(QGraphicsItem):

    def __init__(self, collection, data, attrs, event_handler, first, parent=None):
        super(SwitchGraphGraphicsItem, self).__init__(parent)
        self.collection = collection
        self.data = data
        self.attrs = attrs
        self.event_handler = event_handler

        margin = 20
        title_width = 50

        self.title_graphics = QGraphicsSimpleTextItem(data.title, self)

        self.title_graphics.setPos(margin, margin)
        graph_width = attrs.XToPixel(attrs.subrange.x.hi) + 1
        graph_height = attrs.YToPixel(attrs.subrange.y.hi) + 1

        self.graph_origin_x = margin + title_width + margin
        self.graph_origin_y = graph_height + margin

        _x_axis_size = 1
        y_axis_size = 1
        self.yline = QGraphicsLineItem(0, 0, 0, graph_height, self)

        self.x_axis = XAxisGraphicsItem(graph_width, self)
        self.x_axis.setPos(self.graph_origin_x, self.graph_origin_y + 1)

        if first:
            self.scale_item = SwitchScaleGraphicsItem(self.x_axis, self)
            self.scale_item.setPos(self.graph_origin_x, self.graph_origin_y + 10)

        self.yline.setPos(self.graph_origin_x - y_axis_size, self.graph_origin_y - graph_height)

        self.axis_point = QGraphicsLineItem(0, 0, 0, 0, self)
        self.axis_point.setPos(self.graph_origin_x - 1, self.graph_origin_y +1)

        self.width = self.graph_origin_x + graph_width + margin
        self.height = self.graph_origin_y + margin

        self.graph = SwitchGraphDataGraphicsItem(data, graph_width, graph_height, attrs, event_handler, self)
        self.graph.setPos(self.graph_origin_x, self.graph_origin_y - graph_height)

        if parent and 'EnableRubberBand' in dir(parent):
            parent.EnableRubberBand(self.graph_origin_x, self.graph_origin_x + graph_width - 1, self)

    def boundingRect(self):
        return QRectF(0, 0, self.width, self.height)

    def paint(self, painter, option, widget):
        pass

    def RBXToPixel(self, x):
        return self.attrs.PixelToX(x - self.graph_origin_x)

    def RBXRangeToPixel(self, x0, x1):
        return (self.RBXToPixel(x0), self.RBXToPixel(x1 + 1))

    def RBPixelToTime(self, x):
        if x < self.data.points[0].x:
            return self.data.XToData(0)
        return self.data.XToData(x)

    def RBEventTimes(self, x0, x1):
        x0, x1 = self.RBXRangeToPixel(x0, x1)
        time_from = self.RBPixelToTime(x0)
        time_to = self.RBPixelToTime(x1)
        return (time_from, time_to)

    def RBEvent(self, x0, x1):
        time_from, time_to = self.RBEventTimes(x0, x1)
        self.event_handler.RangeEvent(time_from, time_to)

    def RBMoveEvent(self, x0, x1):
        if x1 < x0:
            x0, x1 = x1, x0
        self.RBEvent(x0, x1)

    def RBReleaseEvent(self, x0, x1, selection_state):
        if x1 < x0:
            x0, x1 = x1, x0
        x0, x1 = self.RBXRangeToPixel(x0, x1)
        self.event_handler.SelectEvent(x0, x1, selection_state)

# Graphics item to draw a vertical bracket (used to highlight "forward" sub-range)

class VerticalBracketGraphicsItem(QGraphicsItem):

    def __init__(self, parent=None):
        super(VerticalBracketGraphicsItem, self).__init__(parent)

        self.width = 0
        self.height = 0
        self.hide()

    def SetSize(self, width, height):
        self.width = width + 1
        self.height = height + 1

    def boundingRect(self):
        return QRectF(0, 0, self.width, self.height)

    def paint(self, painter, _option, _widget):
        colour = QColor(255, 255, 0, 32)
        painter.fillRect(0, 0, self.width, self.height, colour)
        x1 = self.width - 1
        y1 = self.height - 1
        painter.drawLine(0, 0, x1, 0)
        painter.drawLine(0, 0, 0, 3)
        painter.drawLine(x1, 0, x1, 3)
        painter.drawLine(0, y1, x1, y1)
        painter.drawLine(0, y1, 0, y1 - 3)
        painter.drawLine(x1, y1, x1, y1 - 3)

# Graphics item to contain graphs arranged vertically

class VertcalGraphSetGraphicsItem(QGraphicsItem):

    def __init__(self, collection, attrs, event_handler, child_class, parent=None):
        super(VertcalGraphSetGraphicsItem, self).__init__(parent)

        self.collection = collection

        self.top = 10

        self.width = 0
        self.height = self.top

        self.rubber_band = None
        self.rb_enabled = False
        self.rb_in_view = False
        self.rb_xlo = 0
        self.rb_xhi = 0
        self.rb_event_handler = None
        self.rb_origin = None

        first = True
        for data in collection.data:
            child = child_class(collection, data, attrs, event_handler, first, self)
            child.setPos(0, self.height + 1)
            rect = child.boundingRect()
            if rect.right() > self.width:
                self.width = rect.right()
            self.height = self.height + rect.bottom() + 1
            first = False

        self.bracket = VerticalBracketGraphicsItem(self)

    def EnableRubberBand(self, xlo, xhi, rb_event_handler):
        if self.rb_enabled:
            return
        self.rb_enabled = True
        self.rb_in_view = False
        self.setAcceptedMouseButtons(Qt.LeftButton)
        self.rb_xlo = xlo
        self.rb_xhi = xhi
        self.rb_event_handler = rb_event_handler

    def mousePressEvent(self, event):
        if self.rb_enabled:
            self.MousePressEvent(event)

    def mouseMoveEvent(self, event):
        if self.rb_enabled:
            self.MouseMoveEvent(event)

    def mouseReleaseEvent(self, event):
        if self.rb_enabled:
            self.MouseReleaseEvent(event)

    def boundingRect(self):
        return QRectF(0, 0, self.width, self.height)

    def paint(self, painter, option, widget):
        pass

    def RubberBandParent(self):
        scene = self.scene()
        view = scene.views()[0]
        viewport = view.viewport()
        return viewport

    def RubberBandSetGeometry(self, rect):
        scene_rectf = self.mapRectToScene(QRectF(rect))
        scene = self.scene()
        view = scene.views()[0]
        poly = view.mapFromScene(scene_rectf)
        self.rubber_band.setGeometry(poly.boundingRect())

    def SetSelection(self, selection_state):
        if self.rubber_band:
            if selection_state:
                self.RubberBandSetGeometry(selection_state)
                self.rubber_band.show()
            else:
                self.rubber_band.hide()

    def SetBracket(self, rect):
        if rect:
            x, y, width, height = rect.x(), rect.y(), rect.width(), rect.height()
            self.bracket.setPos(x, y)
            self.bracket.SetSize(width, height)
            self.bracket.show()
        else:
            self.bracket.hide()

    def RubberBandX(self, event):
        x = event.pos().toPoint().x()
        if x < self.rb_xlo:
            x = self.rb_xlo
        elif x > self.rb_xhi:
            x = self.rb_xhi
        else:
            self.rb_in_view = True
        return x

    def RubberBandRect(self, x):
        if self.rb_origin.x() <= x:
            width = x - self.rb_origin.x()
            rect = QRect(self.rb_origin, QSize(width, self.height))
        else:
            width = self.rb_origin.x() - x
            top_left = QPoint(self.rb_origin.x() - width, self.rb_origin.y())
            rect = QRect(top_left, QSize(width, self.height))
        return rect

    def MousePressEvent(self, event):
        self.rb_in_view = False
        x = self.RubberBandX(event)
        self.rb_origin = QPoint(x, self.top)
        if self.rubber_band is None:
            self.rubber_band = QRubberBand(QRubberBand.Rectangle, self.RubberBandParent())
        self.RubberBandSetGeometry(QRect(self.rb_origin, QSize(0, self.height)))
        if self.rb_in_view:
            self.rubber_band.show()
            self.rb_event_handler.RBMoveEvent(x, x)
        else:
            self.rubber_band.hide()

    def MouseMoveEvent(self, event):
        x = self.RubberBandX(event)
        rect = self.RubberBandRect(x)
        self.RubberBandSetGeometry(rect)
        if self.rb_in_view:
            self.rubber_band.show()
            self.rb_event_handler.RBMoveEvent(self.rb_origin.x(), x)

    def MouseReleaseEvent(self, event):
        x = self.RubberBandX(event)
        if self.rb_in_view:
            selection_state = self.RubberBandRect(x)
        else:
            selection_state = None
        self.rb_event_handler.RBReleaseEvent(self.rb_origin.x(), x, selection_state)

# Switch graph legend data model

class SwitchGraphLegendModel(QAbstractTableModel):

    def __init__(self, collection, region_attributes, parent=None):
        super(SwitchGraphLegendModel, self).__init__(parent)

        self.region_attributes = region_attributes

        self.child_items = sorted(collection.hregions.values(), key=GraphDataRegionOrdinal)
        self.child_count = len(self.child_items)

        self.highlight_set = set()

        self.column_headers = ("pid", "tid", "comm")

    def rowCount(self, _parent):
        return self.child_count

    def headerData(self, section, orientation, role):
        if role != Qt.DisplayRole:
            return None
        if orientation != Qt.Horizontal:
            return None
        return self.columnHeader(section)

    def index(self, row, column, _parent):
        return self.createIndex(row, column, self.child_items[row])

    def columnCount(self, _parent=None):
        return len(self.column_headers)

    def columnHeader(self, column):
        return self.column_headers[column]

    def data(self, index, role):
        if role == Qt.BackgroundRole:
            child = self.child_items[index.row()]
            if child in self.highlight_set:
                return self.region_attributes[child.key].colour
            return None
        if role == Qt.ForegroundRole:
            child = self.child_items[index.row()]
            if child in self.highlight_set:
                return QColor(255, 255, 255)
            return self.region_attributes[child.key].colour
        if role != Qt.DisplayRole:
            return None
        hregion = self.child_items[index.row()]
        col = index.column()
        if col == 0:
            return hregion.pid
        if col == 1:
            return hregion.tid
        if col == 2:
            return hregion.comm
        return None

    def SetHighlight(self, row, _set_highlight):
        child = self.child_items[row]
        top_left = self.createIndex(row, 0, child)
        bottom_right = self.createIndex(row, len(self.column_headers) - 1, child)
        self.dataChanged.emit(top_left, bottom_right)

    def Highlight(self, highlight_set):
        for row in range(self.child_count):
            child = self.child_items[row]
            if child in self.highlight_set:
                if child not in highlight_set:
                    self.SetHighlight(row, False)
            elif child in highlight_set:
                self.SetHighlight(row, True)
        self.highlight_set = highlight_set

# Switch graph legend is a table

class SwitchGraphLegend(QWidget):

    def __init__(self, collection, region_attributes, parent=None):
        super(SwitchGraphLegend, self).__init__(parent)

        self.data_model = SwitchGraphLegendModel(collection, region_attributes)

        self.model = QSortFilterProxyModel()
        self.model.setSourceModel(self.data_model)

        self.view = QTableView()
        self.view.setModel(self.model)
        self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
        self.view.verticalHeader().setVisible(False)
        self.view.sortByColumn(-1, Qt.AscendingOrder)
        self.view.setSortingEnabled(True)
        self.view.resizeColumnsToContents()
        self.view.resizeRowsToContents()

        self.vbox = VBoxLayout(self.view)
        self.setLayout(self.vbox)

        sz1 = self.view.columnWidth(0) + self.view.columnWidth(1) + self.view.columnWidth(2) + 2
        sz1 = sz1 + self.view.verticalScrollBar().sizeHint().width()
        self.saved_size = sz1

    def resizeEvent(self, event):
        self.saved_size = self.size().width()
        super(SwitchGraphLegend, self).resizeEvent(event)

    def Highlight(self, highlight_set):
        self.data_model.Highlight(highlight_set)
        self.update()

    def changeEvent(self, event):
        if event.type() == QEvent.FontChange:
            self.view.resizeRowsToContents()
            self.view.resizeColumnsToContents()
            # Need to resize rows again after column resize
            self.view.resizeRowsToContents()
        super(SwitchGraphLegend, self).changeEvent(event)

# Random colour generation

def RGBColourTooLight(r, g, _b):
    if g > 230:
        return True
    if g <= 160:
        return False
    if r <= 180 and g <= 180:
        return False
    if r < 60:
        return False
    return True

def GenerateColours(x):
    cs = [0]
    for i in range(1, x):
        cs.append(int((255.0 / i) + 0.5))
    colours = []
    for r in cs:
        for g in cs:
            for b in cs:
                # Exclude black and colours that look too light against a white background
                if (r, g, b) == (0, 0, 0) or RGBColourTooLight(r, g, b):
                    continue
                colours.append(QColor(r, g, b))
    return colours

def GenerateNColours(n):
    for x in range(2, n + 2):
        colours = GenerateColours(x)
        if len(colours) >= n:
            return colours
    return []

def GenerateNRandomColours(n, seed):
    colours = GenerateNColours(n)
    random.seed(seed)
    random.shuffle(colours)
    return colours

# Graph attributes, in particular the scale and subrange that change when zooming

class GraphAttributes():

    def __init__(self, scale, subrange, region_attributes, dp):
        self.scale = scale
        self.subrange = subrange
        self.region_attributes = region_attributes
        # Rounding avoids errors due to finite floating point precision
        self.dp = dp	# data decimal places
        self.Update()

    def XToPixel(self, x):
        return int(round((x - self.subrange.x.lo) * self.scale.x, self.pdp.x))

    def YToPixel(self, y):
        return int(round((y - self.subrange.y.lo) * self.scale.y, self.pdp.y))

    def PixelToXRounded(self, px):
        return round((round(px, 0) / self.scale.x), self.dp.x) + self.subrange.x.lo

    def PixelToYRounded(self, py):
        return round((round(py, 0) / self.scale.y), self.dp.y) + self.subrange.y.lo

    def PixelToX(self, px):
        x = self.PixelToXRounded(px)
        if self.pdp.x == 0:
            rt = self.XToPixel(x)
            if rt > px:
                return x - 1
        return x

    def PixelToY(self, py):
        y = self.PixelToYRounded(py)
        if self.pdp.y == 0:
            rt = self.YToPixel(y)
            if rt > py:
                return y - 1
        return y

    def ToPDP(self, dp, scale):
        # Calculate pixel decimal places:
        #    (10 ** dp) is the minimum delta in the data
        #    scale it to get the minimum delta in pixels
        #    log10 gives the number of decimals places negatively
        #    subtrace 1 to divide by 10
        #    round to the lower negative number
        #    change the sign to get the number of decimals positively
        x = math.log10((10 ** dp) * scale)
        if x < 0:
            x -= 1
            x = -int(math.floor(x) - 0.1)
        else:
            x = 0
        return x

    def Update(self):
        x = self.ToPDP(self.dp.x, self.scale.x)
        y = self.ToPDP(self.dp.y, self.scale.y)
        self.pdp = XY(x, y) # pixel decimal places

# Switch graph splitter which divides the CPU graphs from the legend

class SwitchGraphSplitter(QSplitter):

    def __init__(self, parent=None):
        super(SwitchGraphSplitter, self).__init__(parent)

        self.first_time = False

    def resizeEvent(self, event):
        if self.first_time:
            self.first_time = False
            sz1 = self.widget(1).view.columnWidth(0) + self.widget(1).view.columnWidth(1) + self.widget(1).view.columnWidth(2) + 2
            sz1 = sz1 + self.widget(1).view.verticalScrollBar().sizeHint().width()
            sz0 = self.size().width() - self.handleWidth() - sz1
            self.setSizes([sz0, sz1])
        elif not(self.widget(1).saved_size is None):
            sz1 = self.widget(1).saved_size
            sz0 = self.size().width() - self.handleWidth() - sz1
            self.setSizes([sz0, sz1])
        super(SwitchGraphSplitter, self).resizeEvent(event)

# Graph widget base class

class GraphWidget(QWidget):

    graph_title_changed = Signal(object)

    def __init__(self, parent=None):
        super(GraphWidget, self).__init__(parent)

    def GraphTitleChanged(self, title):
        self.graph_title_changed.emit(title)

    def Title(self):
        return ""

# Display time in s, ms, us or ns

def ToTimeStr(val):
    val = Decimal(val)
    if val >= 1000000000:
        return "{} s".format((val / 1000000000).quantize(Decimal("0.000000001")))
    if val >= 1000000:
        return "{} ms".format((val / 1000000).quantize(Decimal("0.000001")))
    if val >= 1000:
        return "{} us".format((val / 1000).quantize(Decimal("0.001")))
    return "{} ns".format(val.quantize(Decimal("1")))

# Switch (i.e. context switch i.e. Time Chart by CPU) graph widget which contains the CPU graphs and the legend and control buttons

class SwitchGraphWidget(GraphWidget):

    def __init__(self, glb, collection, parent=None):
        super(SwitchGraphWidget, self).__init__(parent)

        self.glb = glb
        self.collection = collection

        self.back_state = []
        self.forward_state = []
        self.selection_state = (None, None)
        self.fwd_rect = None
        self.start_time = self.glb.StartTime(collection.machine_id)

        i = 0
        hregions = collection.hregions.values()
        colours = GenerateNRandomColours(len(hregions), 1013)
        region_attributes = {}
        for hregion in hregions:
            if hregion.pid == 0 and hregion.tid == 0:
                region_attributes[hregion.key] = GraphRegionAttribute(QColor(0, 0, 0))
            else:
                region_attributes[hregion.key] = GraphRegionAttribute(colours[i])
                i = i + 1

        # Default to entire range
        xsubrange = Subrange(0.0, float(collection.xrangehi - collection.xrangelo) + 1.0)
        ysubrange = Subrange(0.0, float(collection.yrangehi - collection.yrangelo) + 1.0)
        subrange = XY(xsubrange, ysubrange)

        scale = self.GetScaleForRange(subrange)

        self.attrs = GraphAttributes(scale, subrange, region_attributes, collection.dp)

        self.item = VertcalGraphSetGraphicsItem(collection, self.attrs, self, SwitchGraphGraphicsItem)

        self.scene = QGraphicsScene()
        self.scene.addItem(self.item)

        self.view = QGraphicsView(self.scene)
        self.view.centerOn(0, 0)
        self.view.setAlignment(Qt.AlignLeft | Qt.AlignTop)

        self.legend = SwitchGraphLegend(collection, region_attributes)

        self.splitter = SwitchGraphSplitter()
        self.splitter.addWidget(self.view)
        self.splitter.addWidget(self.legend)

        self.point_label = QLabel("")
        self.point_label.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)

        self.back_button = QToolButton()
        self.back_button.setIcon(self.style().standardIcon(QStyle.SP_ArrowLeft))
        self.back_button.setDisabled(True)
        self.back_button.released.connect(self.Back)

        self.forward_button = QToolButton()
        self.forward_button.setIcon(self.style().standardIcon(QStyle.SP_ArrowRight))
        self.forward_button.setDisabled(True)
        self.forward_button.released.connect(self.Forward)

        self.zoom_button = QToolButton()
        self.zoom_button.setText("Zoom")
        self.zoom_button.setDisabled(True)
        self.zoom_button.released.connect(self.Zoom)

        self.hbox = HBoxLayout(self.back_button, self.forward_button, self.zoom_button, self.point_label)

        self.vbox = VBoxLayout(self.splitter, self.hbox)

        self.setLayout(self.vbox)

    def GetScaleForRangeX(self, xsubrange):
        # Default graph 1000 pixels wide
        dflt = 1000.0
        r = xsubrange.hi - xsubrange.lo
        return dflt / r

    def GetScaleForRangeY(self, ysubrange):
        # Default graph 50 pixels high
        dflt = 50.0
        r = ysubrange.hi - ysubrange.lo
        return dflt / r

    def GetScaleForRange(self, subrange):
        # Default graph 1000 pixels wide, 50 pixels high
        xscale = self.GetScaleForRangeX(subrange.x)
        yscale = self.GetScaleForRangeY(subrange.y)
        return XY(xscale, yscale)

    def PointEvent(self, cpu, time_from, _time_to, hregions):
        text = "CPU: " + str(cpu)
        time_from = time_from.quantize(Decimal(1))
        rel_time_from = time_from - self.glb.StartTime(self.collection.machine_id)
        text = text + " Time: " + str(time_from) + " (+" + ToTimeStr(rel_time_from) + ")"
        self.point_label.setText(text)
        self.legend.Highlight(hregions)

    def RightClickEvent(self, _cpu, hregion_times, pos):
        if not IsSelectable(self.glb.db, "calls", "WHERE parent_id >= 0"):
            return
        menu = QMenu(self.view)
        for hregion, time in hregion_times:
            thread_at_time = (hregion.exec_comm_id, hregion.thread_id, time)
            menu_text = "Show Call Tree for {} {}:{} at {}".format(hregion.comm, hregion.pid, hregion.tid, time)
            menu.addAction(CreateAction(menu_text, "Show Call Tree", lambda a=None, args=thread_at_time: self.RightClickSelect(args), self.view))
        menu.exec_(pos)

    def RightClickSelect(self, args):
        CallTreeWindow(self.glb, self.glb.mainwindow, thread_at_time=args)

    def NoPointEvent(self):
        self.point_label.setText("")
        self.legend.Highlight({})

    def RangeEvent(self, time_from, time_to):
        time_from = time_from.quantize(Decimal(1))
        time_to = time_to.quantize(Decimal(1))
        if time_to <= time_from:
            self.point_label.setText("")
            return
        rel_time_from = time_from - self.start_time
        rel_time_to = time_to - self.start_time
        text = " Time: " + str(time_from) + " (+" + ToTimeStr(rel_time_from) + ") to: " + str(time_to) + " (+" + ToTimeStr(rel_time_to) + ")"
        text = text + " duration: " + ToTimeStr(time_to - time_from)
        self.point_label.setText(text)

    def BackState(self):
        return (self.attrs.subrange, self.attrs.scale, self.selection_state, self.fwd_rect)

    def PushBackState(self):
        state = copy.deepcopy(self.BackState())
        self.back_state.append(state)
        self.back_button.setEnabled(True)

    def PopBackState(self):
        self.attrs.subrange, self.attrs.scale, self.selection_state, self.fwd_rect = self.back_state.pop()
        self.attrs.Update()
        if not self.back_state:
            self.back_button.setDisabled(True)

    def PushForwardState(self):
        state = copy.deepcopy(self.BackState())
        self.forward_state.append(state)
        self.forward_button.setEnabled(True)

    def PopForwardState(self):
        self.attrs.subrange, self.attrs.scale, self.selection_state, self.fwd_rect = self.forward_state.pop()
        self.attrs.Update()
        if not self.forward_state:
            self.forward_button.setDisabled(True)

    def Title(self):
        time_from = self.collection.xrangelo + Decimal(self.attrs.subrange.x.lo)
        time_to = self.collection.xrangelo + Decimal(self.attrs.subrange.x.hi)
        rel_time_from = time_from - self.start_time
        rel_time_to = time_to - self.start_time
        title = "+" + ToTimeStr(rel_time_from) + " to +" + ToTimeStr(rel_time_to)
        title = title + " (" + ToTimeStr(time_to - time_from) + ")"
        return title

    def Update(self):
        selected_subrange, selection_state = self.selection_state
        self.item.SetSelection(selection_state)
        self.item.SetBracket(self.fwd_rect)
        self.zoom_button.setDisabled(selected_subrange is None)
        self.GraphTitleChanged(self.Title())
        self.item.update(self.item.boundingRect())

    def Back(self):
        if not self.back_state:
            return
        self.PushForwardState()
        self.PopBackState()
        self.Update()

    def Forward(self):
        if not self.forward_state:
            return
        self.PushBackState()
        self.PopForwardState()
        self.Update()

    def SelectEvent(self, x0, x1, selection_state):
        if selection_state is None:
            selected_subrange = None
        else:
            if x1 - x0 < 1.0:
                x1 += 1.0
            selected_subrange = Subrange(x0, x1)
        self.selection_state = (selected_subrange, selection_state)
        self.zoom_button.setDisabled(selected_subrange is None)

    def Zoom(self):
        selected_subrange, selection_state = self.selection_state
        if selected_subrange is None:
            return
        self.fwd_rect = selection_state
        self.item.SetSelection(None)
        self.PushBackState()
        self.attrs.subrange.x = selected_subrange
        self.forward_state = []
        self.forward_button.setDisabled(True)
        self.selection_state = (None, None)
        self.fwd_rect = None
        self.attrs.scale.x = self.GetScaleForRangeX(self.attrs.subrange.x)
        self.attrs.Update()
        self.Update()

# Slow initialization - perform non-GUI initialization in a separate thread and put up a modal message box while waiting

class SlowInitClass():

    def __init__(self, glb, title, init_fn):
        self.init_fn = init_fn
        self.done = False
        self.result = None

        self.msg_box = QMessageBox(glb.mainwindow)
        self.msg_box.setText("Initializing " + title + ". Please wait.")
        self.msg_box.setWindowTitle("Initializing " + title)
        self.msg_box.setWindowIcon(glb.mainwindow.style().standardIcon(QStyle.SP_MessageBoxInformation))

        self.init_thread = Thread(self.ThreadFn, glb)
        self.init_thread.done.connect(self.Done, Qt.QueuedConnection)

        self.init_thread.start()

    def Done(self):
        self.msg_box.done(0)

    def ThreadFn(self, glb):
        conn_name = "SlowInitClass" + str(os.getpid())
        db, _dbname = glb.dbref.Open(conn_name)
        self.result = self.init_fn(db)
        self.done = True
        return (True, 0)

    def Result(self):
        while not self.done:
            self.msg_box.exec_()
        self.init_thread.wait()
        return self.result

def SlowInit(glb, title, init_fn):
    init = SlowInitClass(glb, title, init_fn)
    return init.Result()

# Time chart by CPU window

class TimeChartByCPUWindow(QMdiSubWindow):

    def __init__(self, glb, parent=None):
        super(TimeChartByCPUWindow, self).__init__(parent)

        self.glb = glb
        self.machine_id = glb.HostMachineId()
        self.collection_name = "SwitchGraphDataCollection " + str(self.machine_id)

        collection = LookupModel(self.collection_name)
        if collection is None:
            collection = SlowInit(glb, "Time Chart", self.Init)

        self.widget = SwitchGraphWidget(glb, collection, self)
        self.view = self.widget

        self.base_title = "Time Chart by CPU"
        self.setWindowTitle(self.base_title + self.widget.Title())
        self.widget.graph_title_changed.connect(self.GraphTitleChanged)

        self.setWidget(self.widget)

        AddSubWindow(glb.mainwindow.mdi_area, self, self.windowTitle())

    def Init(self, db):
        return LookupCreateModel(self.collection_name, lambda : SwitchGraphDataCollection(self.glb, db, self.machine_id))

    def GraphTitleChanged(self, title):
        self.setWindowTitle(self.base_title + " : " + title)

# Child data item  finder

class ChildDataItemFinder():

    def __init__(self, root):
        self.root = root
        self.value, self.direction, self.pattern, self.last_value, self.last_pattern = (None,) * 5
        self.rows = []
        self.pos = 0

    def FindSelect(self):
        self.rows = []
        if self.pattern:
            pattern = re.compile(self.value)
            for child in self.root.child_items:
                for column_data in child.data:
                    if re.search(pattern, str(column_data)) is not None:
                        self.rows.append(child.row)
                        break
        else:
            for child in self.root.child_items:
                for column_data in child.data:
                    if self.value in str(column_data):
                        self.rows.append(child.row)
                        break

    def FindValue(self):
        self.pos = 0
        if self.last_value != self.value or self.pattern != self.last_pattern:
            self.FindSelect()
        if not len(self.rows):
            return -1
        return self.rows[self.pos]

    def FindThread(self):
        if self.direction == 0 or self.value != self.last_value or self.pattern != self.last_pattern:
            row = self.FindValue()
        elif len(self.rows):
            if self.direction > 0:
                self.pos += 1
                if self.pos >= len(self.rows):
                    self.pos = 0
            else:
                self.pos -= 1
                if self.pos < 0:
                    self.pos = len(self.rows) - 1
            row = self.rows[self.pos]
        else:
            row = -1
        return (True, row)

    def Find(self, value, direction, pattern, _context, callback):
        self.value, self.direction, self.pattern, self.last_value, self.last_pattern = (value, direction,pattern, self.value, self.pattern)
        # Use a thread so the UI is not blocked
        thread = Thread(self.FindThread)
        thread.done.connect(lambda row, t=thread, c=callback: self.FindDone(t, c, row), Qt.QueuedConnection)
        thread.start()

    def FindDone(self, _thread, callback, row):
        callback(row)

# Number of database records to fetch in one go

glb_chunk_sz = 10000

# Background process for SQL data fetcher

class SQLFetcherProcess():

    def __init__(self, dbref, sql, buffer, head, tail, fetch_count, fetching_done, process_target, wait_event, fetched_event, prep):
        # Need a unique connection name
        conn_name = "SQLFetcher" + str(os.getpid())
        self.db, _dbname = dbref.Open(conn_name)
        self.sql = sql
        self.buffer = buffer
        self.head = head
        self.tail = tail
        self.fetch_count = fetch_count
        self.fetching_done = fetching_done
        self.process_target = process_target
        self.wait_event = wait_event
        self.fetched_event = fetched_event
        self.prep = prep
        self.query = QSqlQuery(self.db)
        self.query_limit = 0 if "$$last_id$$" in sql else 2
        self.last_id = -1
        self.fetched = 0
        self.more = True
        self.local_head = self.head.value
        self.local_tail = self.tail.value

    def Select(self):
        if self.query_limit:
            if self.query_limit == 1:
                return
            self.query_limit -= 1
        stmt = self.sql.replace("$$last_id$$", str(self.last_id))
        QueryExec(self.query, stmt)

    def Next(self):
        if not self.query.next():
            self.Select()
            if not self.query.next():
                return None
        self.last_id = self.query.value(0)
        return self.prep(self.query)

    def WaitForTarget(self):
        while True:
            self.wait_event.clear()
            target = self.process_target.value
            if target > self.fetched or target < 0:
                break
            self.wait_event.wait()
        return target

    def HasSpace(self, sz):
        if self.local_tail <= self.local_head:
            space = len(self.buffer) - self.local_head
            if space > sz:
                return True
            if space >= glb_nsz:
                # Use 0 (or space < glb_nsz) to mean there is no more at the top of the buffer
                nd = pickle.dumps(0, pickle.HIGHEST_PROTOCOL)
                self.buffer[self.local_head : self.local_head + len(nd)] = nd
            self.local_head = 0
        if self.local_tail - self.local_head > sz:
            return True
        return False

    def WaitForSpace(self, sz):
        if self.HasSpace(sz):
            return
        while True:
            self.wait_event.clear()
            self.local_tail = self.tail.value
            if self.HasSpace(sz):
                return
            self.wait_event.wait()

    def AddToBuffer(self, obj):
        d = pickle.dumps(obj, pickle.HIGHEST_PROTOCOL)
        n = len(d)
        nd = pickle.dumps(n, pickle.HIGHEST_PROTOCOL)
        sz = n + glb_nsz
        self.WaitForSpace(sz)
        pos = self.local_head
        self.buffer[pos : pos + len(nd)] = nd
        self.buffer[pos + glb_nsz : pos + sz] = d
        self.local_head += sz

    def FetchBatch(self, batch_size):
        fetched = 0
        while batch_size > fetched:
            obj = self.Next()
            if obj is None:
                self.more = False
                break
            self.AddToBuffer(obj)
            fetched += 1
        if fetched:
            self.fetched += fetched
            with self.fetch_count.get_lock():
                self.fetch_count.value += fetched
            self.head.value = self.local_head
            self.fetched_event.set()

    def Run(self):
        while self.more:
            target = self.WaitForTarget()
            if target < 0:
                break
            batch_size = min(glb_chunk_sz, target - self.fetched)
            self.FetchBatch(batch_size)
        self.fetching_done.value = True
        self.fetched_event.set()

def SQLFetcherFn(*x):
    process = SQLFetcherProcess(*x)
    process.Run()

# SQL data fetcher

class SQLFetcher(QObject):

    done = Signal(object)

    def __init__(self, glb, sql, prep, process_data, parent=None):
        super(SQLFetcher, self).__init__(parent)
        self.process_data = process_data
        self.more = True
        self.target = 0
        self.last_target = 0
        self.fetched = 0
        self.buffer_size = 16 * 1024 * 1024
        self.buffer = Array(c_char, self.buffer_size, lock=False)
        self.head = Value(c_longlong)
        self.tail = Value(c_longlong)
        self.local_tail = 0
        self.fetch_count = Value(c_longlong)
        self.fetching_done = Value(c_bool)
        self.last_count = 0
        self.process_target = Value(c_longlong)
        self.wait_event = Event()
        self.fetched_event = Event()
        glb.AddInstanceToShutdownOnExit(self)
        self.process = Process(target=SQLFetcherFn, args=(glb.dbref, sql, self.buffer, self.head, self.tail, self.fetch_count, self.fetching_done, self.process_target, self.wait_event, self.fetched_event, prep))
        self.process.start()
        self.thread = Thread(self.Thread)
        self.thread.done.connect(self.ProcessData, Qt.QueuedConnection)
        self.thread.start()

    def Shutdown(self):
        # Tell the thread and process to exit
        self.process_target.value = -1
        self.wait_event.set()
        self.more = False
        self.fetching_done.value = True
        self.fetched_event.set()

    def Thread(self):
        if not self.more:
            return True, 0
        while True:
            self.fetched_event.clear()
            fetch_count = self.fetch_count.value
            if fetch_count != self.last_count:
                break
            if self.fetching_done.value:
                self.more = False
                return True, 0
            self.fetched_event.wait()
        count = fetch_count - self.last_count
        self.last_count = fetch_count
        self.fetched += count
        return False, count

    def Fetch(self, nr):
        if not self.more:
            # -1 inidcates there are no more
            return -1
        result = self.fetched
        extra = result + nr - self.target
        if extra > 0:
            self.target += extra
            # process_target < 0 indicates shutting down
            if self.process_target.value >= 0:
                self.process_target.value = self.target
            self.wait_event.set()
        return result

    def RemoveFromBuffer(self):
        pos = self.local_tail
        if len(self.buffer) - pos < glb_nsz:
            pos = 0
        n = pickle.loads(self.buffer[pos : pos + glb_nsz])
        if n == 0:
            pos = 0
            n = pickle.loads(self.buffer[0 : glb_nsz])
        pos += glb_nsz
        obj = pickle.loads(self.buffer[pos : pos + n])
        self.local_tail = pos + n
        return obj

    def ProcessData(self, count):
        for _i in range(count):
            obj = self.RemoveFromBuffer()
            self.process_data(obj)
        self.tail.value = self.local_tail
        self.wait_event.set()
        self.done.emit(count)

# Fetch more records bar

class FetchMoreRecordsBar():

    def __init__(self, model, parent):
        self.model = model

        self.label = QLabel("Number of records (x " + "{:,}".format(glb_chunk_sz) + ") to fetch:")
        self.label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)

        self.fetch_count = QSpinBox()
        self.fetch_count.setRange(1, 1000000)
        self.fetch_count.setValue(10)
        self.fetch_count.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)

        self.fetch = QPushButton("Go!")
        self.fetch.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
        self.fetch.released.connect(self.FetchMoreRecords)

        self.progress = QProgressBar()
        self.progress.setRange(0, 100)
        self.progress.hide()

        self.done_label = QLabel("All records fetched")
        self.done_label.hide()

        self.spacer = QLabel("")

        self.close_button = QToolButton()
        self.close_button.setIcon(parent.style().standardIcon(QStyle.SP_DockWidgetCloseButton))
        self.close_button.released.connect(self.Deactivate)

        self.hbox = QHBoxLayout()
        self.hbox.setContentsMargins(0, 0, 0, 0)

        self.hbox.addWidget(self.label)
        self.hbox.addWidget(self.fetch_count)
        self.hbox.addWidget(self.fetch)
        self.hbox.addWidget(self.spacer)
        self.hbox.addWidget(self.progress)
        self.hbox.addWidget(self.done_label)
        self.hbox.addWidget(self.close_button)

        self.bar = QWidget()
        self.bar.setLayout(self.hbox)
        self.bar.show()

        self.in_progress = False
        self.start = 0
        self.model.progress.connect(self.Progress)

        self.done = False

        if not model.HasMoreRecords():
            self.Done()

    def Widget(self):
        return self.bar

    def Activate(self):
        self.bar.show()
        self.fetch.setFocus()

    def Deactivate(self):
        self.bar.hide()

    def Enable(self, enable):
        self.fetch.setEnabled(enable)
        self.fetch_count.setEnabled(enable)

    def Busy(self):
        self.Enable(False)
        self.fetch.hide()
        self.spacer.hide()
        self.progress.show()

    def Idle(self):
        self.in_progress = False
        self.Enable(True)
        self.progress.hide()
        self.fetch.show()
        self.spacer.show()

    def Target(self):
        return self.fetch_count.value() * glb_chunk_sz

    def Done(self):
        self.done = True
        self.Idle()
        self.label.hide()
        self.fetch_count.hide()
        self.fetch.hide()
        self.spacer.hide()
        self.done_label.show()

    def Progress(self, count):
        if self.in_progress:
            if count:
                percent = ((count - self.start) * 100) / self.Target()
                if percent >= 100:
                    self.Idle()
                else:
                    self.progress.setValue(percent)
        if not count:
            # Count value of zero means no more records
            self.Done()

    def FetchMoreRecords(self):
        if self.done:
            return
        self.progress.setValue(0)
        self.Busy()
        self.in_progress = True
        self.start = self.model.FetchMoreRecords(self.Target())

# Brance data model level two item

class BranchLevelTwoItem():

    def __init__(self, row, col, text, parent_item):
        self.row = row
        self.parent_item = parent_item
        self.data = [""] * (col + 1)
        self.data[col] = text
        self.level = 2

    def getParentItem(self):
        return self.parent_item

    def getRow(self):
        return self.row

    def childCount(self):
        return 0

    def hasChildren(self):
        return False

    def getData(self, column):
        return self.data[column]

# Brance data model level one item

class BranchLevelOneItem():

    def __init__(self, glb, row, data, parent_item):
        self.glb = glb
        self.row = row
        self.parent_item = parent_item
        self.child_count = 0
        self.child_items = []
        self.data = data[1:]
        self.dbid = data[0]
        self.level = 1
        self.query_done = False
        self.br_col = len(self.data) - 1

    def getChildItem(self, row):
        return self.child_items[row]

    def getParentItem(self):
        return self.parent_item

    def getRow(self):
        return self.row

    def Select(self):
        self.query_done = True

        if not self.glb.have_disassembler:
            return

        query = QSqlQuery(self.glb.db)

        QueryExec(query, "SELECT cpu, to_dso_id, to_symbol_id, to_sym_offset, short_name, long_name, build_id, sym_start, to_ip"
                  " FROM samples"
                  " INNER JOIN dsos ON samples.to_dso_id = dsos.id"
                  " INNER JOIN symbols ON samples.to_symbol_id = symbols.id"
                  " WHERE samples.id = " + str(self.dbid))
        if not query.next():
            return
        cpu = query.value(0)
        dso = query.value(1)
        sym = query.value(2)
        if dso == 0 or sym == 0:
            return
        off = query.value(3)
        short_name = query.value(4)
        long_name = query.value(5)
        build_id = query.value(6)
        sym_start = query.value(7)
        ip = query.value(8)

        QueryExec(query, "SELECT samples.dso_id, symbol_id, sym_offset, sym_start"
                  " FROM samples"
                  " INNER JOIN symbols ON samples.symbol_id = symbols.id"
                  " WHERE samples.id > " + str(self.dbid) + " AND cpu = " + str(cpu) +
                  " ORDER BY samples.id"
                  " LIMIT 1")
        if not query.next():
            return
        if query.value(0) != dso:
            # Cannot disassemble from one dso to another
            return
        bsym = query.value(1)
        boff = query.value(2)
        bsym_start = query.value(3)
        if bsym == 0:
            return
        tot = bsym_start + boff + 1 - sym_start - off
        if tot <= 0 or tot > 16384:
            return

        inst = self.glb.disassembler.Instruction()
        f = self.glb.FileFromNamesAndBuildId(short_name, long_name, build_id)
        if not f:
            return
        mode = 0 if Is64Bit(f) else 1
        self.glb.disassembler.SetMode(inst, mode)

        buf_sz = tot + 16
        buf = create_string_buffer(tot + 16)
        f.seek(sym_start + off)
        buf.value = f.read(buf_sz)
        buf_ptr = addressof(buf)
        i = 0
        while tot > 0:
            cnt, text = self.glb.disassembler.DisassembleOne(inst, buf_ptr, buf_sz, ip)
            if cnt:
                byte_str = tohex(ip).rjust(16)
                for k in range(cnt):
                    byte_str += " %02x" % ord(buf[i])
                    i += 1
                while k < 15:
                    byte_str += "   "
                    k += 1
                self.child_items.append(BranchLevelTwoItem(0, self.br_col, byte_str + " " + text, self))
                self.child_count += 1
            else:
                return
            buf_ptr += cnt
            tot -= cnt
            buf_sz -= cnt
            ip += cnt

    def childCount(self):
        if not self.query_done:
            self.Select()
            if not self.child_count:
                return -1
        return self.child_count

    def hasChildren(self):
        if not self.query_done:
            return True
        return self.child_count > 0

    def getData(self, column):
        return self.data[column]

# Brance data model root item

class BranchRootItem():

    def __init__(self):
        self.child_count = 0
        self.child_items = []
        self.level = 0

    def getChildItem(self, row):
        return self.child_items[row]

    def getParentItem(self):
        return None

    def getRow(self):
        return 0

    def childCount(self):
        return self.child_count

    def hasChildren(self):
        return self.child_count > 0

    def getData(self, _column):
        return ""

# Calculate instructions per cycle

def CalcIPC(cyc_cnt, insn_cnt):
    if cyc_cnt and insn_cnt:
        ipc = Decimal(float(insn_cnt) / cyc_cnt)
        ipc = str(ipc.quantize(Decimal(".01"), rounding=ROUND_HALF_UP))
    else:
        ipc = "0"
    return ipc

# Branch data preparation

def BranchDataPrepBr(query, data):
    data.append(tohex(query.value(8)).rjust(16) + " " + query.value(9) + offstr(query.value(10)) +
            " (" + dsoname(query.value(11)) + ")" + " -> " +
            tohex(query.value(12)) + " " + query.value(13) + offstr(query.value(14)) +
            " (" + dsoname(query.value(15)) + ")")

def BranchDataPrepIPC(query, data):
    insn_cnt = query.value(16)
    cyc_cnt = query.value(17)
    ipc = CalcIPC(cyc_cnt, insn_cnt)
    data.append(insn_cnt)
    data.append(cyc_cnt)
    data.append(ipc)

def BranchDataPrep(query):
    data = []
    for i in range(0, 8):
        data.append(query.value(i))
    BranchDataPrepBr(query, data)
    return data

def BranchDataPrepWA(query):
    data = []
    data.append(query.value(0))
    # Workaround pyside failing to handle large integers (i.e. time) in python3 by converting to a string
    data.append("{:>19}".format(query.value(1)))
    for i in range(2, 8):
        data.append(query.value(i))
    BranchDataPrepBr(query, data)
    return data

def BranchDataWithIPCPrep(query):
    data = []
    for i in range(0, 8):
        data.append(query.value(i))
    BranchDataPrepIPC(query, data)
    BranchDataPrepBr(query, data)
    return data

def BranchDataWithIPCPrepWA(query):
    data = []
    data.append(query.value(0))
    # Workaround pyside failing to handle large integers (i.e. time) in python3 by converting to a string
    data.append("{:>19}".format(query.value(1)))
    for i in range(2, 8):
        data.append(query.value(i))
    BranchDataPrepIPC(query, data)
    BranchDataPrepBr(query, data)
    return data

# Branch data model

class BranchModel(TreeModel):

    progress = Signal(object)

    def __init__(self, glb, event_id, where_clause, parent=None):
        super(BranchModel, self).__init__(glb, None, parent)
        self.event_id = event_id
        self.more = True
        self.populated = 0
        self.have_ipc = IsSelectable(glb.db, "samples", columns = "insn_count, cyc_count")
        if self.have_ipc:
            select_ipc = ", insn_count, cyc_count"
            prep_fn = BranchDataWithIPCPrep
            prep_wa_fn = BranchDataWithIPCPrepWA
        else:
            select_ipc = ""
            prep_fn = BranchDataPrep
            prep_wa_fn = BranchDataPrepWA
        sql = ("SELECT samples.id, time, cpu, comm, pid, tid, branch_types.name,"
            " CASE WHEN in_tx = '0' THEN 'No' ELSE 'Yes' END,"
            " ip, symbols.name, sym_offset, dsos.short_name,"
            " to_ip, to_symbols.name, to_sym_offset, to_dsos.short_name"
            + select_ipc +
            " FROM samples"
            " INNER JOIN comms ON comm_id = comms.id"
            " INNER JOIN threads ON thread_id = threads.id"
            " INNER JOIN branch_types ON branch_type = branch_types.id"
            " INNER JOIN symbols ON symbol_id = symbols.id"
            " INNER JOIN symbols to_symbols ON to_symbol_id = to_symbols.id"
            " INNER JOIN dsos ON samples.dso_id = dsos.id"
            " INNER JOIN dsos AS to_dsos ON samples.to_dso_id = to_dsos.id"
            " WHERE samples.id > $$last_id$$" + where_clause +
            " AND evsel_id = " + str(self.event_id) +
            " ORDER BY samples.id"
            " LIMIT " + str(glb_chunk_sz))
        if pyside_version_1 and sys.version_info[0] == 3:
            prep = prep_fn
        else:
            prep = prep_wa_fn
        self.fetcher = SQLFetcher(glb, sql, prep, self.AddSample)
        self.fetcher.done.connect(self.Update)
        self.fetcher.Fetch(glb_chunk_sz)

    def GetRoot(self):
        return BranchRootItem()

    def columnCount(self, _parent=None):
        if self.have_ipc:
            return 11
        else:
            return 8

    def columnHeader(self, column):
        if self.have_ipc:
            return ("Time", "CPU", "Command", "PID", "TID", "Branch Type", "In Tx", "Insn Cnt", "Cyc Cnt", "IPC", "Branch")[column]
        else:
            return ("Time", "CPU", "Command", "PID", "TID", "Branch Type", "In Tx", "Branch")[column]

    def columnFont(self, column):
        if self.have_ipc:
            br_col = 10
        else:
            br_col = 7
        if column != br_col:
            return None
        return QFont("Monospace")

    def DisplayData(self, item, index):
        if item.level == 1:
            self.FetchIfNeeded(item.row)
        return item.getData(index.column())

    def AddSample(self, data):
        child = BranchLevelOneItem(self.glb, self.populated, data, self.root)
        self.root.child_items.append(child)
        self.populated += 1

    def Update(self, fetched):
        if not fetched:
            self.more = False
            self.progress.emit(0)
        child_count = self.root.child_count
        count = self.populated - child_count
        if count > 0:
            parent = QModelIndex()
            self.beginInsertRows(parent, child_count, child_count + count - 1)
            self.insertRows(child_count, count, parent)
            self.root.child_count += count
            self.endInsertRows()
            self.progress.emit(self.root.child_count)

    def FetchMoreRecords(self, count):
        current = self.root.child_count
        if self.more:
            self.fetcher.Fetch(count)
        else:
            self.progress.emit(0)
        return current

    def HasMoreRecords(self):
        return self.more

# Report Variables

class ReportVars():

    def __init__(self, name = "", where_clause = "", limit = ""):
        self.name = name
        self.where_clause = where_clause
        self.limit = limit

    def UniqueId(self):
        return str(self.where_clause + ";" + self.limit)

# Branch window

class BranchWindow(QMdiSubWindow):

    def __init__(self, glb, event_id, report_vars, parent=None):
        super(BranchWindow, self).__init__(parent)

        model_name = "Branch Events " + str(event_id) +  " " + report_vars.UniqueId()

        self.model = LookupCreateModel(model_name, lambda: BranchModel(glb, event_id, report_vars.where_clause))

        self.view = QTreeView()
        self.view.setUniformRowHeights(True)
        self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
        self.view.CopyCellsToClipboard = CopyTreeCellsToClipboard
        self.view.setModel(self.model)

        self.ResizeColumnsToContents()

        self.context_menu = TreeContextMenu(self.view)

        self.find_bar = FindBar(self, self, True)

        self.finder = ChildDataItemFinder(self.model.root)

        self.fetch_bar = FetchMoreRecordsBar(self.model, self)

        self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())

        self.setWidget(self.vbox.Widget())

        AddSubWindow(glb.mainwindow.mdi_area, self, report_vars.name + " Branch Events")

    def ResizeColumnToContents(self, column, n):
        # Using the view's resizeColumnToContents() here is extrememly slow
        # so implement a crude alternative
        mm = "MM" if column else "MMMM"
        font = self.view.font()
        metrics = QFontMetrics(font)
        max_w = 0
        for row in range(n):
            val = self.model.root.child_items[row].data[column]
            width = metrics.width(str(val) + mm)
            max_w = width if width > max_w else max_w
        val = self.model.columnHeader(column)
        width = metrics.width(str(val) + mm)
        max_w = width if width > max_w else max_w
        self.view.setColumnWidth(column, max_w)

    def ResizeColumnsToContents(self):
        n = min(self.model.root.child_count, 100)
        if n < 1:
            # No data yet, so connect a signal to notify when there is
            self.model.rowsInserted.connect(self.UpdateColumnWidths)
            return
        columns = self.model.columnCount()
        for i in range(columns):
            self.ResizeColumnToContents(i, n)

    def UpdateColumnWidths(self, *_x):
        # This only needs to be done once, so disconnect the signal now
        self.model.rowsInserted.disconnect(self.UpdateColumnWidths)
        self.ResizeColumnsToContents()

    def Find(self, value, direction, pattern, context):
        self.view.setFocus()
        self.find_bar.Busy()
        self.finder.Find(value, direction, pattern, context, self.FindDone)

    def FindDone(self, row):
        self.find_bar.Idle()
        if row >= 0:
            self.view.setCurrentIndex(self.model.index(row, 0, QModelIndex()))
        else:
            self.find_bar.NotFound()

# Line edit data item

class LineEditDataItem(object):

    def __init__(self, glb, label, placeholder_text, parent, item_id = "", default = ""):
        self.glb = glb
        self.label = label
        self.placeholder_text = placeholder_text
        self.parent = parent
        self.id = item_id

        self.value = default

        self.widget = QLineEdit(default)
        self.widget.editingFinished.connect(self.Validate)
        self.widget.textChanged.connect(self.Invalidate)
        self.red = False
        self.error = ""
        self.validated = True

        if placeholder_text:
            self.widget.setPlaceholderText(placeholder_text)

    def TurnTextRed(self):
        if not self.red:
            palette = QPalette()
            palette.setColor(QPalette.Text,Qt.red)
            self.widget.setPalette(palette)
            self.red = True

    def TurnTextNormal(self):
        if self.red:
            palette = QPalette()
            self.widget.setPalette(palette)
            self.red = False

    def InvalidValue(self, value):
        self.value = ""
        self.TurnTextRed()
        self.error = self.label + " invalid value '" + value + "'"
        self.parent.ShowMessage(self.error)

    def Invalidate(self):
        self.validated = False

    def DoValidate(self, input_string):
        self.value = input_string.strip()

    def Validate(self):
        self.validated = True
        self.error = ""
        self.TurnTextNormal()
        self.parent.ClearMessage()
        input_string = self.widget.text()
        if not len(input_string.strip()):
            self.value = ""
            return
        self.DoValidate(input_string)

    def IsValid(self):
        if not self.validated:
            self.Validate()
        if len(self.error):
            self.parent.ShowMessage(self.error)
            return False
        return True

    def IsNumber(self, value):
        try:
            x = int(value)
        except ValueError:
            x = 0
        return str(x) == value

# Non-negative integer ranges dialog data item

class NonNegativeIntegerRangesDataItem(LineEditDataItem):

    def __init__(self, glb, label, placeholder_text, column_name, parent):
        super(NonNegativeIntegerRangesDataItem, self).__init__(glb, label, placeholder_text, parent)

        self.column_name = column_name

    def DoValidate(self, input_string):
        singles = []
        ranges = []
        for value in [x.strip() for x in input_string.split(",")]:
            if "-" in value:
                vrange = value.split("-")
                if len(vrange) != 2 or not self.IsNumber(vrange[0]) or not self.IsNumber(vrange[1]):
                    return self.InvalidValue(value)
                ranges.append(vrange)
            else:
                if not self.IsNumber(value):
                    return self.InvalidValue(value)
                singles.append(value)
        ranges = [("(" + self.column_name + " >= " + r[0] + " AND " + self.column_name + " <= " + r[1] + ")") for r in ranges]
        if len(singles):
            ranges.append(self.column_name + " IN (" + ",".join(singles) + ")")
        self.value = " OR ".join(ranges)

# Positive integer dialog data item

class PositiveIntegerDataItem(LineEditDataItem):

    def DoValidate(self, input_string):
        if not self.IsNumber(input_string.strip()):
            return self.InvalidValue(input_string)
        value = int(input_string.strip())
        if value <= 0:
            return self.InvalidValue(input_string)
        self.value = str(value)

# Dialog data item converted and validated using a SQL table

class SQLTableDataItem(LineEditDataItem):

    def __init__(self, glb, label, placeholder_text, table_name, match_column, column_name1, column_name2, parent):
        super(SQLTableDataItem, self).__init__(glb, label, placeholder_text, parent)

        self.table_name = table_name
        self.match_column = match_column
        self.column_name1 = column_name1
        self.column_name2 = column_name2

    def ValueToIds(self, value):
        ids = []
        query = QSqlQuery(self.glb.db)
        stmt = "SELECT id FROM " + self.table_name + " WHERE " + self.match_column + " = '" + value + "'"
        ret = query.exec_(stmt)
        if ret:
            while query.next():
                ids.append(str(query.value(0)))
        return ids

    def DoValidate(self, input_string):
        all_ids = []
        for value in [x.strip() for x in input_string.split(",")]:
            ids = self.ValueToIds(value)
            if len(ids):
                all_ids.extend(ids)
            else:
                return self.InvalidValue(value)
        self.value = self.column_name1 + " IN (" + ",".join(all_ids) + ")"
        if self.column_name2:
            self.value = "( " + self.value + " OR " + self.column_name2 + " IN (" + ",".join(all_ids) + ") )"

# Sample time ranges dialog data item converted and validated using 'samples' SQL table

class SampleTimeRangesDataItem(LineEditDataItem):

    def __init__(self, glb, label, placeholder_text, column_name, parent):
        self.column_name = column_name

        self.last_id = 0
        self.first_time = 0
        self.last_time = 2 ** 64

        query = QSqlQuery(glb.db)
        QueryExec(query, "SELECT id, time FROM samples ORDER BY id DESC LIMIT 1")
        if query.next():
            self.last_id = int(query.value(0))
        self.first_time = int(glb.HostStartTime())
        self.last_time = int(glb.HostFinishTime())
        if placeholder_text:
            placeholder_text += ", between " + str(self.first_time) + " and " + str(self.last_time)

        super(SampleTimeRangesDataItem, self).__init__(glb, label, placeholder_text, parent)

    def IdBetween(self, query, lower_id, higher_id, order):
        QueryExec(query, "SELECT id FROM samples WHERE id > " + str(lower_id) + " AND id < " + str(higher_id) + " ORDER BY id " + order + " LIMIT 1")
        if query.next():
            return True, int(query.value(0))
        else:
            return False, 0

    def BinarySearchTime(self, lower_id, higher_id, target_time, get_floor):
        query = QSqlQuery(self.glb.db)
        while True:
            next_id = int((lower_id + higher_id) / 2)
            QueryExec(query, "SELECT time FROM samples WHERE id = " + str(next_id))
            if not query.next():
                ok, dbid = self.IdBetween(query, lower_id, next_id, "DESC")
                if not ok:
                    ok, dbid = self.IdBetween(query, next_id, higher_id, "")
                    if not ok:
                        return str(higher_id)
                next_id = dbid
                QueryExec(query, "SELECT time FROM samples WHERE id = " + str(next_id))
            next_time = int(query.value(0))
            if get_floor:
                if target_time > next_time:
                    lower_id = next_id
                else:
                    higher_id = next_id
                if higher_id <= lower_id + 1:
                    return str(higher_id)
            else:
                if target_time >= next_time:
                    lower_id = next_id
                else:
                    higher_id = next_id
                if higher_id <= lower_id + 1:
                    return str(lower_id)

    def ConvertRelativeTime(self, val):
        mult = 1
        suffix = val[-2:]
        if suffix == "ms":
            mult = 1000000
        elif suffix == "us":
            mult = 1000
        elif suffix == "ns":
            mult = 1
        else:
            return val
        val = val[:-2].strip()
        if not self.IsNumber(val):
            return val
        val = int(val) * mult
        if val >= 0:
            val += self.first_time
        else:
            val += self.last_time
        return str(val)

    def ConvertTimeRange(self, vrange):
        if vrange[0] == "":
            vrange[0] = str(self.first_time)
        if vrange[1] == "":
            vrange[1] = str(self.last_time)
        vrange[0] = self.ConvertRelativeTime(vrange[0])
        vrange[1] = self.ConvertRelativeTime(vrange[1])
        if not self.IsNumber(vrange[0]) or not self.IsNumber(vrange[1]):
            return False
        beg_range = max(int(vrange[0]), self.first_time)
        end_range = min(int(vrange[1]), self.last_time)
        if beg_range > self.last_time or end_range < self.first_time:
            return False
        vrange[0] = self.BinarySearchTime(0, self.last_id, beg_range, True)
        vrange[1] = self.BinarySearchTime(1, self.last_id + 1, end_range, False)
        return True

    def AddTimeRange(self, value, ranges):
        n = value.count("-")
        if n == 1:
            pass
        elif n == 2:
            if value.split("-")[1].strip() == "":
                n = 1
        elif n == 3:
            n = 2
        else:
            return False
        pos = findnth(value, "-", n)
        vrange = [value[:pos].strip() ,value[pos+1:].strip()]
        if self.ConvertTimeRange(vrange):
            ranges.append(vrange)
            return True
        return False

    def DoValidate(self, input_string):
        ranges = []
        for value in [x.strip() for x in input_string.split(",")]:
            if not self.AddTimeRange(value, ranges):
                return self.InvalidValue(value)
        ranges = [("(" + self.column_name + " >= " + r[0] + " AND " + self.column_name + " <= " + r[1] + ")") for r in ranges]
        self.value = " OR ".join(ranges)

# Report Dialog Base

class ReportDialogBase(QDialog):

    def __init__(self, glb, title, items, partial, parent=None):
        super(ReportDialogBase, self).__init__(parent)

        self.glb = glb

        self.report_vars = ReportVars()

        self.setWindowTitle(title)
        self.setMinimumWidth(600)

        self.data_items = [x(glb, self) for x in items]

        self.partial = partial

        self.grid = QGridLayout()

        for row in range(len(self.data_items)):
            self.grid.addWidget(QLabel(self.data_items[row].label), row, 0)
            self.grid.addWidget(self.data_items[row].widget, row, 1)

        self.status = QLabel()

        self.ok_button = QPushButton("Ok", self)
        self.ok_button.setDefault(True)
        self.ok_button.released.connect(self.Ok)
        self.ok_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)

        self.cancel_button = QPushButton("Cancel", self)
        self.cancel_button.released.connect(self.reject)
        self.cancel_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)

        self.hbox = QHBoxLayout()
        #self.hbox.addStretch()
        self.hbox.addWidget(self.status)
        self.hbox.addWidget(self.ok_button)
        self.hbox.addWidget(self.cancel_button)

        self.vbox = QVBoxLayout()
        self.vbox.addLayout(self.grid)
        self.vbox.addLayout(self.hbox)

        self.setLayout(self.vbox)

    def Ok(self):
        rep_vars = self.report_vars
        for d in self.data_items:
            if d.id == "REPORTNAME":
                rep_vars.name = d.value
        if not rep_vars.name:
            self.ShowMessage("Report name is required")
            return
        for d in self.data_items:
            if not d.IsValid():
                return
        for d in self.data_items[1:]:
            if d.id == "LIMIT":
                rep_vars.limit = d.value
            elif len(d.value):
                if len(rep_vars.where_clause):
                    rep_vars.where_clause += " AND "
                rep_vars.where_clause += d.value
        if len(rep_vars.where_clause):
            if self.partial:
                rep_vars.where_clause = " AND ( " + rep_vars.where_clause + " ) "
            else:
                rep_vars.where_clause = " WHERE " + rep_vars.where_clause + " "
        self.accept()

    def ShowMessage(self, msg):
        self.status.setText("<font color=#FF0000>" + msg)

    def ClearMessage(self):
        self.status.setText("")

# Selected branch report creation dialog

class SelectedBranchDialog(ReportDialogBase):

    def __init__(self, glb, parent=None):
        title = "Selected Branches"
        items = (lambda g, p: LineEditDataItem(g, "Report name:", "Enter a name to appear in the window title bar", p, "REPORTNAME"),
             lambda g, p: SampleTimeRangesDataItem(g, "Time ranges:", "Enter time ranges", "samples.id", p),
             lambda g, p: NonNegativeIntegerRangesDataItem(g, "CPUs:", "Enter CPUs or ranges e.g. 0,5-6", "cpu", p),
             lambda g, p: SQLTableDataItem(g, "Commands:", "Only branches with these commands will be included", "comms", "comm", "comm_id", "", p),
             lambda g, p: SQLTableDataItem(g, "PIDs:", "Only branches with these process IDs will be included", "threads", "pid", "thread_id", "", p),
             lambda g, p: SQLTableDataItem(g, "TIDs:", "Only branches with these thread IDs will be included", "threads", "tid", "thread_id", "", p),
             lambda g, p: SQLTableDataItem(g, "DSOs:", "Only branches with these DSOs will be included", "dsos", "short_name", "samples.dso_id", "to_dso_id", p),
             lambda g, p: SQLTableDataItem(g, "Symbols:", "Only branches with these symbols will be included", "symbols", "name", "symbol_id", "to_symbol_id", p),
             lambda g, p: LineEditDataItem(g, "Raw SQL clause: ", "Enter a raw SQL WHERE clause", p))
        super(SelectedBranchDialog, self).__init__(glb, title, items, True, parent)

# Event list

def GetEventList(db):
    events = []
    query = QSqlQuery(db)
    QueryExec(query, "SELECT name FROM selected_events WHERE id > 0 ORDER BY id")
    while query.next():
        events.append(query.value(0))
    return events

# Is a table selectable

def IsSelectable(db, table, sql = "", columns = "*"):
    query = QSqlQuery(db)
    try:
        QueryExec(query, "SELECT " + columns + " FROM " + table + " " + sql + " LIMIT 1")
    except RuntimeError:
        return False
    return True

# SQL table data model item

class SQLTableItem():

    def __init__(self, row, data):
        self.row = row
        self.data = data

    def getData(self, column):
        return self.data[column]

# SQL table data model

class SQLTableModel(TableModel):

    progress = Signal(object)

    def __init__(self, glb, sql, column_headers, parent=None):
        super(SQLTableModel, self).__init__(parent)
        self.glb = glb
        self.more = True
        self.populated = 0
        self.column_headers = column_headers
        self.fetcher = SQLFetcher(glb, sql, lambda x, y=len(column_headers): self.SQLTableDataPrep(x, y), self.AddSample)
        self.fetcher.done.connect(self.Update)
        self.fetcher.Fetch(glb_chunk_sz)

    def DisplayData(self, item, index):
        self.FetchIfNeeded(item.row)
        return item.getData(index.column())

    def AddSample(self, data):
        child = SQLTableItem(self.populated, data)
        self.child_items.append(child)
        self.populated += 1

    def Update(self, fetched):
        if not fetched:
            self.more = False
            self.progress.emit(0)
        child_count = self.child_count
        count = self.populated - child_count
        if count > 0:
            parent = QModelIndex()
            self.beginInsertRows(parent, child_count, child_count + count - 1)
            self.insertRows(child_count, count, parent)
            self.child_count += count
            self.endInsertRows()
            self.progress.emit(self.child_count)

    def FetchMoreRecords(self, count):
        current = self.child_count
        if self.more:
            self.fetcher.Fetch(count)
        else:
            self.progress.emit(0)
        return current

    def HasMoreRecords(self):
        return self.more

    def columnCount(self, _parent=None):
        return len(self.column_headers)

    def columnHeader(self, column):
        return self.column_headers[column]

    def SQLTableDataPrep(self, query, count):
        data = []
        for i in range(count):
            data.append(query.value(i))
        return data

# SQL automatic table data model

class SQLAutoTableModel(SQLTableModel):

    def __init__(self, glb, table_name, parent=None):
        sql = "SELECT * FROM " + table_name + " WHERE id > $$last_id$$ ORDER BY id LIMIT " + str(glb_chunk_sz)
        if table_name == "comm_threads_view":
            # For now, comm_threads_view has no id column
            sql = "SELECT * FROM " + table_name + " WHERE comm_id > $$last_id$$ ORDER BY comm_id LIMIT " + str(glb_chunk_sz)
        column_headers = []
        query = QSqlQuery(glb.db)
        if glb.dbref.is_sqlite3:
            QueryExec(query, "PRAGMA table_info(" + table_name + ")")
            while query.next():
                column_headers.append(query.value(1))
            if table_name == "sqlite_master":
                sql = "SELECT * FROM " + table_name
        else:
            if table_name[:19] == "information_schema.":
                sql = "SELECT * FROM " + table_name
                select_table_name = table_name[19:]
                schema = "information_schema"
            else:
                select_table_name = table_name
                schema = "public"
            QueryExec(query, "SELECT column_name FROM information_schema.columns WHERE table_schema = '" + schema + "' and table_name = '" + select_table_name + "'")
            while query.next():
                column_headers.append(query.value(0))
        if pyside_version_1 and sys.version_info[0] == 3:
            if table_name == "samples_view":
                self.SQLTableDataPrep = self.samples_view_DataPrep
            if table_name == "samples":
                self.SQLTableDataPrep = self.samples_DataPrep
        super(SQLAutoTableModel, self).__init__(glb, sql, column_headers, parent)

    def samples_view_DataPrep(self, query, count):
        data = []
        data.append(query.value(0))
        # Workaround pyside failing to handle large integers (i.e. time) in python3 by converting to a string
        data.append("{:>19}".format(query.value(1)))
        for i in range(2, count):
            data.append(query.value(i))
        return data

    def samples_DataPrep(self, query, count):
        data = []
        for i in range(9):
            data.append(query.value(i))
        # Workaround pyside failing to handle large integers (i.e. time) in python3 by converting to a string
        data.append("{:>19}".format(query.value(9)))
        for i in range(10, count):
            data.append(query.value(i))
        return data

# Base class for custom ResizeColumnsToContents

class ResizeColumnsToContentsBase(QObject):

    def __init__(self, parent=None):
        super(ResizeColumnsToContentsBase, self).__init__(parent)

    def ResizeColumnToContents(self, column, n):
        # Using the view's resizeColumnToContents() here is extrememly slow
        # so implement a crude alternative
        font = self.view.font()
        metrics = QFontMetrics(font)
        max_w = 0
        for row in range(n):
            val = self.data_model.child_items[row].data[column]
            width = metrics.width(str(val) + "MM")
            max_w = width if width > max_w else max_w
        val = self.data_model.columnHeader(column)
        width = metrics.width(str(val) + "MM")
        max_w = width if width > max_w else max_w
        self.view.setColumnWidth(column, max_w)

    def ResizeColumnsToContents(self):
        n = min(self.data_model.child_count, 100)
        if n < 1:
            # No data yet, so connect a signal to notify when there is
            self.data_model.rowsInserted.connect(self.UpdateColumnWidths)
            return
        columns = self.data_model.columnCount()
        for i in range(columns):
            self.ResizeColumnToContents(i, n)

    def UpdateColumnWidths(self, *_x):
        # This only needs to be done once, so disconnect the signal now
        self.data_model.rowsInserted.disconnect(self.UpdateColumnWidths)
        self.ResizeColumnsToContents()

# Convert value to CSV

def ToCSValue(val):
    if '"' in val:
        val = val.replace('"', '""')
    if "," in val or '"' in val:
        val = '"' + val + '"'
    return val

# Key to sort table model indexes by row / column, assuming fewer than 1000 columns

glb_max_cols = 1000

def RowColumnKey(a):
    return a.row() * glb_max_cols + a.column()

# Copy selected table cells to clipboard

def CopyTableCellsToClipboard(view, as_csv=False, with_hdr=False):
    indexes = sorted(view.selectedIndexes(), key=RowColumnKey)
    idx_cnt = len(indexes)
    if not idx_cnt:
        return
    if idx_cnt == 1:
        with_hdr=False
    min_row = indexes[0].row()
    max_row = indexes[0].row()
    min_col = indexes[0].column()
    max_col = indexes[0].column()
    for i in indexes:
        min_row = min(min_row, i.row())
        max_row = max(max_row, i.row())
        min_col = min(min_col, i.column())
        max_col = max(max_col, i.column())
    if max_col > glb_max_cols:
        raise RuntimeError("glb_max_cols is too low")
    max_width = [0] * (1 + max_col - min_col)
    for i in indexes:
        c = i.column() - min_col
        max_width[c] = max(max_width[c], len(str(i.data())))
    text = ""
    pad = ""
    sep = ""
    if with_hdr:
        model = indexes[0].model()
        for col in range(min_col, max_col + 1):
            val = model.headerData(col, Qt.Horizontal, Qt.DisplayRole)
            if as_csv:
                text += sep + ToCSValue(val)
                sep = ","
            else:
                c = col - min_col
                max_width[c] = max(max_width[c], len(val))
                width = max_width[c]
                align = model.headerData(col, Qt.Horizontal, Qt.TextAlignmentRole)
                if align & Qt.AlignRight:
                    val = val.rjust(width)
                text += pad + sep + val
                pad = " " * (width - len(val))
                sep = "  "
        text += "\n"
        pad = ""
        sep = ""
    last_row = min_row
    for i in indexes:
        if i.row() > last_row:
            last_row = i.row()
            text += "\n"
            pad = ""
            sep = ""
        if as_csv:
            text += sep + ToCSValue(str(i.data()))
            sep = ","
        else:
            width = max_width[i.column() - min_col]
            if i.data(Qt.TextAlignmentRole) & Qt.AlignRight:
                val = str(i.data()).rjust(width)
            else:
                val = str(i.data())
            text += pad + sep + val
            pad = " " * (width - len(val))
            sep = "  "
    QApplication.clipboard().setText(text)

def CopyTreeCellsToClipboard(view, as_csv=False, with_hdr=False):
    indexes = view.selectedIndexes()
    if not len(indexes):
        return

    selection = view.selectionModel()

    first = None
    for i in indexes:
        above = view.indexAbove(i)
        if not selection.isSelected(above):
            first = i
            break

    if first is None:
        raise RuntimeError("CopyTreeCellsToClipboard internal error")

    model = first.model()
    row_cnt = 0
    col_cnt = model.columnCount(first)
    max_width = [0] * col_cnt

    indent_sz = 2
    indent_str = " " * indent_sz

    expanded_mark_sz = 2
    if sys.version_info[0] == 3:
        expanded_mark = "\u25BC "
        not_expanded_mark = "\u25B6 "
    else:
        expanded_mark = chr(0x25BC) + " "
        not_expanded_mark = chr(0x25B6) + " "
    leaf_mark = "  "

    if not as_csv:
        pos = first
        while True:
            row_cnt += 1
            row = pos.row()
            for c in range(col_cnt):
                i = pos.sibling(row, c)
                if c:
                    n = len(str(i.data()))
                else:
                    n = len(str(i.data()).strip())
                    n += (i.internalPointer().level - 1) * indent_sz
                    n += expanded_mark_sz
                max_width[c] = max(max_width[c], n)
            pos = view.indexBelow(pos)
            if not selection.isSelected(pos):
                break

    text = ""
    pad = ""
    sep = ""
    if with_hdr:
        for c in range(col_cnt):
            val = model.headerData(c, Qt.Horizontal, Qt.DisplayRole).strip()
            if as_csv:
                text += sep + ToCSValue(val)
                sep = ","
            else:
                max_width[c] = max(max_width[c], len(val))
                width = max_width[c]
                align = model.headerData(c, Qt.Horizontal, Qt.TextAlignmentRole)
                if align & Qt.AlignRight:
                    val = val.rjust(width)
                text += pad + sep + val
                pad = " " * (width - len(val))
                sep = "   "
        text += "\n"
        pad = ""
        sep = ""

    pos = first
    while True:
        row = pos.row()
        for c in range(col_cnt):
            i = pos.sibling(row, c)
            val = str(i.data())
            if not c:
                if model.hasChildren(i):
                    if view.isExpanded(i):
                        mark = expanded_mark
                    else:
                        mark = not_expanded_mark
                else:
                    mark = leaf_mark
                val = indent_str * (i.internalPointer().level - 1) + mark + val.strip()
            if as_csv:
                text += sep + ToCSValue(val)
                sep = ","
            else:
                width = max_width[c]
                if c and i.data(Qt.TextAlignmentRole) & Qt.AlignRight:
                    val = val.rjust(width)
                text += pad + sep + val
                pad = " " * (width - len(val))
                sep = "   "
        pos = view.indexBelow(pos)
        if not selection.isSelected(pos):
            break
        text = text.rstrip() + "\n"
        pad = ""
        sep = ""

    QApplication.clipboard().setText(text)

def CopyCellsToClipboard(view, as_csv=False, with_hdr=False):
    view.CopyCellsToClipboard(view, as_csv, with_hdr)

def CopyCellsToClipboardHdr(view):
    CopyCellsToClipboard(view, False, True)

def CopyCellsToClipboardCSV(view):
    CopyCellsToClipboard(view, True, True)

# Context menu

class ContextMenu(object):

    def __init__(self, view):
        self.view = view
        self.view.setContextMenuPolicy(Qt.CustomContextMenu)
        self.view.customContextMenuRequested.connect(self.ShowContextMenu)

    def ShowContextMenu(self, pos):
        menu = QMenu(self.view)
        self.AddActions(menu)
        menu.exec_(self.view.mapToGlobal(pos))

    def AddCopy(self, menu):
        menu.addAction(CreateAction("&Copy selection", "Copy to clipboard", lambda: CopyCellsToClipboardHdr(self.view), self.view))
        menu.addAction(CreateAction("Copy selection as CS&V", "Copy to clipboard as CSV", lambda: CopyCellsToClipboardCSV(self.view), self.view))

    def AddActions(self, menu):
        self.AddCopy(menu)

class TreeContextMenu(ContextMenu):

    def AddActions(self, menu):
        i = self.view.currentIndex()
        text = str(i.data()).strip()
        if len(text):
            menu.addAction(CreateAction('Copy "' + text + '"', "Copy to clipboard", lambda: QApplication.clipboard().setText(text), self.view))
        self.AddCopy(menu)

# Table window

class TableWindow(QMdiSubWindow, ResizeColumnsToContentsBase):

    def __init__(self, glb, table_name, parent=None):
        super(TableWindow, self).__init__(parent)

        self.data_model = LookupCreateModel(table_name + " Table", lambda: SQLAutoTableModel(glb, table_name))

        self.model = QSortFilterProxyModel()
        self.model.setSourceModel(self.data_model)

        self.view = QTableView()
        self.view.setModel(self.model)
        self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
        self.view.verticalHeader().setVisible(False)
        self.view.sortByColumn(-1, Qt.AscendingOrder)
        self.view.setSortingEnabled(True)
        self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
        self.view.CopyCellsToClipboard = CopyTableCellsToClipboard

        self.ResizeColumnsToContents()

        self.context_menu = ContextMenu(self.view)

        self.find_bar = FindBar(self, self, True)

        self.finder = ChildDataItemFinder(self.data_model)

        self.fetch_bar = FetchMoreRecordsBar(self.data_model, self)

        self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())

        self.setWidget(self.vbox.Widget())

        AddSubWindow(glb.mainwindow.mdi_area, self, table_name + " Table")

    def Find(self, value, direction, pattern, context):
        self.view.setFocus()
        self.find_bar.Busy()
        self.finder.Find(value, direction, pattern, context, self.FindDone)

    def FindDone(self, row):
        self.find_bar.Idle()
        if row >= 0:
            self.view.setCurrentIndex(self.model.mapFromSource(self.data_model.index(row, 0, QModelIndex())))
        else:
            self.find_bar.NotFound()

# Table list

def GetTableList(glb):
    tables = []
    query = QSqlQuery(glb.db)
    if glb.dbref.is_sqlite3:
        QueryExec(query, "SELECT name FROM sqlite_master WHERE type IN ( 'table' , 'view' ) ORDER BY name")
    else:
        QueryExec(query, "SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND table_type IN ( 'BASE TABLE' , 'VIEW' ) ORDER BY table_name")
    while query.next():
        tables.append(query.value(0))
    if glb.dbref.is_sqlite3:
        tables.append("sqlite_master")
    else:
        tables.append("information_schema.tables")
        tables.append("information_schema.views")
        tables.append("information_schema.columns")
    return tables

# Top Calls data model

class TopCallsModel(SQLTableModel):

    def __init__(self, glb, report_vars, parent=None):
        text = ""
        if not glb.dbref.is_sqlite3:
            text = "::text"
        limit = ""
        if len(report_vars.limit):
            limit = " LIMIT " + report_vars.limit
        sql = ("SELECT comm, pid, tid, name,"
            " CASE"
            " WHEN (short_name = '[kernel.kallsyms]') THEN '[kernel]'" + text +
            " ELSE short_name"
            " END AS dso,"
            " call_time, return_time, (return_time - call_time) AS elapsed_time, branch_count, "
            " CASE"
            " WHEN (calls.flags = 1) THEN 'no call'" + text +
            " WHEN (calls.flags = 2) THEN 'no return'" + text +
            " WHEN (calls.flags = 3) THEN 'no call/return'" + text +
            " ELSE ''" + text +
            " END AS flags"
            " FROM calls"
            " INNER JOIN call_paths ON calls.call_path_id = call_paths.id"
            " INNER JOIN symbols ON call_paths.symbol_id = symbols.id"
            " INNER JOIN dsos ON symbols.dso_id = dsos.id"
            " INNER JOIN comms ON calls.comm_id = comms.id"
            " INNER JOIN threads ON calls.thread_id = threads.id" +
            report_vars.where_clause +
            " ORDER BY elapsed_time DESC" +
            limit
            )
        column_headers = ("Command", "PID", "TID", "Symbol", "Object", "Call Time", "Return Time", "Elapsed Time (ns)", "Branch Count", "Flags")
        self.alignment = (Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignLeft, Qt.AlignRight, Qt.AlignRight, Qt.AlignLeft)
        super(TopCallsModel, self).__init__(glb, sql, column_headers, parent)

    def columnAlignment(self, column):
        return self.alignment[column]

# Top Calls report creation dialog

class TopCallsDialog(ReportDialogBase):

    def __init__(self, glb, parent=None):
        title = "Top Calls by Elapsed Time"
        items = (lambda g, p: LineEditDataItem(g, "Report name:", "Enter a name to appear in the window title bar", p, "REPORTNAME"),
             lambda g, p: SQLTableDataItem(g, "Commands:", "Only calls with these commands will be included", "comms", "comm", "comm_id", "", p),
             lambda g, p: SQLTableDataItem(g, "PIDs:", "Only calls with these process IDs will be included", "threads", "pid", "thread_id", "", p),
             lambda g, p: SQLTableDataItem(g, "TIDs:", "Only calls with these thread IDs will be included", "threads", "tid", "thread_id", "", p),
             lambda g, p: SQLTableDataItem(g, "DSOs:", "Only calls with these DSOs will be included", "dsos", "short_name", "dso_id", "", p),
             lambda g, p: SQLTableDataItem(g, "Symbols:", "Only calls with these symbols will be included", "symbols", "name", "symbol_id", "", p),
             lambda g, p: LineEditDataItem(g, "Raw SQL clause: ", "Enter a raw SQL WHERE clause", p),
             lambda g, p: PositiveIntegerDataItem(g, "Record limit:", "Limit selection to this number of records", p, "LIMIT", "100"))
        super(TopCallsDialog, self).__init__(glb, title, items, False, parent)

# Top Calls window

class TopCallsWindow(QMdiSubWindow, ResizeColumnsToContentsBase):

    def __init__(self, glb, report_vars, parent=None):
        super(TopCallsWindow, self).__init__(parent)

        self.data_model = LookupCreateModel("Top Calls " + report_vars.UniqueId(), lambda: TopCallsModel(glb, report_vars))
        self.model = self.data_model

        self.view = QTableView()
        self.view.setModel(self.model)
        self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
        self.view.verticalHeader().setVisible(False)
        self.view.setSelectionMode(QAbstractItemView.ContiguousSelection)
        self.view.CopyCellsToClipboard = CopyTableCellsToClipboard

        self.context_menu = ContextMenu(self.view)

        self.ResizeColumnsToContents()

        self.find_bar = FindBar(self, self, True)

        self.finder = ChildDataItemFinder(self.model)

        self.fetch_bar = FetchMoreRecordsBar(self.data_model, self)

        self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())

        self.setWidget(self.vbox.Widget())

        AddSubWindow(glb.mainwindow.mdi_area, self, report_vars.name)

    def Find(self, value, direction, pattern, context):
        self.view.setFocus()
        self.find_bar.Busy()
        self.finder.Find(value, direction, pattern, context, self.FindDone)

    def FindDone(self, row):
        self.find_bar.Idle()
        if row >= 0:
            self.view.setCurrentIndex(self.model.index(row, 0, QModelIndex()))
        else:
            self.find_bar.NotFound()

# Action Definition

def CreateAction(label, tip, callback, parent=None, shortcut=None):
    action = QAction(label, parent)
    if shortcut != None:
        action.setShortcuts(shortcut)
    action.setStatusTip(tip)
    action.triggered.connect(callback)
    return action

# Typical application actions

def CreateExitAction(app, parent=None):
    return CreateAction("&Quit", "Exit the application", app.closeAllWindows, parent, QKeySequence.Quit)

# Typical MDI actions

def CreateCloseActiveWindowAction(mdi_area):
    return CreateAction("Cl&ose", "Close the active window", mdi_area.closeActiveSubWindow, mdi_area)

def CreateCloseAllWindowsAction(mdi_area):
    return CreateAction("Close &All", "Close all the windows", mdi_area.closeAllSubWindows, mdi_area)

def CreateTileWindowsAction(mdi_area):
    return CreateAction("&Tile", "Tile the windows", mdi_area.tileSubWindows, mdi_area)

def CreateCascadeWindowsAction(mdi_area):
    return CreateAction("&Cascade", "Cascade the windows", mdi_area.cascadeSubWindows, mdi_area)

def CreateNextWindowAction(mdi_area):
    return CreateAction("Ne&xt", "Move the focus to the next window", mdi_area.activateNextSubWindow, mdi_area, QKeySequence.NextChild)

def CreatePreviousWindowAction(mdi_area):
    return CreateAction("Pre&vious", "Move the focus to the previous window", mdi_area.activatePreviousSubWindow, mdi_area, QKeySequence.PreviousChild)

# Typical MDI window menu

class WindowMenu():

    def __init__(self, mdi_area, menu):
        self.mdi_area = mdi_area
        self.window_menu = menu.addMenu("&Windows")
        self.close_active_window = CreateCloseActiveWindowAction(mdi_area)
        self.close_all_windows = CreateCloseAllWindowsAction(mdi_area)
        self.tile_windows = CreateTileWindowsAction(mdi_area)
        self.cascade_windows = CreateCascadeWindowsAction(mdi_area)
        self.next_window = CreateNextWindowAction(mdi_area)
        self.previous_window = CreatePreviousWindowAction(mdi_area)
        self.window_menu.aboutToShow.connect(self.Update)

    def Update(self):
        self.window_menu.clear()
        sub_window_count = len(self.mdi_area.subWindowList())
        have_sub_windows = sub_window_count != 0
        self.close_active_window.setEnabled(have_sub_windows)
        self.close_all_windows.setEnabled(have_sub_windows)
        self.tile_windows.setEnabled(have_sub_windows)
        self.cascade_windows.setEnabled(have_sub_windows)
        self.next_window.setEnabled(have_sub_windows)
        self.previous_window.setEnabled(have_sub_windows)
        self.window_menu.addAction(self.close_active_window)
        self.window_menu.addAction(self.close_all_windows)
        self.window_menu.addSeparator()
        self.window_menu.addAction(self.tile_windows)
        self.window_menu.addAction(self.cascade_windows)
        self.window_menu.addSeparator()
        self.window_menu.addAction(self.next_window)
        self.window_menu.addAction(self.previous_window)
        if sub_window_count == 0:
            return
        self.window_menu.addSeparator()
        nr = 1
        for sub_window in self.mdi_area.subWindowList():
            label = str(nr) + " " + sub_window.name
            if nr < 10:
                label = "&" + label
            action = self.window_menu.addAction(label)
            action.setCheckable(True)
            action.setChecked(sub_window == self.mdi_area.activeSubWindow())
            action.triggered.connect(lambda a=None,x=nr: self.setActiveSubWindow(x))
            self.window_menu.addAction(action)
            nr += 1

    def setActiveSubWindow(self, nr):
        self.mdi_area.setActiveSubWindow(self.mdi_area.subWindowList()[nr - 1])

# Help text

glb_help_text = """
<h1>Contents</h1>
<style>
p.c1 {
    text-indent: 40px;
}
p.c2 {
    text-indent: 80px;
}
}
</style>
<p class=c1><a href=#reports>1. Reports</a></p>
<p class=c2><a href=#callgraph>1.1 Context-Sensitive Call Graph</a></p>
<p class=c2><a href=#calltree>1.2 Call Tree</a></p>
<p class=c2><a href=#allbranches>1.3 All branches</a></p>
<p class=c2><a href=#selectedbranches>1.4 Selected branches</a></p>
<p class=c2><a href=#topcallsbyelapsedtime>1.5 Top calls by elapsed time</a></p>
<p class=c1><a href=#charts>2. Charts</a></p>
<p class=c2><a href=#timechartbycpu>2.1 Time chart by CPU</a></p>
<p class=c1><a href=#tables>3. Tables</a></p>
<h1 id=reports>1. Reports</h1>
<h2 id=callgraph>1.1 Context-Sensitive Call Graph</h2>
The result is a GUI window with a tree representing a context-sensitive
call-graph. Expanding a couple of levels of the tree and adjusting column
widths to suit will display something like:
<pre>
                                         Call Graph: pt_example
Call Path                          Object      Count   Time(ns)  Time(%)  Branch Count   Branch Count(%)
v- ls
    v- 2638:2638
        v- _start                  ld-2.19.so    1     10074071   100.0         211135            100.0
          |- unknown               unknown       1        13198     0.1              1              0.0
          >- _dl_start             ld-2.19.so    1      1400980    13.9          19637              9.3
          >- _d_linit_internal     ld-2.19.so    1       448152     4.4          11094              5.3
          v-__libc_start_main@plt  ls            1      8211741    81.5         180397             85.4
             >- _dl_fixup          ld-2.19.so    1         7607     0.1            108              0.1
             >- __cxa_atexit       libc-2.19.so  1        11737     0.1             10              0.0
             >- __libc_csu_init    ls            1        10354     0.1             10              0.0
             |- _setjmp            libc-2.19.so  1            0     0.0              4              0.0
             v- main               ls            1      8182043    99.6         180254             99.9
</pre>
<h3>Points to note:</h3>
<ul>
<li>The top level is a command name (comm)</li>
<li>The next level is a thread (pid:tid)</li>
<li>Subsequent levels are functions</li>
<li>'Count' is the number of calls</li>
<li>'Time' is the elapsed time until the function returns</li>
<li>Percentages are relative to the level above</li>
<li>'Branch Count' is the total number of branches for that function and all functions that it calls
</ul>
<h3>Find</h3>
Ctrl-F displays a Find bar which finds function names by either an exact match or a pattern match.
The pattern matching symbols are ? for any character and * for zero or more characters.
<h2 id=calltree>1.2 Call Tree</h2>
The Call Tree report is very similar to the Context-Sensitive Call Graph, but the data is not aggregated.
Also the 'Count' column, which would be always 1, is replaced by the 'Call Time'.
<h2 id=allbranches>1.3 All branches</h2>
The All branches report displays all branches in chronological order.
Not all data is fetched immediately. More records can be fetched using the Fetch bar provided.
<h3>Disassembly</h3>
Open a branch to display disassembly. This only works if:
<ol>
<li>The disassembler is available. Currently, only Intel XED is supported - see <a href=#xed>Intel XED Setup</a></li>
<li>The object code is available. Currently, only the perf build ID cache is searched for object code.
The default directory ~/.debug can be overridden by setting environment variable PERF_BUILDID_DIR.
One exception is kcore where the DSO long name is used (refer dsos_view on the Tables menu),
or alternatively, set environment variable PERF_KCORE to the kcore file name.</li>
</ol>
<h4 id=xed>Intel XED Setup</h4>
To use Intel XED, libxed.so must be present.  To build and install libxed.so:
<pre>
git clone https://github.com/intelxed/mbuild.git mbuild
git clone https://github.com/intelxed/xed
cd xed
./mfile.py --share
sudo ./mfile.py --prefix=/usr/local install
sudo ldconfig
</pre>
<h3>Instructions per Cycle (IPC)</h3>
If available, IPC information is displayed in columns 'insn_cnt', 'cyc_cnt' and 'IPC'.
<p><b>Intel PT note:</b> The information applies to the blocks of code ending with, and including, that branch.
Due to the granularity of timing information, the number of cycles for some code blocks will not be known.
In that case, 'insn_cnt', 'cyc_cnt' and 'IPC' are zero, but when 'IPC' is displayed it covers the period
since the previous displayed 'IPC'.
<h3>Find</h3>
Ctrl-F displays a Find bar which finds substrings by either an exact match or a regular expression match.
Refer to Python documentation for the regular expression syntax.
All columns are searched, but only currently fetched rows are searched.
<h2 id=selectedbranches>1.4 Selected branches</h2>
This is the same as the <a href=#allbranches>All branches</a> report but with the data reduced
by various selection criteria. A dialog box displays available criteria which are AND'ed together.
<h3>1.4.1 Time ranges</h3>
The time ranges hint text shows the total time range. Relative time ranges can also be entered in
ms, us or ns. Also, negative values are relative to the end of trace.  Examples:
<pre>
    81073085947329-81073085958238	From 81073085947329 to 81073085958238
    100us-200us		From 100us to 200us
    10ms-			From 10ms to the end
    -100ns			The first 100ns
    -10ms-			The last 10ms
</pre>
N.B. Due to the granularity of timestamps, there could be no branches in any given time range.
<h2 id=topcallsbyelapsedtime>1.5 Top calls by elapsed time</h2>
The Top calls by elapsed time report displays calls in descending order of time elapsed between when the function was called and when it returned.
The data is reduced by various selection criteria. A dialog box displays available criteria which are AND'ed together.
If not all data is fetched, a Fetch bar is provided. Ctrl-F displays a Find bar.
<h1 id=charts>2. Charts</h1>
<h2 id=timechartbycpu>2.1 Time chart by CPU</h2>
This chart displays context switch information when that data is available. Refer to context_switches_view on the Tables menu.
<h3>Features</h3>
<ol>
<li>Mouse over to highight the task and show the time</li>
<li>Drag the mouse to select a region and zoom by pushing the Zoom button</li>
<li>Go back and forward by pressing the arrow buttons</li>
<li>If call information is available, right-click to show a call tree opened to that task and time.
Note, the call tree may take some time to appear, and there may not be call information for the task or time selected.
</li>
</ol>
<h3>Important</h3>
The graph can be misleading in the following respects:
<ol>
<li>The graph shows the first task on each CPU as running from the beginning of the time range.
Because tracing might start on different CPUs at different times, that is not necessarily the case.
Refer to context_switches_view on the Tables menu to understand what data the graph is based upon.</li>
<li>Similarly, the last task on each CPU can be showing running longer than it really was.
Again, refer to context_switches_view on the Tables menu to understand what data the graph is based upon.</li>
<li>When the mouse is over a task, the highlighted task might not be visible on the legend without scrolling if the legend does not fit fully in the window</li>
</ol>
<h1 id=tables>3. Tables</h1>
The Tables menu shows all tables and views in the database. Most tables have an associated view
which displays the information in a more friendly way. Not all data for large tables is fetched
immediately. More records can be fetched using the Fetch bar provided. Columns can be sorted,
but that can be slow for large tables.
<p>There are also tables of database meta-information.
For SQLite3 databases, the sqlite_master table is included.
For PostgreSQL databases, information_schema.tables/views/columns are included.
<h3>Find</h3>
Ctrl-F displays a Find bar which finds substrings by either an exact match or a regular expression match.
Refer to Python documentation for the regular expression syntax.
All columns are searched, but only currently fetched rows are searched.
<p>N.B. Results are found in id order, so if the table is re-ordered, find-next and find-previous
will go to the next/previous result in id order, instead of display order.
"""

# Help window

class HelpWindow(QMdiSubWindow):

    def __init__(self, glb, parent=None):
        super(HelpWindow, self).__init__(parent)

        self.text = QTextBrowser()
        self.text.setHtml(glb_help_text)
        self.text.setReadOnly(True)
        self.text.setOpenExternalLinks(True)

        self.setWidget(self.text)

        AddSubWindow(glb.mainwindow.mdi_area, self, "Exported SQL Viewer Help")

# Main window that only displays the help text

class HelpOnlyWindow(QMainWindow):

    def __init__(self, parent=None):
        super(HelpOnlyWindow, self).__init__(parent)

        self.setMinimumSize(200, 100)
        self.resize(800, 600)
        self.setWindowTitle("Exported SQL Viewer Help")
        self.setWindowIcon(self.style().standardIcon(QStyle.SP_MessageBoxInformation))

        self.text = QTextBrowser()
        self.text.setHtml(glb_help_text)
        self.text.setReadOnly(True)
        self.text.setOpenExternalLinks(True)

        self.setCentralWidget(self.text)

# PostqreSQL server version

def PostqreSQLServerVersion(db):
    query = QSqlQuery(db)
    QueryExec(query, "SELECT VERSION()")
    if query.next():
        v_str = query.value(0)
        v_list = v_str.strip().split(" ")
        if v_list[0] == "PostgreSQL" and v_list[2] == "on":
            return v_list[1]
        return v_str
    return "Unknown"

# SQLite version

def SQLiteVersion(db):
    query = QSqlQuery(db)
    QueryExec(query, "SELECT sqlite_version()")
    if query.next():
        return query.value(0)
    return "Unknown"

# About dialog

class AboutDialog(QDialog):

    def __init__(self, glb, parent=None):
        super(AboutDialog, self).__init__(parent)

        self.setWindowTitle("About Exported SQL Viewer")
        self.setMinimumWidth(300)

        pyside_version = "1" if pyside_version_1 else "2"

        text = "<pre>"
        text += "Python version:     " + sys.version.split(" ")[0] + "\n"
        text += "PySide version:     " + pyside_version + "\n"
        text += "Qt version:         " + qVersion() + "\n"
        if glb.dbref.is_sqlite3:
            text += "SQLite version:     " + SQLiteVersion(glb.db) + "\n"
        else:
            text += "PostqreSQL version: " + PostqreSQLServerVersion(glb.db) + "\n"
        text += "</pre>"

        self.text = QTextBrowser()
        self.text.setHtml(text)
        self.text.setReadOnly(True)
        self.text.setOpenExternalLinks(True)

        self.vbox = QVBoxLayout()
        self.vbox.addWidget(self.text)

        self.setLayout(self.vbox)

# Font resize

def ResizeFont(widget, diff):
    font = widget.font()
    sz = font.pointSize()
    font.setPointSize(sz + diff)
    widget.setFont(font)

def ShrinkFont(widget):
    ResizeFont(widget, -1)

def EnlargeFont(widget):
    ResizeFont(widget, 1)

# Unique name for sub-windows

def NumberedWindowName(name, nr):
    if nr > 1:
        name += " <" + str(nr) + ">"
    return name

def UniqueSubWindowName(mdi_area, name):
    nr = 1
    while True:
        unique_name = NumberedWindowName(name, nr)
        ok = True
        for sub_window in mdi_area.subWindowList():
            if sub_window.name == unique_name:
                ok = False
                break
        if ok:
            return unique_name
        nr += 1

# Add a sub-window

def AddSubWindow(mdi_area, sub_window, name):
    unique_name = UniqueSubWindowName(mdi_area, name)
    sub_window.setMinimumSize(200, 100)
    sub_window.resize(800, 600)
    sub_window.setWindowTitle(unique_name)
    sub_window.setAttribute(Qt.WA_DeleteOnClose)
    sub_window.setWindowIcon(sub_window.style().standardIcon(QStyle.SP_FileIcon))
    sub_window.name = unique_name
    mdi_area.addSubWindow(sub_window)
    sub_window.show()

# Main window

class MainWindow(QMainWindow):

    def __init__(self, glb, parent=None):
        super(MainWindow, self).__init__(parent)

        self.glb = glb

        self.setWindowTitle("Exported SQL Viewer: " + glb.dbname)
        self.setWindowIcon(self.style().standardIcon(QStyle.SP_ComputerIcon))
        self.setMinimumSize(200, 100)

        self.mdi_area = QMdiArea()
        self.mdi_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
        self.mdi_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)

        self.setCentralWidget(self.mdi_area)

        menu = self.menuBar()

        file_menu = menu.addMenu("&File")
        file_menu.addAction(CreateExitAction(glb.app, self))

        edit_menu = menu.addMenu("&Edit")
        edit_menu.addAction(CreateAction("&Copy", "Copy to clipboard", self.CopyToClipboard, self, QKeySequence.Copy))
        edit_menu.addAction(CreateAction("Copy as CS&V", "Copy to clipboard as CSV", self.CopyToClipboardCSV, self))
        edit_menu.addAction(CreateAction("&Find...", "Find items", self.Find, self, QKeySequence.Find))
        edit_menu.addAction(CreateAction("Fetch &more records...", "Fetch more records", self.FetchMoreRecords, self, [QKeySequence(Qt.Key_F8)]))
        edit_menu.addAction(CreateAction("&Shrink Font", "Make text smaller", self.ShrinkFont, self, [QKeySequence("Ctrl+-")]))
        edit_menu.addAction(CreateAction("&Enlarge Font", "Make text bigger", self.EnlargeFont, self, [QKeySequence("Ctrl++")]))

        reports_menu = menu.addMenu("&Reports")
        if IsSelectable(glb.db, "calls"):
            reports_menu.addAction(CreateAction("Context-Sensitive Call &Graph", "Create a new window containing a context-sensitive call graph", self.NewCallGraph, self))

        if IsSelectable(glb.db, "calls", "WHERE parent_id >= 0"):
            reports_menu.addAction(CreateAction("Call &Tree", "Create a new window containing a call tree", self.NewCallTree, self))

        self.EventMenu(GetEventList(glb.db), reports_menu)

        if IsSelectable(glb.db, "calls"):
            reports_menu.addAction(CreateAction("&Top calls by elapsed time", "Create a new window displaying top calls by elapsed time", self.NewTopCalls, self))

        if IsSelectable(glb.db, "context_switches"):
            charts_menu = menu.addMenu("&Charts")
            charts_menu.addAction(CreateAction("&Time chart by CPU", "Create a new window displaying time charts by CPU", self.TimeChartByCPU, self))

        self.TableMenu(GetTableList(glb), menu)

        self.window_menu = WindowMenu(self.mdi_area, menu)

        help_menu = menu.addMenu("&Help")
        help_menu.addAction(CreateAction("&Exported SQL Viewer Help", "Helpful information", self.Help, self, QKeySequence.HelpContents))
        help_menu.addAction(CreateAction("&About Exported SQL Viewer", "About this application", self.About, self))

    def Try(self, fn):
        win = self.mdi_area.activeSubWindow()
        if win:
            try:
                fn(win.view)
            except AttributeError:
                pass

    def CopyToClipboard(self):
        self.Try(CopyCellsToClipboardHdr)

    def CopyToClipboardCSV(self):
        self.Try(CopyCellsToClipboardCSV)

    def Find(self):
        win = self.mdi_area.activeSubWindow()
        if win:
            try:
                win.find_bar.Activate()
            except AttributeError:
                pass

    def FetchMoreRecords(self):
        win = self.mdi_area.activeSubWindow()
        if win:
            try:
                win.fetch_bar.Activate()
            except AttributeError:
                pass

    def ShrinkFont(self):
        self.Try(ShrinkFont)

    def EnlargeFont(self):
        self.Try(EnlargeFont)

    def EventMenu(self, events, reports_menu):
        branches_events = 0
        for event in events:
            event = event.split(":")[0]
            if event == "branches":
                branches_events += 1
        dbid = 0
        for event in events:
            dbid += 1
            event = event.split(":")[0]
            if event == "branches":
                label = "All branches" if branches_events == 1 else "All branches " + "(id=" + dbid + ")"
                reports_menu.addAction(CreateAction(label, "Create a new window displaying branch events", lambda a=None,x=dbid: self.NewBranchView(x), self))
                label = "Selected branches" if branches_events == 1 else "Selected branches " + "(id=" + dbid + ")"
                reports_menu.addAction(CreateAction(label, "Create a new window displaying branch events", lambda a=None,x=dbid: self.NewSelectedBranchView(x), self))

    def TimeChartByCPU(self):
        TimeChartByCPUWindow(self.glb, self)

    def TableMenu(self, tables, menu):
        table_menu = menu.addMenu("&Tables")
        for table in tables:
            table_menu.addAction(CreateAction(table, "Create a new window containing a table view", lambda a=None,t=table: self.NewTableView(t), self))

    def NewCallGraph(self):
        CallGraphWindow(self.glb, self)

    def NewCallTree(self):
        CallTreeWindow(self.glb, self)

    def NewTopCalls(self):
        dialog = TopCallsDialog(self.glb, self)
        ret = dialog.exec_()
        if ret:
            TopCallsWindow(self.glb, dialog.report_vars, self)

    def NewBranchView(self, event_id):
        BranchWindow(self.glb, event_id, ReportVars(), self)

    def NewSelectedBranchView(self, event_id):
        dialog = SelectedBranchDialog(self.glb, self)
        ret = dialog.exec_()
        if ret:
            BranchWindow(self.glb, event_id, dialog.report_vars, self)

    def NewTableView(self, table_name):
        TableWindow(self.glb, table_name, self)

    def Help(self):
        HelpWindow(self.glb, self)

    def About(self):
        dialog = AboutDialog(self.glb, self)
        dialog.exec_()

def TryOpen(file_name):
    try:
        return open(file_name, "rb")
    except OSError:
        return None

def Is64Bit(f):
    result = sizeof(c_void_p)
    # ELF support only
    pos = f.tell()
    f.seek(0)
    header = f.read(7)
    f.seek(pos)
    magic = header[0:4]
    if sys.version_info[0] == 2:
        eclass = ord(header[4])
        encoding = ord(header[5])
        version = ord(header[6])
    else:
        eclass = header[4]
        encoding = header[5]
        version = header[6]
    if magic == chr(127) + "ELF" and eclass > 0 and eclass < 3 and encoding > 0 and encoding < 3 and version == 1:
        result = True if eclass == 2 else False
    return result

# Global data

class Glb():

    def __init__(self, dbref, db, dbname):
        self.dbref = dbref
        self.db = db
        self.dbname = dbname
        self.home_dir = os.path.expanduser("~")
        self.buildid_dir = os.getenv("PERF_BUILDID_DIR")
        if self.buildid_dir:
            self.buildid_dir += "/.build-id/"
        else:
            self.buildid_dir = self.home_dir + "/.debug/.build-id/"
        self.app = None
        self.mainwindow = None
        self.instances_to_shutdown_on_exit = weakref.WeakSet()
        try:
            self.disassembler = LibXED()
            self.have_disassembler = True
        except (OSError, RuntimeError, AttributeError):
            self.have_disassembler = False
        self.host_machine_id = 0
        self.host_start_time = 0
        self.host_finish_time = 0

    def FileFromBuildId(self, build_id):
        file_name = self.buildid_dir + build_id[0:2] + "/" + build_id[2:] + "/elf"
        return TryOpen(file_name)

    def FileFromNamesAndBuildId(self, short_name, long_name, build_id):
        # Assume current machine i.e. no support for virtualization
        if short_name[0:7] == "[kernel" and os.path.basename(long_name) == "kcore":
            file_name = os.getenv("PERF_KCORE")
            f = TryOpen(file_name) if file_name else None
            if f:
                return f
            # For now, no special handling if long_name is /proc/kcore
            f = TryOpen(long_name)
            if f:
                return f
        f = self.FileFromBuildId(build_id)
        if f:
            return f
        return None

    def AddInstanceToShutdownOnExit(self, instance):
        self.instances_to_shutdown_on_exit.add(instance)

    # Shutdown any background processes or threads
    def ShutdownInstances(self):
        for x in self.instances_to_shutdown_on_exit:
            try:
                x.Shutdown()
            except AttributeError:
                pass

    def GetHostMachineId(self):
        query = QSqlQuery(self.db)
        QueryExec(query, "SELECT id FROM machines WHERE pid = -1")
        if query.next():
            self.host_machine_id = query.value(0)
        else:
            self.host_machine_id = 0
        return self.host_machine_id

    def HostMachineId(self):
        if self.host_machine_id:
            return self.host_machine_id
        return self.GetHostMachineId()

    def SelectValue(self, sql):
        query = QSqlQuery(self.db)
        try:
            QueryExec(query, sql)
        except RuntimeError:
            return None
        if query.next():
            return Decimal(query.value(0))
        return None

    def SwitchesMinTime(self, machine_id):
        return self.SelectValue("SELECT time"
                    " FROM context_switches"
                    " WHERE time != 0 AND machine_id = " + str(machine_id) +
                    " ORDER BY id LIMIT 1")

    def SwitchesMaxTime(self, machine_id):
        return self.SelectValue("SELECT time"
                    " FROM context_switches"
                    " WHERE time != 0 AND machine_id = " + str(machine_id) +
                    " ORDER BY id DESC LIMIT 1")

    def SamplesMinTime(self, machine_id):
        return self.SelectValue("SELECT time"
                    " FROM samples"
                    " WHERE time != 0 AND machine_id = " + str(machine_id) +
                    " ORDER BY id LIMIT 1")

    def SamplesMaxTime(self, machine_id):
        return self.SelectValue("SELECT time"
                    " FROM samples"
                    " WHERE time != 0 AND machine_id = " + str(machine_id) +
                    " ORDER BY id DESC LIMIT 1")

    def CallsMinTime(self, machine_id):
        return self.SelectValue("SELECT calls.call_time"
                    " FROM calls"
                    " INNER JOIN threads ON threads.id = calls.thread_id"
                    " WHERE calls.call_time != 0 AND threads.machine_id = " + str(machine_id) +
                    " ORDER BY calls.id LIMIT 1")

    def CallsMaxTime(self, machine_id):
        return self.SelectValue("SELECT calls.return_time"
                    " FROM calls"
                    " INNER JOIN threads ON threads.id = calls.thread_id"
                    " WHERE calls.return_time != 0 AND threads.machine_id = " + str(machine_id) +
                    " ORDER BY calls.return_time DESC LIMIT 1")

    def GetStartTime(self, machine_id):
        t0 = self.SwitchesMinTime(machine_id)
        t1 = self.SamplesMinTime(machine_id)
        t2 = self.CallsMinTime(machine_id)
        if t0 is None or (not(t1 is None) and t1 < t0):
            t0 = t1
        if t0 is None or (not(t2 is None) and t2 < t0):
            t0 = t2
        return t0

    def GetFinishTime(self, machine_id):
        t0 = self.SwitchesMaxTime(machine_id)
        t1 = self.SamplesMaxTime(machine_id)
        t2 = self.CallsMaxTime(machine_id)
        if t0 is None or (not(t1 is None) and t1 > t0):
            t0 = t1
        if t0 is None or (not(t2 is None) and t2 > t0):
            t0 = t2
        return t0

    def HostStartTime(self):
        if self.host_start_time:
            return self.host_start_time
        self.host_start_time = self.GetStartTime(self.HostMachineId())
        return self.host_start_time

    def HostFinishTime(self):
        if self.host_finish_time:
            return self.host_finish_time
        self.host_finish_time = self.GetFinishTime(self.HostMachineId())
        return self.host_finish_time

    def StartTime(self, machine_id):
        if machine_id == self.HostMachineId():
            return self.HostStartTime()
        return self.GetStartTime(machine_id)

    def FinishTime(self, machine_id):
        if machine_id == self.HostMachineId():
            return self.HostFinishTime()
        return self.GetFinishTime(machine_id)

# Database reference

class DBRef():

    def __init__(self, is_sqlite3, dbname):
        self.is_sqlite3 = is_sqlite3
        self.dbname = dbname
        self.TRUE = "TRUE"
        self.FALSE = "FALSE"
        # SQLite prior to version 3.23 does not support TRUE and FALSE
        if self.is_sqlite3:
            self.TRUE = "1"
            self.FALSE = "0"

    def Open(self, connection_name):
        dbname = self.dbname
        if self.is_sqlite3:
            db = QSqlDatabase.addDatabase("QSQLITE", connection_name)
        else:
            db = QSqlDatabase.addDatabase("QPSQL", connection_name)
            opts = dbname.split()
            for opt in opts:
                if "=" in opt:
                    opt = opt.split("=")
                    if opt[0] == "hostname":
                        db.setHostName(opt[1])
                    elif opt[0] == "port":
                        db.setPort(int(opt[1]))
                    elif opt[0] == "username":
                        db.setUserName(opt[1])
                    elif opt[0] == "password":
                        db.setPassword(opt[1])
                    elif opt[0] == "dbname":
                        dbname = opt[1]
                else:
                    dbname = opt

        db.setDatabaseName(dbname)
        if not db.open():
            raise RuntimeError("Failed to open database " + dbname + " error: " + db.lastError().text())
        return db, dbname

# Main

def Main():
    usage_str =	"exported-sql-viewer.py [--pyside-version-1] <database name>\n" \
            "   or: exported-sql-viewer.py --help-only"
    ap = argparse.ArgumentParser(usage = usage_str, add_help = False)
    ap.add_argument("--pyside-version-1", action='store_true')
    ap.add_argument("dbname", nargs="?")
    ap.add_argument("--help-only", action='store_true')
    args = ap.parse_args()

    if args.help_only:
        app = QApplication(sys.argv)
        mainwindow = HelpOnlyWindow()
        mainwindow.show()
        err = app.exec_()
        sys.exit(err)

    dbname = args.dbname
    if dbname is None:
        ap.print_usage()
        print("Too few arguments")
        sys.exit(1)

    is_sqlite3 = False
    try:
        f = open(dbname, "rb")
        if f.read(15) == b'SQLite format 3':
            is_sqlite3 = True
        f.close()
    except OSError:
        pass

    dbref = DBRef(is_sqlite3, dbname)
    db, dbname = dbref.Open("main")
    glb = Glb(dbref, db, dbname)
    app = QApplication(sys.argv)
    glb.app = app
    mainwindow = MainWindow(glb)
    glb.mainwindow = mainwindow
    mainwindow.show()
    err = app.exec_()
    glb.ShutdownInstances()
    db.close()
    sys.exit(err)

if __name__ == "__main__":
    Main()