path: root/bitbake/lib/bb/ui/taskexp_ncurses.py

#
# BitBake Graphical ncurses-based Dependency Explorer
#   * Based on the GTK implementation
#   * Intended to run on any Linux host
#
# Copyright (C) 2007        Ross Burton
# Copyright (C) 2007 - 2008 Richard Purdie
# Copyright (C) 2022 - 2024 David Reyna
#
# SPDX-License-Identifier: GPL-2.0-only
#

#
# Execution example:
#   $ bitbake -g -u taskexp_ncurses zlib acl
#
# Self-test example (executes a script of GUI actions):
#   $ TASK_EXP_UNIT_TEST=1 bitbake -g -u taskexp_ncurses zlib acl
#   ...
#   $ echo $?
#   0
#   $ TASK_EXP_UNIT_TEST=1 bitbake -g -u taskexp_ncurses zlib acl foo
#   ERROR: Nothing PROVIDES 'foo'. Close matches:
#   ofono
#   $ echo $?
#   1
#
# Self-test with no terminal example (only tests dependency fetch from bitbake):
#   $ TASK_EXP_UNIT_TEST_NOTERM=1 bitbake -g -u taskexp_ncurses quilt
#   $ echo $?
#   0
#
# Features:
# * Ncurses is used for the presentation layer. Only the 'curses'
#   library is used (none of the extension libraries), plus only
#   one main screen is used (no sub-windows)
# * Uses the 'generateDepTreeEvent' bitbake event to fetch the
#   dynamic dependency data based on passed recipes
# * Computes and provides reverse dependencies
# * Supports task sorting on:
#   (a) Task dependency order within each recipe
#   (b) Pure alphabetical order
#   (c) Provisions for third sort order (bitbake order?)
# * The 'Filter' does a "*string*" wildcard filter on tasks in the
#   main window, dynamically re-ordering and re-centering the content
# * A 'Print' function exports the selected task or its whole recipe
#   task set to the default file "taskdep.txt"
# * Supports a progress bar for bitbake loads and file printing
# * Line art for box drawing supported, ASCII art an alernative
# * No horizontal scrolling support. Selected task's full name
#   shown in bottom bar
# * Dynamically catches terminals that are (or become) too small
# * Exception to insure return to normal terminal on errors
# * Debugging support, self test option
#

import sys
import traceback
import curses
import re
import time

# Bitbake server support
import threading
from xmlrpc import client
import bb
import bb.event

# Dependency indexes (depends_model)
(TYPE_DEP, TYPE_RDEP) = (0, 1)
DEPENDS_TYPE = 0
DEPENDS_TASK = 1
DEPENDS_DEPS = 2
# Task indexes (task_list)
TASK_NAME = 0
TASK_PRIMARY = 1
TASK_SORT_ALPHA = 2
TASK_SORT_DEPS = 3
TASK_SORT_BITBAKE = 4
# Sort options (default is SORT_DEPS)
SORT_ALPHA = 0
SORT_DEPS = 1
SORT_BITBAKE_ENABLE = False # NOTE: future sort
SORT_BITBAKE = 2
sort_model = SORT_DEPS
# Print options
PRINT_MODEL_1 = 0
PRINT_MODEL_2 = 1
print_model = PRINT_MODEL_2
print_file_name = "taskdep_print.log"
print_file_backup_name = "taskdep_print_backup.log"
is_printed = False
is_filter = False

# Standard (and backup) key mappings
CHAR_NUL = 0            # Used as self-test nop char
CHAR_BS_H = 8           # Alternate backspace key
CHAR_TAB = 9
CHAR_RETURN = 10
CHAR_ESCAPE = 27
CHAR_UP = ord('{')      # Used as self-test ASCII char
CHAR_DOWN = ord('}')    # Used as self-test ASCII char

# Color_pair IDs
CURSES_NORMAL = 0
CURSES_HIGHLIGHT = 1
CURSES_WARNING = 2


#################################################
### Debugging support
###

verbose = False

# Debug: message display slow-step through display update issues
def alert(msg,screen):
    if msg:
        screen.addstr(0, 10, '[%-4s]' % msg)
        screen.refresh();
        curses.napms(2000)
    else:
        if do_line_art:
            for i in range(10, 24):
                screen.addch(0, i, curses.ACS_HLINE)
        else:
            screen.addstr(0, 10, '-' * 14)
        screen.refresh();

# Debug: display edge conditions on frame movements
def debug_frame(nbox_ojb):
    if verbose:
        nbox_ojb.screen.addstr(0, 50, '[I=%2d,O=%2d,S=%3s,H=%2d,M=%4d]' % (
            nbox_ojb.cursor_index,
            nbox_ojb.cursor_offset,
            nbox_ojb.scroll_offset,
            nbox_ojb.inside_height,
            len(nbox_ojb.task_list),
        ))
        nbox_ojb.screen.refresh();

#
# Unit test (assumes that 'quilt-native' is always present)
#

unit_test = os.environ.get('TASK_EXP_UNIT_TEST')
unit_test_cmnds=[
    '# Default selected task in primary box',
    'tst_selected=<TASK>.do_recipe_qa',
    '# Default selected task in deps',
    'tst_entry=<TAB>',
    'tst_selected=',
    '# Default selected task in rdeps',
    'tst_entry=<TAB>',
    'tst_selected=<TASK>.do_fetch',
    "# Test 'select' back to primary box",
    'tst_entry=<CR>',
    '#tst_entry=<DOWN>',  # optional injected error
    'tst_selected=<TASK>.do_fetch',
    '# Check filter',
    'tst_entry=/uilt-nativ/',
    'tst_selected=quilt-native.do_recipe_qa',
    '# Check print',
    'tst_entry=p',
    'tst_printed=quilt-native.do_fetch',
    '#tst_printed=quilt-foo.do_nothing',  # optional injected error
    '# Done!',
    'tst_entry=q',
]
unit_test_idx=0
unit_test_command_chars=''
unit_test_results=[]
def unit_test_action(active_package):
    global unit_test_idx
    global unit_test_command_chars
    global unit_test_results
    ret = CHAR_NUL
    if unit_test_command_chars:
        ch = unit_test_command_chars[0]
        unit_test_command_chars = unit_test_command_chars[1:]
        time.sleep(0.5)
        ret = ord(ch)
    else:
        line = unit_test_cmnds[unit_test_idx]
        unit_test_idx += 1
        line = re.sub('#.*', '', line).strip()
        line = line.replace('<TASK>',active_package.primary[0])
        line = line.replace('<TAB>','\t').replace('<CR>','\n')
        line = line.replace('<UP>','{').replace('<DOWN>','}')
        if not line: line = 'nop=nop'
        cmnd,value = line.split('=')
        if cmnd == 'tst_entry':
            unit_test_command_chars = value
        elif cmnd == 'tst_selected':
            active_selected = active_package.get_selected()
            if active_selected != value:
                unit_test_results.append("ERROR:SELFTEST:expected '%s' but got '%s' (NOTE:bitbake may have changed)" % (value,active_selected))
                ret = ord('Q')
            else:
                unit_test_results.append("Pass:SELFTEST:found '%s'" % (value))
        elif cmnd == 'tst_printed':
            result = os.system('grep %s %s' % (value,print_file_name))
            if result:
                unit_test_results.append("ERROR:PRINTTEST:expected '%s' in '%s'" % (value,print_file_name))
                ret = ord('Q')
            else:
                unit_test_results.append("Pass:PRINTTEST:found '%s'" % (value))
    # Return the action (CHAR_NUL for no action til next round)
    return(ret)

