Subversion Repositories thor

#include "types.h"
#include "proto.h"
 
extern JCB *IOFocusNdx;
extern int IOFocusTbl[4];
extern int iof_sema;
 
hMBX hFocusSwitchMbx = -1;
 
void FocusSwitcher()
{
     int d1,d2,d3;
 
     if firstcall {
         FMTK_AllocMbx(&hFocusSwitchMbx);
     }
     forever {
         FMTK_WaitMsg(hFocusSwitchMbx, &d1, &d2, &d3, 0x7FFFFFFFFFFFFFFFL);
         SwitchIOFocus();
     }
}
 
 
void ForceIOFocus(JCB *j)
{
    RequestIOFocus(j);   // In case it isn't requested yet.
     if (LockSemaphore(&iof_sema,-1)) {
        if (j != IOFocusNdx) {
            CopyScreenToVirtualScreen();
            j->pVidMem = j->pVirtVidMem;
            IOFocusNdx = j;
            j->pVidMem = 0xFFD00000;
            CopyVirtualScreenToScreen();
        }
        UnlockSemaphore(&iof_sema);
     }
}
 
 
// First check if it's even possible to switch the focus to another
// task. The I/O focus list could be empty or there may be only a
// single task in the list. In either case it's not possible to
// switch.
void SwitchIOFocus()
{
     JCB *j, *p;
 
     if (LockSemaphore(&iof_sema,-1)) {
         j = IOFocusNdx;
         if (j) {
             p = IOFocusNdx->iof_next;
             if (p <> IOFocusNdx) {
                 if (p) {
                     CopyScreenToVirtualScreen();
                     j->pVidMem = j->pVirtVidMem;
                     IOFocusNdx = p;
                     p->pVidMem = 0xFFD00000;
                     CopyVirtualScreenToScreen();
                 }
             }
         }
        UnlockSemaphore(&iof_sema);
     }
}
 
//-----------------------------------------------------------------------------
// The I/O focus list is an array indicating which jobs are requesting the
// I/O focus. The I/O focus is user controlled by pressing ALT-TAB on the
// keyboard.
//-----------------------------------------------------------------------------
 
void RequestIOFocus(JCB *j)
{
     int nj;
     int stat;
 
     nj = j->number;
     if (LockSemaphore(&iof_sema,-1)) {
        stat = (IOFocusTbl[0] >> nj) & 1;
        if (!stat) {
           if (IOFocusNdx==null) {
               IOFocusNdx = j;
               j->iof_next = j;
               j->iof_prev = j;
           }
           else {
               j->iof_prev = IOFocusNdx->iof_prev;
               j->iof_next = IOFocusNdx;
               IOFocusNdx->iof_prev->iof_next = j;
               IOFocusNdx->iof_prev = j;
           }
           IOFocusTbl[0] |= (1 << nj);
        }
        UnlockSemaphore(&iof_sema);
     }
}
 
//-----------------------------------------------------------------------------
// Release the IO focus for the current job.
//-----------------------------------------------------------------------------
void ReleaseIOFocus()
{
     ForceReleaseIOFocus(GetJCBPtr());
}
 
//-----------------------------------------------------------------------------
// Releasing the I/O focus causes the focus to switch if the running job
// had the I/O focus.
// ForceReleaseIOFocus forces the release of the IO focus for a job
// different than the one currently running.
//-----------------------------------------------------------------------------
 
void ForceReleaseIOFocus(JCB * j)
{
     JCB *p;
 
     if (LockSemaphore(&iof_sema,-1)) {
         if (IOFocusTbl[0] & (1 << (int)j->number)) {
             IOFocusTbl[0] &= ~(1 << j->number);
             if (j == IOFocusNdx)
                SwitchIOFocus();
             p = j->iof_next;
             if (p) {
                  if (p <> j) {
                        p->iof_prev = j->iof_prev;
                        j->iof_prev->iof_next = p;
                  } 
                  else {
                       IOFocusNdx = null;
                  }
                  j->iof_next = null;
                  j->iof_prev = null;
             }
         }
        UnlockSemaphore(&iof_sema);
     }
}
 
void CopyVirtualScreenToScreen()
{
     short int *p, *q;
     JCB *j;
     int nn, pos;
 
     j = IOFocusNdx;
     p = j->pVidMem;
     q = j->pVirtVidMem;
     nn = j->VideoRows * j->VideoCols;
     for (; nn >= 0; nn--)
         p[nn] = q[nn];
    pos = j->CursorRow * j->VideoCols + j->CursorCol;
    SetVideoReg(11,pos);
}
 
void CopyScreenToVirtualScreen()
{
     short int *p, *q;
     JCB *j;
     int nn;
 
     j = IOFocusNdx;
     p = j->pVidMem;
     q = j->pVirtVidMem;
     nn = j->VideoRows * j->VideoCols;
     for (; nn >= 0; nn--)
         q[nn] = p[nn];
}