multishell

function preReq ()
    local col=term.isColour()
    local requiresPocket=false
    if requiresPocket then
        if col and pocket then
            return true
        end
    else
        if col then
            return true
        end
    end
    return false
end
-------------------------------------------------------------------------
--diagnostic stuff
oldOsVersion=os.version
os.version = function()
    return oldOsVersion().." & X project"
end
------------------------------------------------------------------------
function multishells()
    -- Setup process switching
    local parentTerm = term.current()
    local w,h = parentTerm.getSize()

    local tProcesses = {}
    local nCurrentProcess = nil
    local nRunningProcess = nil
    local multishell = {}
    local nLastProcess = 0

    ---------------------------------------------------------------------
    ---Diagnostic stuff

    function freeSpace (space)
        for i=1,space,1 do
            write(" ")
        end
    end

    function multishell.printProcesses()
        multishell.printTable(tProcesses,1,"window","terminal")
    end
    function multishell.printStatus(ID)
        print (coroutine.status(tProcesses[ID].co))
    end



    function multishell.printTable (tab,dep,...)
        local filter={...}

        if dep==nil then
        dep=1
        end
        print ("")
        freeSpace(dep-1)
        print ("{")
        for i,v in pairs (tab) do
            local filMatch=false
            for j,w in pairs (filter) do
                if w==i then
                    filMatch=true
                end
            end
            if not filMatch then
                freeSpace(dep)
                write (i.."    ")
                if type(v) =="table" then
                    dep=dep+1
                    multishell.printTable(v,dep,unpack(filter))
                    dep=dep-1
                else
                    print (v)
                end
                local curX,curY = term.getCursorPos()
                local sizeX,sizeY = term.getSize()
                if curY == sizeY then
                    os.pullEvent("key")
                end
            end
        end
        freeSpace(dep-1)
        print ("}")
    end

    ----------------------------------------------------------------------

    local function selectProcess( n )

        if nCurrentProcess ~= n then
            if tProcesses[n] ~= nil then
                if nCurrentProcess then
                    local tOldProcess = tProcesses[ nCurrentProcess ]
                    tOldProcess.window.setVisible( false )
                end
                nCurrentProcess = n
                if nCurrentProcess then
                    local tNewProcess = tProcesses[ nCurrentProcess ]
                    tNewProcess.window.setVisible( true )
                    tNewProcess.bInteracted = true
                end
            end
        end
    end

    local function setProcessTitle( n, sTitle )
        tProcesses[ n ].sTitle = sTitle
    end

    function resumeProcess( nProcess, sEvent, ... )
        if multishell.isValid(nProcess) then
            local tProcess = tProcesses[ nProcess ]
            --local sFilter = tProcess.sFilter

        --  if sFilter == nil or sFilter == sEvent or sEvent == "terminate" then
                local nPreviousProcess = nRunningProcess
                nRunningProcess = nProcess

                term.redirect( tProcess.terminal )

                local ok, result = coroutine.resume( tProcess.co, sEvent, ... )

                tProcess.terminal = term.current()

                if ok then
                    tProcess.sFilter = result
                else
                    printError( result )
                end
                nRunningProcess = nPreviousProcess
            --end
        --  else
        --  print ("you failed")
        --  end
        else
            print ("you failed")
        end
    end

    function multishell.killProcess (ID)
        if ID~=1 and multishell.isValid(ID) then
            resumeProcess( ID, "terminate")
        end
    end

    local function launchProcess( tProgramEnv, sProgramPath, ... )

        if  not tProgramEnv.multishell then
            tProgramEnv.multishell=multishell
        end
        if  not tProgramEnv.shell then
            tProgramEnv.shell=shell
        end
        local tProgramArgs = { ... }
        nLastProcess = nLastProcess + 1
        local nProcess = nLastProcess
        local tProcess = {}
        tProcess.sTitle = fs.getName( sProgramPath )
        tProcess.window = window.create( parentTerm, 1, 1, w, h, false )
        tProcess.co = coroutine.create( function()
            --if nLastProcess~=1 then
            --      parallel.waitForAny(
            --      function() os.run( tProgramEnv, sProgramPath, unpack( tProgramArgs ) ) end,
            --      function() endProcess(nProcess) end
            --      )
            --else
            os.run( tProgramEnv, sProgramPath, unpack( tProgramArgs ) )
            --end
            if not tProcess.bInteracted then
                term.setCursorBlink( false )
                print( "Press any key to continue" )
                os.pullEvent( "char" )
            end
            if nCurrentProcess==nProcess then
                selectProcess (1)
            end
            os.queueEvent("check_Processes")
        end )

    --  tProcess.sFilter = nil
        tProcess.terminal = tProcess.window
        tProcess.bInteracted = false
        tProcesses[ nProcess ] = tProcess
        resumeProcess( nProcess )
        return nProcess
    end

    local function cullProcess( nProcess )
        --if nProcess==nil then
        --  return
        --end
        local tProcess = tProcesses[ nProcess ]
        if tProcess==nil then
            return
        end
        --printTable(tProcess)
        --local cor = tProcess.co
        --print (cor)
        --print (coroutine.status(cor))
        --
        --multishell.printTable(tProcess,1,"window","terminal")
        --print (coroutine.status(tProcess.co))
        --if tProcesses[nProcess].active==false then
        if coroutine.status( tProcess.co ) == "dead" then
            if nCurrentProcess==nProcess then
                selectProcess (1)
            end
            tProcesses[nProcess] = nil
        end
    end

    local function cullProcesses()
        --local culled = false
        --for n=multishell.getCount(),1,-1 do
        --culled = culled or cullProcess( n )
        --end
        --return culled
         for i=1, nLastProcess do
            if multishell.isValid(i) then
                cullProcess( i )
            end
        end
    end

    function multishell.checkProcesses()
        cullProcesses()
    end

    function multishell.isValid(id)
        if tProcesses[id]~=nil then
            return true
        end
        return false
    end

    function multishell.getProcesses()
        local procArray = {}
        local index=1
        for id,proc in pairs(tProcesses) do
            procArray[index]={}
            procArray[index].id=id
            procArray[index].title=proc.sTitle
            index=index+1
        end
        return procArray
    end



    function multishell.getFocus()
        return nCurrentProcess
    end

    function multishell.setFocus( n )
        if multishell.isValid(n) then
            selectProcess( n )
            return true
        end
        return false
    end
    function multishell.getLastID()
        return nLastProcess
    end
    function multishell.getTitle( n )
        if multishell.isValid(n) then
            return tProcesses[n].sTitle
        end
        return nil
    end

    function multishell.setTitle( n, sTitle )
        if multishell.isValid(n) then
            setProcessTitle( n, sTitle )
        end
    end

    function multishell.getCurrent()
        return nRunningProcess
    end

    function multishell.launch( tProgramEnv, sProgramPath, ... )
        local previousTerm = term.current()
        local nResult = launchProcess( tProgramEnv, sProgramPath, ... )
        term.redirect( previousTerm )
        return nResult
    end

    function multishell.getCount()
        local count = 0

        for id, proc in pairs(tProcesses) do
            count = count + 1
        end
        return count
    end

    local jump={false,false}


    -- Begin
    parentTerm.clear()
    selectProcess( launchProcess( {
        ["shell"] = shell,
        ["multishell"] = multishell
    }, "/rom/programs/shell" ) )

    -- Run processes
    while multishell.isValid(1) do
        -- Get the event
        if jump[1] and jump[2] then
            selectProcess(1)
            --print ("jumped")
        end
        local tEventData = { os.pullEventRaw() }
        local sEvent = tEventData[1]
        if sEvent == "check_Processes" then
            cullProcesses()
        elseif sEvent == "terminate" then
            if nCurrentProcess ~= 1 then
                resumeProcess( nCurrentProcess, unpack( tEventData ) )
                cullProcesses()
            end

        elseif sEvent == "tabChangeDisable" then
            jump[1]=false
            jump[2]=false

        elseif sEvent == "key" then
            if jump[1]==false and tEventData[2]==29 then
                jump[1]=true
                os.queueEvent("tabChangeDisable")
            elseif jump[2]==false and tEventData[2]==56 then
                jump[2]=true
                os.queueEvent("tabChangeDisable")
            end

            resumeProcess( nCurrentProcess, unpack( tEventData ) )


        elseif sEvent == "char" or sEvent == "paste" then

            -- Keyboard event
            -- Passthrough to current process

            resumeProcess( nCurrentProcess, unpack( tEventData ) )

        elseif sEvent == "mouse_click" or sEvent == "mouse_drag" or sEvent == "mouse_scroll" then
            -- Click event
            local button, x, y = tEventData[2], tEventData[3], tEventData[4]
            -- Passthrough to current process
            resumeProcess( nCurrentProcess, sEvent, button, x, y )

        elseif sEvent=="send_event" then
            if multishell.isValid(tEventData[2]) then
                local target = tEventData[2]
                tEventData[2] = nRunningProcess
                resumeProcess( target, unpack( tEventData ) )
            end
        else
            -- Other event
            -- Passthrough to all processes
            local nLimit = nLastProcess -- Storing this ensures any new things spawned don't get the event
            for n=1,nLimit do
                if multishell.isValid(n) then
                    resumeProcess( n, unpack( tEventData ) )
                end
            end
        end
    end

    -- Shutdown
    term.redirect( parentTerm )