# Unit test without an interative terminal (e.g. ptest)
unit_test_noterm = os.environ.get('TASK_EXP_UNIT_TEST_NOTERM')


#################################################
### Window frame rendering
###
### By default, use the normal line art. Since
###  these extended characters are not ASCII, one
###  must use the ncursus API to render them
### The alternate ASCII line art set is optionally
###  available via the 'do_line_art' flag

# By default, render frames using line art
do_line_art = True

# ASCII render set option
CHAR_HBAR = '-'
CHAR_VBAR = '|'
CHAR_UL_CORNER = '/'
CHAR_UR_CORNER = '\\'
CHAR_LL_CORNER = '\\'
CHAR_LR_CORNER = '/'

# Box frame drawing with line-art
def line_art_frame(box):
    x = box.base_x
    y = box.base_y
    w = box.width
    h = box.height + 1

    if do_line_art:
        for i in range(1, w - 1):
            box.screen.addch(y, x + i, curses.ACS_HLINE, box.color)
            box.screen.addch(y + h - 1, x + i, curses.ACS_HLINE, box.color)
        body_line = "%s" % (' ' * (w - 2))
        for i in range(1, h - 1):
            box.screen.addch(y + i, x, curses.ACS_VLINE, box.color)
            box.screen.addstr(y + i, x + 1, body_line, box.color)
            box.screen.addch(y + i, x + w - 1, curses.ACS_VLINE, box.color)
        box.screen.addch(y, x, curses.ACS_ULCORNER, box.color)
        box.screen.addch(y, x + w - 1, curses.ACS_URCORNER, box.color)
        box.screen.addch(y + h - 1, x, curses.ACS_LLCORNER, box.color)
        box.screen.addch(y + h - 1, x + w - 1, curses.ACS_LRCORNER, box.color)
    else:
        top_line  = "%s%s%s" % (CHAR_UL_CORNER,CHAR_HBAR * (w - 2),CHAR_UR_CORNER)
        body_line = "%s%s%s" % (CHAR_VBAR,' ' * (w - 2),CHAR_VBAR)
        bot_line  = "%s%s%s" % (CHAR_UR_CORNER,CHAR_HBAR * (w - 2),CHAR_UL_CORNER)
        tag_line  = "%s%s%s" % ('[',CHAR_HBAR * (w - 2),']')
        # Top bar
        box.screen.addstr(y, x, top_line)
        # Middle frame
        for i in range(1, (h - 1)):
            box.screen.addstr(y+i, x, body_line)
        # Bottom bar
        box.screen.addstr(y + (h - 1), x, bot_line)

# Connect the separate boxes
def line_art_fixup(box):
    if do_line_art:
        box.screen.addch(box.base_y+2, box.base_x, curses.ACS_LTEE, box.color)
        box.screen.addch(box.base_y+2, box.base_x+box.width-1, curses.ACS_RTEE, box.color)


#################################################
### Ncurses box object : box frame object to display
### and manage a sub-window's display elements
### using basic ncurses
###
### Supports:
###   * Frame drawing, content (re)drawing
###   * Content scrolling via ArrowUp, ArrowDn, PgUp, PgDN,
###   * Highlighting for active selected item
###   * Content sorting based on selected sort model
###

