Example #1
0
/*------------------------------------ senseXProcessQueue ---*/
static void
senseXProcessQueue(SenseXData * xx)
{
    if (xx && (! xx->fStopping))
    {
        short prevLock;
        
        switch (xx->fState)
        {
            case kBetweenMessages:
                prevLock = lockout_set(1);
                xx->fState = kAwaitingFirstMessage;
                lockout_set(prevLock);
                break;
                
            case kAfterSecondMessage:
                prevLock = lockout_set(1);
                outlet_int(xx->fResultOut, 0);
                xx->fState = kAwaitingFirstMessage;
                lockout_set(prevLock);
                break;
                
            default:
                break;
                
        }
#if USE_EVNUM
        evnum_incr();
#endif /* USE_EVNUM */
    }
} // senseXProcessQueue
Example #2
0
/*------------------------------------ spaceballPerformWriteCommand ---*/
void
spaceballPerformWriteCommand(SpaceballData * xx,
                             const short     numBytesToSend,
                             unsigned char * bytesToFollow)
{
    unsigned char dataValue;
    static t_atom dataList[OUT_BUFFER_SIZE];

    if (xx)
    {
        short prevLock = lockout_set(1);

        /* Make sure serialX is in 'chunk' mode. */
        if (! xx->fChunkPulseSent)
        {
            outlet_bang(xx->fChunkSendOut);
            xx->fChunkPulseSent = true;
        }
        /* Send data. */
        for (short ii = 0; ii < numBytesToSend; ++ii, ++bytesToFollow)
        {
            dataValue = *bytesToFollow;
            atom_setlong(dataList + ii, dataValue);
        }
        outlet_list(xx->fDataSendOut, 0L, numBytesToSend, dataList);
        lockout_set(prevLock);
    }
} // spaceballPerformWriteCommand
Example #3
0
void match_set(t_match *x, t_symbol *s, short ac, t_atom *av)
{
	t_atom *temp;
	char savelock;

	if (!ac)
		return;

	if (ac != x->m_size)
		temp = (t_atom *)sysmem_newptr((long)ac * sizeof(t_atom));
	else
		temp = x->m_want;
	match_setwant(temp,ac,av);
	savelock = lockout_set(1);
	critical_enter(x->m_critical);
	if (ac != x->m_size) {
		match_freebytes(x);
		x->m_want = temp;
		x->m_seen = (t_atom *)sysmem_newptr((long)ac * sizeof(t_atom));
	}
	x->m_size = ac;
	match_clear(x);
	lockout_set(savelock);
	critical_exit(x->m_critical);
}	
Example #4
0
void LCD_drag(Lcd *x, Point pt, short button_down)
{
	Rect	r;
	short		slider;
	Atom	aList[2];
	short 	way;
	
	EnterCallback();
	
#ifdef debug
	post("¥LCD_drag - start");
#endif
	r = x->lcd_box.b_rect;
	
	if (x->local)
	{
		if (button_down) {
			LCD_MoveTo(x,(long)(x->lcd_where.h),(long)(x->lcd_where.v));
			LCD_LineTo(x,(long)(pt.h-r.left),(long)(pt.v-r.top));
		}
		else
			x->lcd_shiftClick = false;
	}
	
	LCD_posToRC(x,pt);

	SETLONG(&aList[0],(long)(pt.h-r.left));
	SETLONG(&aList[1],(long)(pt.v-r.top));
	/* lockouts added by DDZ 12/14/92 */
	way = lockout_set(1);
	outlet_list(x->lcd_outlet,0L,2,aList);
	lockout_set(way);
	ExitCallback();
}
Example #5
0
void LCD_click(Lcd *x, Point where, short modifiers)
{
	short	i;
	Rect	r;
	Atom	aList[2];
	short		way;
	
	EnterCallback();
	
#ifdef debug
	post("¥LCD_click - start");
#endif
	r = x->lcd_box.b_rect;
	x->lcd_shiftClick = modifiers&shiftKey;

	if (x->local)
		LCD_MoveTo(x,(long)(where.h-r.left),(long)(where.v-r.top));

	LCD_posToRC(x,where);
	wind_drag((void *)LCD_drag,x,where);

	SETLONG(&aList[0],(long)(where.h-r.left));
	SETLONG(&aList[1],(long)(where.v-r.top));
	/* lockouts added by DDZ 12/14/92 */
	way = lockout_set(1);
	outlet_list(x->lcd_outlet,0L,2,aList);
	lockout_set(way);
	ExitCallback();
}	/* ms_click */
Example #6
0
/*------------------------------------ senseXDoMessage ---*/
void
senseXDoMessage(SenseXData * xx)
{
    if (! xx->fStopping)
    {
        short prevLock;

        switch (xx->fState)
        {
            case kAwaitingFirstMessage:
                prevLock = lockout_set(1);
                if (0 > xx->fOnDelay)
                {
                    clock_delay(xx->fPollClock, xx->fOnDelay);
                    xx->fState = kBetweenMessages;
                }
                else
                {
                    outlet_int(xx->fResultOut, 1);
                    if (0 > xx->fOffDelay)
                    {
                        clock_delay(xx->fPollClock, xx->fOffDelay);
                        xx->fState = kAfterSecondMessage;
                    }
                    else
                    {
                        outlet_int(xx->fResultOut, 0);
                        xx->fState = kAwaitingFirstMessage;
                    }
                }
                lockout_set(prevLock);
                break;

            case kBetweenMessages:
                prevLock = lockout_set(1);
                outlet_int(xx->fResultOut, 1);
                clock_unset(xx->fPollClock);
                if (0 < xx->fOffDelay)
                {
                    clock_delay(xx->fPollClock, xx->fOffDelay);
                    xx->fState = kAfterSecondMessage;
                }
                else
                {
                    outlet_int(xx->fResultOut, 0);
                    xx->fState = kAwaitingFirstMessage;
                }
                lockout_set(prevLock);
                break;

            default:
                break;
                
        }
    }
} // senseXDoMessage
Example #7
0
/*------------------------------------ processErrorQueue ---*/
static void
processErrorQueue(UdpObjectData * xx)
{
    if (xx)
    {
        short prev_lock = lockout_set(1);

        outlet_bang(xx->fErrorBangOut);
        lockout_set(prev_lock);
#if USE_EVNUM
        evnum_incr();
#endif /* USE_EVNUM */
    }
} // processErrorQueue
Example #8
0
/*------------------------------------ x10ProcessQueue ---*/
static void
x10ProcessQueue(X10ControlData * xx)
{
    if (xx && (! xx->fStopping))
    {
        short prevLock = lockout_set(1);
        
        outlet_bang(xx->fPollerOut);
        clock_delay(xx->fPollClock, xx->fPollRate);
        lockout_set(prevLock);
#if USE_EVNUM
        evnum_incr();
#endif /* USE_EVNUM */
    }
} // x10ProcessQueue
Example #9
0
static short AcquireLock(OTUDP *x) {
	// Mutual exclusion:  Make sure that neither Max not Open Transport will interrupt us

	int i;
	short oldLockout;

	
	oldLockout = lockout_set(1);
	OTEnterNotifier(x->o_udp_ep);

#define TOO_MANY_SPINS 1
	i = 0;
	while (OTAcquireLock(&(x->o_readlock)) == false) {
		if ((++i) > TOO_MANY_SPINS) {
			error("¥ otudp_read: OTAcquireLock keeps failing!");
		}
	}

	if (x->o_semaphoreTest != 0) {
		++(x->o_semaphoreTestFailureCount);
		if (x->o_semaphoreTestFailureCount == 1 || (x->o_semaphoreTestFailureCount % 100) == 0) {
			error("¥ otudp_read: new semaphore test failed (%d times)");
		}
	}

	++(x->o_semaphoreTest);
	return oldLockout;
}
Example #10
0
/*------------------------------------ spaceballProcessQueue ---*/
static void
spaceballProcessQueue(SpaceballData * xx)
{
    if (xx && (! xx->fStopping))
    {
        short prevLock = lockout_set(1);
        
        if (! xx->fReset)
        {
            static unsigned char resetString[] = "@RESET\015\015";
            
            if (! xx->fDelayCounter)
            {
                spaceballPerformWriteCommand(xx, sizeof(resetString) - 1, resetString);
                ++xx->fDelayCounter;
            }
            else if (xx->fDelayCounter++ >= xx->fResetDuration)
            {
                xx->fReset = true;
                xx->fDelayCounter = 0;
            }
        }
        else if (! xx->fInited)
        {
            static unsigned char initString[] =
                                            "CB\015NT\015FR?\015P@r@r\015MSSV\015Z\015BcCcCc\015";
            
            if (! xx->fDelayCounter)
            {
                spaceballPerformWriteCommand(xx, sizeof(initString) - 1, initString);
                spaceballZeroValues(xx);
                ++xx->fDelayCounter;
            }
            else if (xx->fDelayCounter++ >= xx->fInitDuration)
            {
                xx->fInited = true;
                xx->fDelayCounter = 0;
            }
        }
        outlet_bang(xx->fSampleBangOut);
        clock_delay(xx->fPollClock, xx->fPollRate);
        lockout_set(prevLock);
#if USE_EVNUM
        evnum_incr();
#endif /* USE_EVNUM */
    }
} // spaceballProcessQueue
Example #11
0
static void ReleaseLock(OTUDP *x, short oldLockout) {
	if (x->o_semaphoreTest != 1) {
		error("¥ otudp_read: about to release lock, but semaphoreTest is %ld", x->o_semaphoreTest);
	}
	--(x->o_semaphoreTest);

	OTClearLock(&(x->o_readlock));
	OTLeaveNotifier(x->o_udp_ep);
	lockout_set(oldLockout);
}
Example #12
0
static short AcquireLock(OTTCP *x) {
	// Mutual exclusion:  Make sure that neither Max not Open Transport will interrupt us

	int i;
	short oldLockout;

	
	oldLockout = lockout_set(1);
	OTEnterNotifier(x->o_tcp_ep);

#define TOO_MANY_SPINS 1
	i = 0;
	while (OTAcquireLock(&(x->o_readlock)) == false) {
		if ((++i) > TOO_MANY_SPINS) {
			ouchstring("OTAcquireLock keeps failing inside ottcp_read!");
		}
	}

	return oldLockout;
}
Example #13
0
static void ReleaseLock(OTTCP *x, short oldLockout) {
	OTClearLock(&(x->o_readlock));
	OTLeaveNotifier(x->o_tcp_ep);
	lockout_set(oldLockout);
}
Example #14
0
/*------------------------------------ spaceballProcessResponse ---*/
void
spaceballProcessResponse(SpaceballData * xx,
                         long            rr)
{
    if (xx)
    {
        short         prevLock = lockout_set(1);
        unsigned char incoming = static_cast<unsigned char>(rr & 0x00ff);
        short         slot = xx->fBufferPos;

        if (xx->fNextCharEscaped)
        {
            xx->fNextCharEscaped = false;
            if (kSpaceballResponseEscape != incoming)
            {
                incoming &= 0x001f;
            }
            if (IN_BUFFER_SIZE > slot)
            {
                xx->fBuffer[slot] = incoming;
                ++xx->fBufferPos;
            }
            else
            {
                xx->fBufferPos = 0;
                xx->fSkipping = true;
            }
        }
        else if (kSpaceballResponseEndCommand == incoming)
        {
            if (xx->fSkipping)
            {
                xx->fSkipping = false;
            }
            else if (0 < xx->fBufferPos)
            {
                spaceballProcessPacket(xx);
            }
            xx->fBufferPos = 0;
        }
        else if (kSpaceballResponseNewLine == incoming)
        {
            if (! xx->fSkipping)
            {
                if (slot)
                {
                    if (IN_BUFFER_SIZE > slot)
                    {
                        xx->fBuffer[slot] = incoming;
                        ++xx->fBufferPos;
                    }
                    else
                    {
                        xx->fBufferPos = 0;
                        xx->fSkipping = true;
                    }
                }
            }
        }
        else if (kSpaceballResponseXoff == incoming)
        {
            xx->fOutputBlocked = true;
        }
        else if (kSpaceballResponseXon == incoming)
        {
            xx->fOutputBlocked = false;
        }
        else if (kSpaceballResponseEscape == incoming)
        {
            if (! xx->fSkipping)
            {
                xx->fNextCharEscaped = true;
            }
        }
        else if (! xx->fSkipping)
        {
            if (IN_BUFFER_SIZE > slot)
            {
                xx->fBuffer[slot] = incoming;
                ++xx->fBufferPos;
            }
            else
            {
                xx->fBufferPos = 0;
                xx->fSkipping = true;
            }
        }
        lockout_set(prevLock);
    }
} // spaceballProcessResponse