end
-----------------------------------------------------------------------------------
local function run(mainFunc, errFunc)
    local oldOsShutdown, oldCoroutineStatus = os.shutdown, coroutine.status
    if type(mainFunc) ~= "function" then
            error("Nothing to run", 2)
    end


  local function clearScreen()
        term.redirect(type(term.native) == "function" and term.native() or term.native)
        term.setBackgroundColour(colours.black)
        term.setTextColour(colours.white)
        term.setCursorPos(1, 1)
        term.setCursorBlink(false)
        term.clear()
  end
  local function coroutineStatusOverride(...)
        return "dead"
  end

  local function osShutdownOverride()

        clearScreen()

        rednet.close()
        os.unloadAPI("rednet")
        os.loadAPI("/rom/apis/rednet")

        rawset(os, "shutdown", oldOsShutdown)
        rawset(coroutine, "status", oldCoroutineStatus)


        local ok, err = pcall(mainFunc)

        if not ok then
            clearScreen()
            pcall( function()
                if type(errFunc) == "function" then
                  errFunc(err)
                else
                  printError(err)
                  print("Press any key to continue")
                  os.pullEvent("key")
                end
          end )
        end

        os.sleep(2)
        os.shutdown()

  end

  rawset(os, "shutdown", osShutdownOverride)
  rawset(coroutine, "status", coroutineStatusOverride)
end

if preReq() then
    run(multishells)
else
    print("You need advanced pocket computer to run X project")
end