class NBox():
    def __init__(self, screen, label, primary, base_x, base_y, width, height):
        # Box description
        self.screen = screen
        self.label = label
        self.primary = primary
        self.color = curses.color_pair(CURSES_NORMAL) if screen else None
        # Box boundaries
        self.base_x = base_x
        self.base_y = base_y
        self.width = width
        self.height = height
        # Cursor/scroll management
        self.cursor_enable = False
        self.cursor_index = 0   # Absolute offset
        self.cursor_offset = 0  # Frame centric offset
        self.scroll_offset = 0  # Frame centric offset
        # Box specific content
        # Format of each entry is [package_name,is_primary_recipe,alpha_sort_key,deps_sort_key]
        self.task_list = []

    @property
    def inside_width(self):
        return(self.width-2)

    @property
    def inside_height(self):
        return(self.height-2)

    # Populate the box's content, include the sort mappings and is_primary flag
    def task_list_append(self,task_name,dep):
        task_sort_alpha = task_name
        task_sort_deps = dep.get_dep_sort(task_name)
        is_primary = False
        for primary in self.primary:
            if task_name.startswith(primary+'.'):
                is_primary = True
        if SORT_BITBAKE_ENABLE:
            task_sort_bitbake = dep.get_bb_sort(task_name)
            self.task_list.append([task_name,is_primary,task_sort_alpha,task_sort_deps,task_sort_bitbake])
        else:
            self.task_list.append([task_name,is_primary,task_sort_alpha,task_sort_deps])

    def reset(self):
        self.task_list = []
        self.cursor_index = 0   # Absolute offset
        self.cursor_offset = 0  # Frame centric offset
        self.scroll_offset = 0  # Frame centric offset

    # Sort the box's content based on the current sort model
    def sort(self):
        if SORT_ALPHA == sort_model:
            self.task_list.sort(key = lambda x: x[TASK_SORT_ALPHA])
        elif SORT_DEPS == sort_model:
            self.task_list.sort(key = lambda x: x[TASK_SORT_DEPS])
        elif SORT_BITBAKE == sort_model:
            self.task_list.sort(key = lambda x: x[TASK_SORT_BITBAKE])

    # The target package list (to hightlight), from the command line
    def set_primary(self,primary):
        self.primary = primary

    # Draw the box's outside frame
    def draw_frame(self):
        line_art_frame(self)
        # Title
        self.screen.addstr(self.base_y,
            (self.base_x + (self.width//2))-((len(self.label)+2)//2),
            '['+self.label+']')
        self.screen.refresh()

    # Draw the box's inside text content
    def redraw(self):
        task_list_len = len(self.task_list)
        # Middle frame
        body_line = "%s" % (' ' * (self.inside_width-1) )
        for i in range(0,self.inside_height+1):
            if i < (task_list_len + self.scroll_offset):
                str_ctl = "%%-%ss" % (self.width-3)
                # Safety assert
                if (i + self.scroll_offset) >= task_list_len:
                    alert("REDRAW:%2d,%4d,%4d" % (i,self.scroll_offset,task_list_len),self.screen)
                    break

                task_obj = self.task_list[i + self.scroll_offset]
                task = task_obj[TASK_NAME][:self.inside_width-1]
                task_primary = task_obj[TASK_PRIMARY]

                if task_primary:
                    line = str_ctl % task[:self.inside_width-1]
                    self.screen.addstr(self.base_y+1+i, self.base_x+2, line, curses.A_BOLD)
                else:
                    line = str_ctl % task[:self.inside_width-1]
                    self.screen.addstr(self.base_y+1+i, self.base_x+2, line)
            else:
                line = "%s" % (' ' * (self.inside_width-1) )
                self.screen.addstr(self.base_y+1+i, self.base_x+2, line)
        self.screen.refresh()

    # Show the current selected task over the bottom of the frame
    def show_selected(self,selected_task):
        if not selected_task:
            selected_task = self.get_selected()
        tag_line   = "%s%s%s" % ('[',CHAR_HBAR * (self.width-2),']')
        self.screen.addstr(self.base_y + self.height, self.base_x, tag_line)
        self.screen.addstr(self.base_y + self.height,
            (self.base_x + (self.width//2))-((len(selected_task)+2)//2),
            '['+selected_task+']')
        self.screen.refresh()

    # Load box with new table of content
    def update_content(self,task_list):
        self.task_list = task_list
        if self.cursor_enable:
            cursor_update(turn_on=False)
        self.cursor_index = 0
        self.cursor_offset = 0
        self.scroll_offset = 0
        self.redraw()
        if self.cursor_enable:
            cursor_update(turn_on=True)

    # Manage the box's highlighted task and blinking cursor character
    def cursor_on(self,is_on):
        self.cursor_enable = is_on
        self.cursor_update(is_on)

    # High-light the current pointed package, normal for released packages
    def cursor_update(self,turn_on=True):
        str_ctl = "%%-%ss" % (self.inside_width-1)
        try:
            if len(self.task_list):
                task_obj = self.task_list[self.cursor_index]
                task = task_obj[TASK_NAME][:self.inside_width-1]
                task_primary = task_obj[TASK_PRIMARY]
                task_font = curses.A_BOLD if task_primary else 0
            else:
                task = ''
                task_font = 0
        except Exception as e:
            alert("CURSOR_UPDATE:%s" % (e),self.screen)
            return
        if turn_on:
            self.screen.addstr(self.base_y+1+self.cursor_offset,self.base_x+1,">", curses.color_pair(CURSES_HIGHLIGHT) | curses.A_BLINK)
            self.screen.addstr(self.base_y+1+self.cursor_offset,self.base_x+2,str_ctl % task, curses.color_pair(CURSES_HIGHLIGHT) | task_font)
        else:
            self.screen.addstr(self.base_y+1+self.cursor_offset,self.base_x+1," ")
            self.screen.addstr(self.base_y+1+self.cursor_offset,self.base_x+2,str_ctl % task, task_font)

    # Down arrow
    def line_down(self):
        if len(self.task_list) <= (self.cursor_index+1):
            return
        self.cursor_update(turn_on=False)
        self.cursor_index += 1
        self.cursor_offset += 1
        if self.cursor_offset > (self.inside_height):
            self.cursor_offset -= 1
            self.scroll_offset += 1
            self.redraw()
        self.cursor_update(turn_on=True)
        debug_frame(self)

    # Up arrow
    def line_up(self):
        if 0 > (self.cursor_index-1):
            return
        self.cursor_update(turn_on=False)
        self.cursor_index -= 1
        self.cursor_offset -= 1
        if self.cursor_offset < 0:
            self.cursor_offset += 1
            self.scroll_offset -= 1
            self.redraw()
        self.cursor_update(turn_on=True)
        debug_frame(self)

    # Page down
    def page_down(self):
        max_task = len(self.task_list)-1
        if max_task < self.inside_height:
            return
        self.cursor_update(turn_on=False)
        self.cursor_index += 10
        self.cursor_index = min(self.cursor_index,max_task)
        self.cursor_offset = min(self.inside_height,self.cursor_index)
        self.scroll_offset = self.cursor_index - self.cursor_offset
        self.redraw()
        self.cursor_update(turn_on=True)
        debug_frame(self)

    # Page up
    def page_up(self):
        max_task = len(self.task_list)-1
        if max_task < self.inside_height:
            return
        self.cursor_update(turn_on=False)
        self.cursor_index -= 10
        self.cursor_index = max(self.cursor_index,0)
        self.cursor_offset = max(0, self.inside_height - (max_task - self.cursor_index))
        self.scroll_offset = self.cursor_index - self.cursor_offset
        self.redraw()
        self.cursor_update(turn_on=True)
        debug_frame(self)

    # Return the currently selected task name for this box
    def get_selected(self):
        if self.task_list:
            return(self.task_list[self.cursor_index][TASK_NAME])
        else:
            return('')

#################################################
### The helper sub-windows
###

# Show persistent help at the top of the screen
class HelpBarView(NBox):
    def __init__(self, screen, label, primary, base_x, base_y, width, height):
        super(HelpBarView, self).__init__(screen, label, primary, base_x, base_y, width, height)

    def show_help(self,show):
        self.screen.addstr(self.base_y,self.base_x, "%s" % (' ' * self.inside_width))
        if show:
            help = "Help='?' Filter='/' NextBox=<Tab> Select=<Enter> Print='p','P' Quit='q'"
            bar_size = self.inside_width - 5 - len(help)
            self.screen.addstr(self.base_y,self.base_x+((self.inside_width-len(help))//2), help)
        self.screen.refresh()

# Pop up a detailed Help box
class HelpBoxView(NBox):
    def __init__(self, screen, label, primary, base_x, base_y, width, height, dep):
        super(HelpBoxView, self).__init__(screen, label, primary, base_x, base_y, width, height)
        self.x_pos = 0
        self.y_pos = 0
        self.dep = dep

    # Instantial the pop-up help box
    def show_help(self,show):
        self.x_pos = self.base_x + 4
        self.y_pos = self.base_y + 2

        def add_line(line):
            if line:
                self.screen.addstr(self.y_pos,self.x_pos,line)
            self.y_pos += 1

        # Gather some statisics
        dep_count = 0
        rdep_count = 0
        for task_obj in self.dep.depends_model:
            if TYPE_DEP == task_obj[DEPENDS_TYPE]:
                dep_count += 1
            elif TYPE_RDEP == task_obj[DEPENDS_TYPE]:
                rdep_count += 1

        self.draw_frame()
        line_art_fixup(self.dep)
        add_line("Quit                : 'q' ")
        add_line("Filter task names   : '/'")
        add_line("Tab to next box     : <Tab>")
        add_line("Select a task       : <Enter>")
        add_line("Print task's deps   : 'p'")
        add_line("Print recipe's deps : 'P'")
        add_line(" -> '%s'" % print_file_name)
        add_line("Sort toggle         : 's'")
        add_line(" %s Recipe inner-depends order" % ('->' if (SORT_DEPS == sort_model) else '- '))
        add_line(" %s Alpha-numeric order" % ('->' if (SORT_ALPHA == sort_model) else '- '))
        if SORT_BITBAKE_ENABLE:
            add_line(" %s Bitbake order" % ('->' if (TASK_SORT_BITBAKE == sort_model) else '- '))
        add_line("Alternate backspace : <CTRL-H>")
        add_line("")
        add_line("Primary recipes = %s"  % ','.join(self.primary))
        add_line("Task  count     = %4d" % len(self.dep.pkg_model))
        add_line("Deps  count     = %4d" % dep_count)
        add_line("RDeps count     = %4d" % rdep_count)
        add_line("")
        self.screen.addstr(self.y_pos,self.x_pos+7,"<Press any key>", curses.color_pair(CURSES_HIGHLIGHT))
        self.screen.refresh()
        c = self.screen.getch()

# Show a progress bar
class ProgressView(NBox):
    def __init__(self, screen, label, primary, base_x, base_y, width, height):
        super(ProgressView, self).__init__(screen, label, primary, base_x, base_y, width, height)

    def progress(self,title,current,max):
        if title:
            self.label = title
        else:
            title = self.label
        if max <=0: max = 10
        bar_size = self.width - 7 - len(title)
        bar_done = int( (float(current)/float(max)) * float(bar_size) )
        self.screen.addstr(self.base_y,self.base_x, " %s:[%s%s]" % (title,'*' * bar_done,' ' * (bar_size-bar_done)))
        self.screen.refresh()
        return(current+1)

    def clear(self):
        self.screen.addstr(self.base_y,self.base_x, "%s" % (' ' * self.width))
        self.screen.refresh()

# Implement a task filter bar
class FilterView(NBox):
    SEARCH_NOP = 0
    SEARCH_GO = 1
    SEARCH_CANCEL = 2

    def __init__(self, screen, label, primary, base_x, base_y, width, height):
        super(FilterView, self).__init__(screen, label, primary, base_x, base_y, width, height)
        self.do_show = False
        self.filter_str = ""

    def clear(self,enable_show=True):
        self.filter_str = ""

    def show(self,enable_show=True):
        self.do_show = enable_show
        if self.do_show:
            self.screen.addstr(self.base_y,self.base_x, "[ Filter: %-25s ]      '/'=cancel, format='abc'       " % self.filter_str[0:25])
        else:
            self.screen.addstr(self.base_y,self.base_x, "%s" % (' ' * self.width))
        self.screen.refresh()

    def show_prompt(self):
        self.screen.addstr(self.base_y,self.base_x + 10 + len(self.filter_str), " ")
        self.screen.addstr(self.base_y,self.base_x + 10 + len(self.filter_str), "")

    # Keys specific to the filter box (start/stop filter keys are in the main loop)
    def input(self,c,ch):
        ret = self.SEARCH_GO
        if c in (curses.KEY_BACKSPACE,CHAR_BS_H):
            #  Backspace
            if self.filter_str:
                self.filter_str = self.filter_str[0:-1]
                self.show()
        elif ((ch >= 'a') and (ch <= 'z')) or ((ch >= 'A') and (ch <= 'Z')) or ((ch >= '0') and (ch <= '9')) or (ch in (' ','_','.','-')):
            # The isalnum() acts strangly with keypad(True), so explicit bounds
            self.filter_str += ch
            self.show()
        else:
            ret = self.SEARCH_NOP
        return(ret)


#################################################
### The primary dependency windows
###

# The main list of package tasks
class PackageView(NBox):
    def __init__(self, screen, label, primary, base_x, base_y, width, height):
        super(PackageView, self).__init__(screen, label, primary, base_x, base_y, width, height)

    # Find and verticaly center a selected task (from filter or from dependent box)
    # The 'task_filter_str' can be a full or a partial (filter) task name
    def find(self,task_filter_str):
        found = False
        max = self.height-2
        if not task_filter_str:
            return(found)
        for i,task_obj in enumerate(self.task_list):
            task = task_obj[TASK_NAME]
            if task.startswith(task_filter_str):
                self.cursor_on(False)
                self.cursor_index = i

                # Position selected at vertical center
                vcenter = self.inside_height // 2
                if self.cursor_index <= vcenter:
                    self.scroll_offset = 0
                    self.cursor_offset = self.cursor_index
                elif self.cursor_index >= (len(self.task_list) - vcenter - 1):
                    self.cursor_offset = self.inside_height-1
                    self.scroll_offset = self.cursor_index - self.cursor_offset
                else:
                    self.cursor_offset = vcenter
                    self.scroll_offset = self.cursor_index - self.cursor_offset

                self.redraw()
                self.cursor_on(True)
                found = True
                break
        return(found)

# The view of dependent packages
class PackageDepView(NBox):
    def __init__(self, screen, label, primary, base_x, base_y, width, height):
        super(PackageDepView, self).__init__(screen, label, primary, base_x, base_y, width, height)

# The view of reverse-dependent packages
class PackageReverseDepView(NBox):
    def __init__(self, screen, label, primary, base_x, base_y, width, height):
        super(PackageReverseDepView, self).__init__(screen, label, primary, base_x, base_y, width, height)


#################################################
### DepExplorer : The parent frame and object
###

class DepExplorer(NBox):
    def __init__(self,screen):
        title = "Task Dependency Explorer"
        super(DepExplorer, self).__init__(screen, 'Task Dependency Explorer','',0,0,80,23)

        self.screen = screen
        self.pkg_model = []
        self.depends_model = []
        self.dep_sort_map = {}
        self.bb_sort_map = {}
        self.filter_str = ''
        self.filter_prev = 'deadbeef'

        if self.screen:
            self.help_bar_view = HelpBarView(screen, "Help",'',1,1,79,1)
            self.help_box_view = HelpBoxView(screen, "Help",'',0,2,40,20,self)
            self.progress_view = ProgressView(screen, "Progress",'',2,1,76,1)
            self.filter_view = FilterView(screen, "Filter",'',2,1,76,1)
            self.package_view = PackageView(screen, "Package",'alpha', 0,2,40,20)
            self.dep_view = PackageDepView(screen, "Dependencies",'beta',40,2,40,10)
            self.reverse_view = PackageReverseDepView(screen, "Dependent Tasks",'gamma',40,13,40,9)
            self.draw_frames()

    # Draw this main window's frame and all sub-windows
    def draw_frames(self):
        self.draw_frame()
        self.package_view.draw_frame()
        self.dep_view.draw_frame()
        self.reverse_view.draw_frame()
        if is_filter:
            self.filter_view.show(True)
            self.filter_view.show_prompt()
        else:
            self.help_bar_view.show_help(True)
        self.package_view.redraw()
        self.dep_view.redraw()
        self.reverse_view.redraw()
        self.show_selected(self.package_view.get_selected())
        line_art_fixup(self)

    # Parse the bitbake dependency event object
    def parse(self, depgraph):
        for task in depgraph["tdepends"]:
            self.pkg_model.insert(0, task)
            for depend in depgraph["tdepends"][task]:
                self.depends_model.insert (0, (TYPE_DEP, task, depend))
                self.depends_model.insert (0, (TYPE_RDEP, depend, task))
        if self.screen:
            self.dep_sort_prep()

    # Prepare the dependency sort order keys
    # This method creates sort keys per recipe tasks in
    # the order of each recipe's internal dependecies
    # Method:
    #   Filter the tasks in dep order in dep_sort_map = {}
    #   (a) Find a task that has no dependecies
    #       Ignore non-recipe specific tasks
    #   (b) Add it to the sort mapping dict with
    #       key of "<task_group>_<order>"
    #   (c) Remove it as a dependency from the other tasks
    #   (d) Repeat till all tasks are mapped
    # Use placeholders to insure each sub-dict is instantiated
    def dep_sort_prep(self):
        self.progress_view.progress('DepSort',0,4)
        # Init the task base entries
        self.progress_view.progress('DepSort',1,4)
        dep_table = {}
        bb_index = 0
        for task in self.pkg_model:
            # First define the incoming bitbake sort order
            self.bb_sort_map[task] = "%04d" % (bb_index)
            bb_index += 1
            task_group = task[0:task.find('.')]
            if task_group not in dep_table:
                dep_table[task_group] = {}
                dep_table[task_group]['-'] = {}         # Placeholder
            if task not in dep_table[task_group]:
                dep_table[task_group][task] = {}
                dep_table[task_group][task]['-'] = {}   # Placeholder
        # Add the task dependecy entries
        self.progress_view.progress('DepSort',2,4)
        for task_obj in self.depends_model:
            if task_obj[DEPENDS_TYPE] != TYPE_DEP:
                continue
            task = task_obj[DEPENDS_TASK]
            task_dep = task_obj[DEPENDS_DEPS]
            task_group = task[0:task.find('.')]
            # Only track depends within same group
            if task_dep.startswith(task_group+'.'):
                dep_table[task_group][task][task_dep] = 1
        self.progress_view.progress('DepSort',3,4)
        for task_group in dep_table:
            dep_index = 0
            # Whittle down the tasks of each group
            this_pass = 1
            do_loop = True
            while (len(dep_table[task_group]) > 1) and do_loop:
                this_pass += 1
                is_change = False
                delete_list = []
                for task in dep_table[task_group]:
                    if '-' == task:
                        continue
                    if 1 == len(dep_table[task_group][task]):
                        is_change = True
                        # No more deps, so collect this task...
                        self.dep_sort_map[task] = "%s_%04d" % (task_group,dep_index)
                        dep_index += 1
                        # ... remove it from other lists as resolved ...
                        for dep_task in dep_table[task_group]:
                            if task in dep_table[task_group][dep_task]:
                                del dep_table[task_group][dep_task][task]
                        # ... and remove it from from the task group
                        delete_list.append(task)
                for task in delete_list:
                    del dep_table[task_group][task]
                if not is_change:
                    alert("ERROR:DEP_SIEVE_NO_CHANGE:%s" % task_group,self.screen)
                    do_loop = False
                    continue
        self.progress_view.progress('',4,4)
        self.progress_view.clear()
        self.help_bar_view.show_help(True)
        if len(self.dep_sort_map) != len(self.pkg_model):
            alert("ErrorDepSort:%d/%d" % (len(self.dep_sort_map),len(self.pkg_model)),self.screen)

    # Look up a dep sort order key
    def get_dep_sort(self,key):
        if key in self.dep_sort_map:
            return(self.dep_sort_map[key])
        else:
            return(key)

    # Look up a bitbake sort order key
    def get_bb_sort(self,key):
        if key in self.bb_sort_map:
            return(self.bb_sort_map[key])
        else:
            return(key)

    # Find the selected package in the main frame, update the dependency frames content accordingly
    def select(self, package_name, only_update_dependents=False):
        if not package_name:
            package_name = self.package_view.get_selected()
        # alert("SELECT:%s:" % package_name,self.screen)

        if self.filter_str != self.filter_prev:
            self.package_view.cursor_on(False)
            # Fill of the main package task list using new filter
            self.package_view.task_list = []
            for package in self.pkg_model:
                if self.filter_str:
                    if self.filter_str in package:
                        self.package_view.task_list_append(package,self)
                else:
                    self.package_view.task_list_append(package,self)
            self.package_view.sort()
            self.filter_prev = self.filter_str

            # Old position is lost, assert new position of previous task (if still filtered in)
            self.package_view.cursor_index = 0
            self.package_view.cursor_offset = 0
            self.package_view.scroll_offset = 0
            self.package_view.redraw()
            self.package_view.cursor_on(True)

        # Make sure the selected package is in view, with implicit redraw()
        if (not only_update_dependents):
            self.package_view.find(package_name)
        # In case selected name change (i.e. filter removed previous)
        package_name = self.package_view.get_selected()

        # Filter the package's dependent list to the dependent view
        self.dep_view.reset()
        for package_def in self.depends_model:
            if (package_def[DEPENDS_TYPE] == TYPE_DEP) and (package_def[DEPENDS_TASK] == package_name):
                self.dep_view.task_list_append(package_def[DEPENDS_DEPS],self)
        self.dep_view.sort()
        self.dep_view.redraw()
        # Filter the package's dependent list to the reverse dependent view
        self.reverse_view.reset()
        for package_def in self.depends_model:
            if (package_def[DEPENDS_TYPE] == TYPE_RDEP) and (package_def[DEPENDS_TASK] == package_name):
                self.reverse_view.task_list_append(package_def[DEPENDS_DEPS],self)
        self.reverse_view.sort()
        self.reverse_view.redraw()
        self.show_selected(package_name)
        self.screen.refresh()

    # The print-to-file method
    def print_deps(self,whole_group=False):
        global is_printed
        # Print the selected deptree(s) to a file
        if not is_printed:
            try:
                # Move to backup any exiting file before first write
                if os.path.isfile(print_file_name):
                    os.system('mv -f %s %s' % (print_file_name,print_file_backup_name))
            except Exception as e:
                alert(e,self.screen)
                alert('',self.screen)
        print_list = []
        selected_task = self.package_view.get_selected()
        if not selected_task:
            return
        if not whole_group:
            print_list.append(selected_task)
        else:
            # Use the presorted task_group order from 'package_view'
            task_group = selected_task[0:selected_task.find('.')+1]
            for task_obj in self.package_view.task_list:
                task = task_obj[TASK_NAME]
                if task.startswith(task_group):
                    print_list.append(task)
        with open(print_file_name, "a") as fd:
            print_max = len(print_list)
            print_count = 1
            self.progress_view.progress('Write "%s"' % print_file_name,0,print_max)
            for task in print_list:
                print_count = self.progress_view.progress('',print_count,print_max)
                self.select(task)
                self.screen.refresh();
                # Utilize the current print output model
                if print_model == PRINT_MODEL_1:
                    print("=== Dependendency Snapshot ===",file=fd)
                    print(" = Package =",file=fd)
                    print('   '+task,file=fd)
                    # Fill in the matching dependencies
                    print(" = Dependencies =",file=fd)
                    for task_obj in self.dep_view.task_list:
                        print('   '+ task_obj[TASK_NAME],file=fd)
                    print(" = Dependent Tasks =",file=fd)
                    for task_obj in self.reverse_view.task_list:
                        print('   '+ task_obj[TASK_NAME],file=fd)
                if print_model == PRINT_MODEL_2:
                    print("=== Dependendency Snapshot ===",file=fd)
                    dep_count = len(self.dep_view.task_list) - 1
                    for i,task_obj in enumerate(self.dep_view.task_list):
                        print('%s%s' % ("Dep    =" if (i==dep_count) else "        ",task_obj[TASK_NAME]),file=fd)
                    if not self.dep_view.task_list:
                        print('Dep    =',file=fd)
                    print("Package=%s" % task,file=fd)
                    for i,task_obj in enumerate(self.reverse_view.task_list):
                        print('%s%s' % ("RDep   =" if (i==0) else "        ",task_obj[TASK_NAME]),file=fd)
                    if not self.reverse_view.task_list:
                        print('RDep   =',file=fd)
                curses.napms(2000)
                self.progress_view.clear()
                self.help_bar_view.show_help(True)
            print('',file=fd)
        # Restore display to original selected task
        self.select(selected_task)
        is_printed = True

#################################################
### Load bitbake data
###

def bitbake_load(server, eventHandler, params, dep, curses_off, screen):
    global bar_len_old
    bar_len_old = 0

    # Support no screen
    def progress(msg,count,max):
        global bar_len_old
        if screen:
            dep.progress_view.progress(msg,count,max)
        else:
            if msg:
                if bar_len_old:
                    bar_len_old = 0
                    print("\n")
                print(f"{msg}: ({count} of {max})")
            else:
                bar_len = int((count*40)/max)
                if bar_len_old != bar_len:
                    print(f"{'*' * (bar_len-bar_len_old)}",end='',flush=True)
                bar_len_old = bar_len
    def clear():
        if screen:
            dep.progress_view.clear()
    def clear_curses(screen):
        if screen:
            curses_off(screen)

    #
    # Trigger bitbake "generateDepTreeEvent"
    #

    cmdline = ''
    try:
        params.updateToServer(server, os.environ.copy())
        params.updateFromServer(server)
        cmdline = params.parseActions()
        if not cmdline:
            clear_curses(screen)
            print("ERROR: nothing to do.  Use 'bitbake world' to build everything, or run 'bitbake --help' for usage information.")
            return 1,cmdline
        if 'msg' in cmdline and cmdline['msg']:
            clear_curses(screen)
            print('ERROR: ' + cmdline['msg'])
            return 1,cmdline
        cmdline = cmdline['action']
        if not cmdline or cmdline[0] != "generateDotGraph":
            clear_curses(screen)
            print("ERROR: This UI requires the -g option")
            return 1,cmdline
        ret, error = server.runCommand(["generateDepTreeEvent", cmdline[1], cmdline[2]])
        if error:
            clear_curses(screen)
            print("ERROR: running command '%s': %s" % (cmdline, error))
            return 1,cmdline
        elif not ret:
            clear_curses(screen)
            print("ERROR: running command '%s': returned %s" % (cmdline, ret))
            return 1,cmdline
    except client.Fault as x:
        clear_curses(screen)
        print("ERROR: XMLRPC Fault getting commandline:\n %s" % x)
        return 1,cmdline
    except Exception as e:
        clear_curses(screen)
        print("ERROR: in startup:\n %s" % traceback.format_exc())
        return 1,cmdline

    #
    # Receive data from bitbake
    #

    progress_total = 0
    load_bitbake = True
    quit = False
    try:
        while load_bitbake:
            try:
                event = eventHandler.waitEvent(0.25)
                if quit:
                    _, error = server.runCommand(["stateForceShutdown"])
                    clear_curses(screen)
                    if error:
                        print('Unable to cleanly stop: %s' % error)
                    break

                if event is None:
                    continue

                if isinstance(event, bb.event.CacheLoadStarted):
                    progress_total = event.total
                    progress('Loading Cache',0,progress_total)
                    continue

                if isinstance(event, bb.event.CacheLoadProgress):
                    x = event.current
                    progress('',x,progress_total)
                    continue

                if isinstance(event, bb.event.CacheLoadCompleted):
                    clear()
                    progress('Bitbake... ',1,2)
                    continue

                if isinstance(event, bb.event.ParseStarted):
                    progress_total = event.total
                    progress('Processing recipes',0,progress_total)
                    if progress_total == 0:
                        continue

                if isinstance(event, bb.event.ParseProgress):
                    x = event.current
                    progress('',x,progress_total)
                    continue

                if isinstance(event, bb.event.ParseCompleted):
                    progress('Generating dependency tree',0,3)
                    continue

                if isinstance(event, bb.event.DepTreeGenerated):
                    progress('Generating dependency tree',1,3)
                    dep.parse(event._depgraph)
                    progress('Generating dependency tree',2,3)

                if isinstance(event, bb.command.CommandCompleted):
                    load_bitbake = False
                    progress('Generating dependency tree',3,3)
                    clear()
                    if screen:
                        dep.help_bar_view.show_help(True)
                    continue

                if isinstance(event, bb.event.NoProvider):
                    clear_curses(screen)
                    print('ERROR: %s' % event)

                    _, error = server.runCommand(["stateShutdown"])
                    if error:
                        print('ERROR: Unable to cleanly shutdown: %s' % error)
                    return 1,cmdline

                if isinstance(event, bb.command.CommandFailed):
                    clear_curses(screen)
                    print('ERROR: ' + str(event))
                    return event.exitcode,cmdline

                if isinstance(event, bb.command.CommandExit):
                    clear_curses(screen)
                    return event.exitcode,cmdline

                if isinstance(event, bb.cooker.CookerExit):
                    break

                continue
            except EnvironmentError as ioerror:
                # ignore interrupted io
                if ioerror.args[0] == 4:
                    pass
            except KeyboardInterrupt:
                if shutdown == 2:
                    clear_curses(screen)
                    print("\nThird Keyboard Interrupt, exit.\n")
                    break
                if shutdown == 1:
                    clear_curses(screen)
                    print("\nSecond Keyboard Interrupt, stopping...\n")
                    _, error = server.runCommand(["stateForceShutdown"])
                    if error:
                        print('Unable to cleanly stop: %s' % error)
                if shutdown == 0:
                    clear_curses(screen)
                    print("\nKeyboard Interrupt, closing down...\n")
                    _, error = server.runCommand(["stateShutdown"])
                    if error:
                        print('Unable to cleanly shutdown: %s' % error)
                shutdown = shutdown + 1
                pass
    except Exception as e:
        # Safe exit on error
        clear_curses(screen)
        print("Exception : %s" % e)
        print("Exception in startup:\n %s" % traceback.format_exc())

    return 0,cmdline

#################################################
### main
###

SCREEN_COL_MIN = 83
SCREEN_ROW_MIN = 26

def main(server, eventHandler, params):
    global verbose
    global sort_model
    global print_model
    global is_printed
    global is_filter
    global screen_too_small

    shutdown = 0
    screen_too_small = False
    quit = False

    # Unit test with no terminal?
    if unit_test_noterm:
        # Load bitbake, test that there is valid dependency data, then exit
        screen = None
        print("* UNIT TEST:START")
        dep = DepExplorer(screen)
        print("* UNIT TEST:BITBAKE FETCH")
        ret,cmdline = bitbake_load(server, eventHandler, params, dep, None, screen)
        if ret:
            print("* UNIT TEST: BITBAKE FAILED")
            return ret
        # Test the acquired dependency data
        quilt_native_deps = 0
        quilt_native_rdeps = 0
        quilt_deps = 0
        quilt_rdeps = 0
        for i,task_obj in enumerate(dep.depends_model):
            if TYPE_DEP == task_obj[0]:
                task = task_obj[1]
                if task.startswith('quilt-native'):
                    quilt_native_deps += 1
                elif task.startswith('quilt'):
                    quilt_deps += 1
            elif TYPE_RDEP == task_obj[0]:
                task = task_obj[1]
                if task.startswith('quilt-native'):
                    quilt_native_rdeps += 1
                elif task.startswith('quilt'):
                    quilt_rdeps += 1
        # Print results
        failed = False
        if 0 < len(dep.depends_model):
             print(f"Pass:Bitbake dependency count = {len(dep.depends_model)}")
        else:
            failed = True
            print(f"FAIL:Bitbake dependency count = 0")
        if quilt_native_deps:
             print(f"Pass:Quilt-native depends count = {quilt_native_deps}")
        else:
            failed = True
            print(f"FAIL:Quilt-native depends count = 0")
        if quilt_native_rdeps:
             print(f"Pass:Quilt-native rdepends count = {quilt_native_rdeps}")
        else:
            failed = True
            print(f"FAIL:Quilt-native rdepends count = 0")
        if quilt_deps:
             print(f"Pass:Quilt depends count = {quilt_deps}")
        else:
            failed = True
            print(f"FAIL:Quilt depends count = 0")
        if quilt_rdeps:
             print(f"Pass:Quilt rdepends count = {quilt_rdeps}")
        else:
            failed = True
            print(f"FAIL:Quilt rdepends count = 0")
        print("* UNIT TEST:STOP")
        return failed

    # Help method to dynamically test parent window too small
    def check_screen_size(dep, active_package):
        global screen_too_small
        rows, cols = screen.getmaxyx()
        if (rows >= SCREEN_ROW_MIN) and (cols >= SCREEN_COL_MIN):
            if screen_too_small:
                # Now big enough, remove error message and redraw screen
                dep.draw_frames()
                active_package.cursor_on(True)
                screen_too_small = False
            return True
        # Test on App init
        if not dep:
            # Do not start this app if screen not big enough
            curses.endwin()
            print("")
            print("ERROR(Taskexp_cli): Mininal screen size is %dx%d" % (SCREEN_COL_MIN,SCREEN_ROW_MIN))
            print("Current screen is Cols=%s,Rows=%d" % (cols,rows))
            return False
        # First time window too small
        if not screen_too_small:
            active_package.cursor_on(False)
            dep.screen.addstr(0,2,'[BIGGER WINDOW PLEASE]', curses.color_pair(CURSES_WARNING) | curses.A_BLINK)
            screen_too_small = True
        return False

    # Helper method to turn off curses mode
    def curses_off(screen):
        if not screen: return
        # Safe error exit
        screen.keypad(False)
        curses.echo()
        curses.curs_set(1)
        curses.endwin()

        if unit_test_results:
            print('\nUnit Test Results:')
            for line in unit_test_results:
                print(" %s" % line)

    #
    # Initialize the ncurse environment
    #

    screen = curses.initscr()
    try:
        if not check_screen_size(None, None):
            exit(1)
        try:
            curses.start_color()
            curses.use_default_colors();
            curses.init_pair(0xFF, curses.COLOR_BLACK, curses.COLOR_WHITE);
            curses.init_pair(CURSES_NORMAL, curses.COLOR_WHITE, curses.COLOR_BLACK)
            curses.init_pair(CURSES_HIGHLIGHT, curses.COLOR_WHITE, curses.COLOR_BLUE)
            curses.init_pair(CURSES_WARNING, curses.COLOR_WHITE, curses.COLOR_RED)
        except:
            curses.endwin()
            print("")
            print("ERROR(Taskexp_cli): Requires 256 colors. Please use this or the equivalent:")
            print("  $ export TERM='xterm-256color'")
            exit(1)

        screen.keypad(True)
        curses.noecho()
        curses.curs_set(0)
        screen.refresh();
    except Exception as e:
        # Safe error exit
        curses_off(screen)
        print("Exception : %s" % e)
        print("Exception in startup:\n %s" % traceback.format_exc())
        exit(1)

    try:
        #
        # Instantiate the presentation layers
        #

        dep = DepExplorer(screen)

        #
        # Prepare bitbake
        #

        # Fetch bitbake dependecy data
        ret,cmdline = bitbake_load(server, eventHandler, params, dep, curses_off, screen)
        if ret: return ret

        #
        # Preset the views
        #

        # Cmdline example = ['generateDotGraph', ['acl', 'zlib'], 'build']
        primary_packages = cmdline[1]
        dep.package_view.set_primary(primary_packages)
        dep.dep_view.set_primary(primary_packages)
        dep.reverse_view.set_primary(primary_packages)
        dep.help_box_view.set_primary(primary_packages)
        dep.help_bar_view.show_help(True)
        active_package = dep.package_view
        active_package.cursor_on(True)
        dep.select(primary_packages[0]+'.')
        if unit_test:
            alert('UNIT_TEST',screen)

        # Help method to start/stop the filter feature
        def filter_mode(new_filter_status):
            global is_filter
            if is_filter == new_filter_status:
                # Ignore no changes
                return
            if not new_filter_status:
                # Turn off
                curses.curs_set(0)
                #active_package.cursor_on(False)
                active_package = dep.package_view
                active_package.cursor_on(True)
                is_filter = False
                dep.help_bar_view.show_help(True)
                dep.filter_str = ''
                dep.select('')
            else:
                # Turn on
                curses.curs_set(1)
                dep.help_bar_view.show_help(False)
                dep.filter_view.clear()
                dep.filter_view.show(True)
                dep.filter_view.show_prompt()
                is_filter = True

        #
        # Main user loop
        #

        while not quit:
            if is_filter:
                dep.filter_view.show_prompt()
            if unit_test:
                c = unit_test_action(active_package)
            else:
                c = screen.getch()
            ch = chr(c)

            # Do not draw if window now too small
            if not check_screen_size(dep,active_package):
                continue

            if verbose:
                if c == CHAR_RETURN:
                    screen.addstr(0, 4, "|%3d,CR |" % (c))
                else:
                    screen.addstr(0, 4, "|%3d,%3s|" % (c,chr(c)))

            # pre-map alternate filter close keys
            if is_filter and (c == CHAR_ESCAPE):
                # Alternate exit from filter
                ch = '/'
                c = ord(ch)

            # Filter and non-filter mode command keys
            # https://docs.python.org/3/library/curses.html
            if c in (curses.KEY_UP,CHAR_UP):
                active_package.line_up()
                if active_package == dep.package_view:
                    dep.select('',only_update_dependents=True)
            elif c in (curses.KEY_DOWN,CHAR_DOWN):
                active_package.line_down()
                if active_package == dep.package_view:
                    dep.select('',only_update_dependents=True)
            elif curses.KEY_PPAGE == c:
                active_package.page_up()
                if active_package == dep.package_view:
                    dep.select('',only_update_dependents=True)
            elif curses.KEY_NPAGE == c:
                active_package.page_down()
                if active_package == dep.package_view:
                    dep.select('',only_update_dependents=True)
            elif CHAR_TAB == c:
                # Tab between boxes
                active_package.cursor_on(False)
                if active_package == dep.package_view:
                    active_package = dep.dep_view
                elif active_package == dep.dep_view:
                    active_package = dep.reverse_view
                else:
                    active_package = dep.package_view
                active_package.cursor_on(True)
            elif curses.KEY_BTAB == c:
                # Shift-Tab reverse between boxes
                active_package.cursor_on(False)
                if active_package == dep.package_view:
                    active_package = dep.reverse_view
                elif active_package == dep.reverse_view:
                    active_package = dep.dep_view
                else:
                    active_package = dep.package_view
                active_package.cursor_on(True)
            elif (CHAR_RETURN == c):
                # CR to select
                selected = active_package.get_selected()
                if selected:
                    active_package.cursor_on(False)
                    active_package = dep.package_view
                    filter_mode(False)
                    dep.select(selected)
                else:
                    filter_mode(False)
                    dep.select(primary_packages[0]+'.')

            elif '/' == ch: # Enter/exit dep.filter_view
                if is_filter:
                    filter_mode(False)
                else:
                    filter_mode(True)
            elif is_filter:
                # If in filter mode, re-direct all these other keys to the filter box
                result = dep.filter_view.input(c,ch)
                dep.filter_str = dep.filter_view.filter_str
                dep.select('')

            # Non-filter mode command keys
            elif 'p' == ch:
                dep.print_deps(whole_group=False)
            elif 'P' == ch:
                dep.print_deps(whole_group=True)
            elif 'w' == ch:
                # Toggle the print model
                if print_model == PRINT_MODEL_1:
                    print_model = PRINT_MODEL_2
                else:
                    print_model = PRINT_MODEL_1
            elif 's' == ch:
                # Toggle the sort model
                if sort_model == SORT_DEPS:
                    sort_model = SORT_ALPHA
                elif sort_model == SORT_ALPHA:
                    if SORT_BITBAKE_ENABLE:
                        sort_model = TASK_SORT_BITBAKE
                    else:
                        sort_model = SORT_DEPS
                else:
                    sort_model = SORT_DEPS
                active_package.cursor_on(False)
                current_task = active_package.get_selected()
                dep.package_view.sort()
                dep.dep_view.sort()
                dep.reverse_view.sort()
                active_package = dep.package_view
                active_package.cursor_on(True)
                dep.select(current_task)
                # Announce the new sort model
                alert("SORT=%s" % ("ALPHA" if (sort_model == SORT_ALPHA) else "DEPS"),screen)
                alert('',screen)

            elif 'q' == ch:
                quit = True
            elif ch in ('h','?'):
                dep.help_box_view.show_help(True)
                dep.select(active_package.get_selected())

            #
            # Debugging commands
            #

            elif 'V' == ch:
                verbose = not verbose
                alert('Verbose=%s' % str(verbose),screen)
                alert('',screen)
            elif 'R' == ch:
                screen.refresh()
            elif 'B' == ch:
                # Progress bar unit test
                dep.progress_view.progress('Test',0,40)
                curses.napms(1000)
                dep.progress_view.progress('',10,40)
                curses.napms(1000)
                dep.progress_view.progress('',20,40)
                curses.napms(1000)
                dep.progress_view.progress('',30,40)
                curses.napms(1000)
                dep.progress_view.progress('',40,40)
                curses.napms(1000)
                dep.progress_view.clear()
                dep.help_bar_view.show_help(True)
            elif 'Q' == ch:
                # Simulated error
                curses_off(screen)
                print('ERROR: simulated error exit')
                return 1

        # Safe exit
        curses_off(screen)
    except Exception as e:
        # Safe exit on error
        curses_off(screen)
        print("Exception : %s" % e)
        print("Exception in startup:\n %s" % traceback.format_exc())

    # Reminder to pick up your printed results
    if is_printed:
        print("")
        print("You have output ready!")
        print("  * Your printed dependency file is: %s" % print_file_name)
        print("  * Your previous results  saved in: %s" % print_file_backup_name)
        print("")