void CSerialDummy::transmitByte(Bit8u val, bool first) {

	if(first) setEvent(SERIAL_THR_EVENT, bytetime/10); 
	else setEvent(SERIAL_TX_EVENT, bytetime);

#ifdef CHECKIT_TESTPLUG
	loopbackdata=val;
#endif
}

void CNullModem::transmitByte (Bit8u val, bool first) {
 	// transmit it later in THR_Event
	if (first) setEvent(SERIAL_THR_EVENT, bytetime/8);
	else setEvent(SERIAL_TX_EVENT, bytetime);

	// disable 0xff escaping when transparent mode is enabled
	if (!transparent && (val==0xff)) WriteChar(0xff);
	
	WriteChar(val);
}

void eEventDisplay::setList(const ePtrList<EITEvent> &e)
{
	delete eventlist;
	delete events;
	eventlist=new ePtrList<EITEvent>(e);
	events=new ePtrList<EITEvent>::iterator(*eventlist);
	if (*events != eventlist->end())
		setEvent(**events);
	else
		setEvent(0);
}

void CDirectSerial::transmitByte (Bit8u val, bool first) {
	// mean bug: with break = 1, WriteFile will never return.
	if((LCR&LCR_BREAK_MASK) == 0) {
		DWORD bytesWritten = 0;
		WriteFile (hCom, &val, 1, &bytesWritten, NULL);
		if (bytesWritten != 1)
			LOG_MSG ("Serial%d: COM port error: write failed!", idnumber);
	}
	if(first) setEvent(SERIAL_THR_EVENT, bytetime/8);
	else setEvent(SERIAL_TX_EVENT, bytetime);
}

void CSerialLog::transmitByte(Bit8u val, bool first) {
	if(first) setEvent(SERIAL_THR_EVENT, bytetime/10); 
	else setEvent(SERIAL_TX_EVENT, bytetime);

	if (val == '\n' || val == '\r')
		log_emit();
	else {
		log_line += (char)val;
		if (log_line.length() >= 256) log_emit();
	}
}

void Erik::in_sp1() {
    //TODO: check STATE_WATER
    if (state&STATE_FALL) setState(STATE_ACT_1);

    if (state&STATE_ACT_2) {
    } else if (state&STATE_ACT_1) {
        setState(STATE_ACT_2);
        addSpeed(jump2);
        setEvent(new CAnimEvent(this,DE_JUMP,0,ESTATE_ABORT,au_jump,(state&STATE_LEFT) ? anim_erik_jump2_left : anim_erik_jump2_right));
    } else {
        setState(STATE_ACT_1);
        addSpeed(jump);
        setEvent(new CAnimEvent(this,DE_JUMP,0,ESTATE_ABORT,NULL,(state&STATE_LEFT) ? anim_erik_jump_left : anim_erik_jump_right));
    }
}

bool CNullModem::ServerConnect() {
	// check if a connection is available.
	clientsocket=serversocket->Accept();
	if (!clientsocket) return false;
	
	Bit8u peeripbuf[16];
	clientsocket->GetRemoteAddressString(peeripbuf);
	LOG_MSG("Serial%d: A client (%s) has connected.",(int)COMNUMBER,peeripbuf);
#if SERIAL_DEBUG
	log_ser(dbg_aux,"Nullmodem: A client (%s) has connected.", peeripbuf);
#endif

    /* FIXME: It would be nice if the SDL net library had a bind() call to bind only to a specific interface.
     *        Or maybe it does... what am I missing? */
    if (!nonlocal && strcmp((char*)peeripbuf,"127.0.0.1") != 0) {
        LOG_MSG("Serial%d: Non-localhost client (%s) dropped by nonlocal:0 policy. To accept connections from network, set nonlocal:1",(int)COMNUMBER,peeripbuf);
        delete clientsocket;
        clientsocket = NULL;
        return false;
    }

	clientsocket->SetSendBufferSize(256);
	rx_state=N_RX_IDLE;
	setEvent(SERIAL_POLLING_EVENT, 1);
	
	// we don't accept further connections
	delete serversocket;
	serversocket=0;

	// transmit the line status
	setRTSDTR(getRTS(), getDTR());
	if (transparent) setCD(true);
	return true;
}

void handleEvent(THREAD_ARG *arg)
{
    BYTE i=0;

    struct event_base* base = event_base_new();
    if (!base)
    {
        fprintf(stderr, "Could not initialize libevent!\n");
        exit(1);
    }
    eventarg.base = base;
    eventarg.UART0_fd = openUart("uart0");
    eventarg.CAN0_fd  = openCAN("can0");
    eventarg.output_socket = NULL;
    eventarg.GUIPipe_fd  = arg->GUIPipe_fd;
    eventarg.CTRLPipe_fd  = arg->CTRLPipe_fd;
    eventarg.UARTPipe_fd = arg->UARTPipe_fd;
    eventarg.lock = arg->lock;
    eventarg.cond = arg->cond;
    setEvent(base);
    for(i=0; i<MAX_CHANNEL; i++)
    {
        eventarg.timer_arg[i].channel = i+1;
        eventarg.timer_arg[i].channelTimer = event_new(base, -1, EV_TIMEOUT,
                                             cbChannelTimer, (void*)(&eventarg.timer_arg[i]));
    }
    event_base_dispatch(base);
}

void MainWindow::setFileName(QString fileName){
    XMLReader * xMlReader = new XMLReader(fileName);
    bool ok = true;
    eventList = xMlReader->readFile(&ok);
    if (!ok){
        eventName.clear();
        ui->labelUpper->setText("<font color='red'>Error reading file " + fileName + "</font>" );
        ui->labelMiddle->setText("<font color='red'>Check if the file exists and if the program has read acces</font>");
        ui->labelLower->setText("<font color='red'>The file might also be damaged or contain XML errors</font");
        return;
    }
    if (eventList.length() == 0){
        ui->labelUpper->setText("<font color ='red'>Error: empty or incorrectly formatted XML file " + fileName + ".</font>");
        return;
    }

    QSignalMapper * signalMapper = new QSignalMapper(this);
    connect(signalMapper,SIGNAL(mapped(int)),this,SLOT(setEventSlot(int)));
    for (int i = 0; i < eventList.length();i++){
        actions.append(ui->menuEvents->addAction(eventList.at(i)->getName()));
        actions.at(i)->setCheckable(true);
        signalMapper->setMapping(actions.at(i),i);
        connect(actions.at(i),SIGNAL(triggered()),signalMapper,SLOT(map()));
    }
    currentEventIndex = 0;
    setEvent();
    actions.at(currentEventIndex)->setChecked(true);
    connect(timer,SIGNAL(timeout()),this,SLOT(eventTimerSlot()));

}

void
ObjectView::MouseUp(BPoint point)
{
	if (fTrackingInfo.isTracking) {

		//spin the teapot on release, TODO: use a marching sum and divide by time
		if (fTrackingInfo.buttons == B_PRIMARY_MOUSE_BUTTON
			&& fTrackingInfo.pickedObject != NULL
			&& (fabs(fTrackingInfo.lastDx) > 1.0f
				|| fabs(fTrackingInfo.lastDy) > 1.0f) ) {

			fTrackingInfo.pickedObject->Spin(0.5f * fTrackingInfo.lastDy, 0.5f * fTrackingInfo.lastDx);

			setEvent(drawEvent);
		}

		//stop tracking
		fTrackingInfo.isTracking = false;
		fTrackingInfo.buttons = 0;
		fTrackingInfo.pickedObject = NULL;
		fTrackingInfo.lastX = 0.0f;
		fTrackingInfo.lastY = 0.0f;
		fTrackingInfo.lastDx = 0.0f;
		fTrackingInfo.lastDy = 0.0f;

		BCursor grabCursor(B_CURSOR_ID_GRAB);
		SetViewCursor(&grabCursor);
	}
}

CSerialModem::CSerialModem(Bitu id, CommandLine* cmd):CSerial(id, cmd) {
	InstallationSuccessful=false;
	connected=false;

	rqueue=new CFifo(MODEM_BUFFER_QUEUE_SIZE);
	tqueue=new CFifo(MODEM_BUFFER_QUEUE_SIZE);
	
	// Default to direct null modem connection.  Telnet mode interprets IAC codes
	telnetmode = false;

	// Initialize the sockets and setup the listening port
	listenport = 23;
	waitingclientsocket=0;
	clientsocket = 0;
	serversocket = 0;
	getBituSubstring("listenport:", &listenport, cmd);
	
	// TODO: Fix dialtones if requested
	//mhd.chan=MIXER_AddChannel((MIXER_MixHandler)this->MODEM_CallBack,8000,"MODEM");
	//MIXER_Enable(mhd.chan,false);
	//MIXER_SetMode(mhd.chan,MIXER_16MONO);
		
	CSerial::Init_Registers();
	Reset(); // reset calls EnterIdleState
		
	setEvent(SERIAL_POLLING_EVENT,1);
	InstallationSuccessful=true;
}

void
ObjectView::MouseMoved(BPoint point, uint32 transit, const BMessage *msg)
{
	if (fTrackingInfo.isTracking && fTrackingInfo.pickedObject != NULL) {

		float dx = point.x - fTrackingInfo.lastX;
		float dy = point.y - fTrackingInfo.lastY;
		fTrackingInfo.lastX = point.x;
		fTrackingInfo.lastY = point.y;

		if (fTrackingInfo.buttons == B_PRIMARY_MOUSE_BUTTON) {

			fTrackingInfo.pickedObject->Spin(0.0f, 0.0f);
			fTrackingInfo.pickedObject->RotateWorldSpace(dx,dy);
			fTrackingInfo.lastDx = dx;
			fTrackingInfo.lastDy = dy;

			setEvent(drawEvent);

		} else if (fTrackingInfo.buttons == B_SECONDARY_MOUSE_BUTTON) {

			float xinc = (dx * 2 * displayScale / Bounds().Width());
			float yinc = (-dy * 2 * displayScale / Bounds().Height());
			float zinc = 0;

			if (fPersp) {
				zinc = yinc * (fTrackingInfo.pickedObject->z / displayScale);
				xinc *= -(fTrackingInfo.pickedObject->z * 4 / zRatio);
				yinc *= -(fTrackingInfo.pickedObject->z * 4 / zRatio);
			}

			fTrackingInfo.pickedObject->x += xinc;
			if (modifiers() & B_SHIFT_KEY)
				fTrackingInfo.pickedObject->z += zinc;
			else
	  			fTrackingInfo.pickedObject->y += yinc;

			fForceRedraw = true;
			setEvent(drawEvent);
		}
	} else {
		void* object = fObjects.ItemAt(ObjectAtPoint(point));
		BCursor cursor(object != NULL
			? B_CURSOR_ID_GRAB : B_CURSOR_ID_SYSTEM_DEFAULT);
		SetViewCursor(&cursor);
	}
}

void Channel2::setNr2(unsigned data) {
	if (envelopeUnit_.nr2Change(data))
		disableMaster_();
	else
		staticOutputTest_(cycleCounter_);

	setEvent();
}

void eEventDisplay::init_eEventDisplay(const ePtrList<EITEvent>* e)
{
	eventlist=0;
	events=0;

	scrollbar = new eProgress(this);
	scrollbar->setName("scrollbar");
	scrollbar->setStart(0);
	scrollbar->setPerc(100);

	descr = new eWidget(this);
	descr->setName("epg_description");

	eventTime = new eLabel(this);
	eventTime->setName("time");

	eventDate = new eLabel(this);
	eventDate->setName("date");

	channel = new eLabel(this);
	channel->setName("channel");

	timer_icon = new eLabel(this);
	timer_icon->setName("timer_icon");

	eSkin *skin=eSkin::getActive();
	if (skin->build(this, "eventview"))
		eFatal("skin load of \"eventview\" failed");

	long_description=new eLabel(descr);
	long_description->setFlags(RS_WRAP);

	// try to recalc long description label... ( no broken text lines.. )
	float lineheight=fontRenderClass::getInstance()->getLineHeight( long_description->getFont() );
	int lines = (int)(descr->getSize().height() / lineheight);
	pageHeight = (int)(lines * lineheight);
	descr->resize( eSize( descr->getSize().width(), pageHeight+(int)(lineheight/6)));
	long_description->resize(eSize(descr->getSize().width(), pageHeight*16));

#ifndef DISABLE_FILE
	addActionToHelpList( &i_epgSelectorActions->addDVRTimerEvent );
#endif
#ifndef DISABLE_NETWORK
	addActionToHelpList( &i_epgSelectorActions->addNGRABTimerEvent );
#endif
	addActionToHelpList( &i_epgSelectorActions->addSwitchTimerEvent );
	addActionToHelpList( &i_epgSelectorActions->removeTimerEvent );
	addActionToHelpList( &i_enigmaEventViewActions->close );

	if (e)
		setList(*e);
	else if (evt)
		setEvent(evt);
	addActionMap( &i_enigmaEventViewActions->map );
	addActionMap( &i_epgSelectorActions->map );
	
	setHelpID(11);
}

void Channel2::reset() {
	// cycleCounter >> 12 & 7 represents the frame sequencer position.
	cycleCounter_ &= 0xFFF;
	cycleCounter_ += ~(cycleCounter_ + 2) << 1 & 0x1000;

	dutyUnit_.reset();
	envelopeUnit_.reset();
	setEvent();
}

WheelEventDispatchMediator::WheelEventDispatchMediator(const PlatformWheelEvent& event, PassRefPtr<AbstractView> view)
{
    if (!(event.deltaX() || event.deltaY()))
        return;

    setEvent(WheelEvent::create(FloatPoint(event.wheelTicksX(), event.wheelTicksY()), FloatPoint(event.deltaX(), event.deltaY()), granularity(event),
                                view, IntPoint(event.globalX(), event.globalY()), IntPoint(event.x(), event.y()), event.ctrlKey(), event.altKey(), event.shiftKey(), event.metaKey()));

}

WheelEventDispatchMediator::WheelEventDispatchMediator(const PlatformWheelEvent& event, PassRefPtr<AbstractView> view)
{
    if (!(event.deltaX() || event.deltaY()))
        return;

    setEvent(WheelEvent::create(FloatPoint(event.wheelTicksX(), event.wheelTicksY()), FloatPoint(event.deltaX(), event.deltaY()),
        deltaMode(event), view, event.globalPosition(), event.position(),
        event.ctrlKey(), event.altKey(), event.shiftKey(), event.metaKey(), event.directionInvertedFromDevice()));
}

void CSerialModem::handleUpperEvent(Bit16u type) {
	switch (type) {
	case SERIAL_RX_EVENT: {
		// check for bytes to be sent to port
		if(CSerial::CanReceiveByte())
			if(rqueue->inuse() && (CSerial::getRTS()||(flowcontrol!=3))) {
				Bit8u rbyte = rqueue->getb();
				//LOG_MSG("Modem: sending byte %2x back to UART3",rbyte);
				CSerial::receiveByte(rbyte);
			}
		if(CSerial::CanReceiveByte()) setEvent(SERIAL_RX_EVENT, bytetime*0.98f);
		break;
	}
	case MODEM_TX_EVENT: {
		if (tqueue->left()) {
			tqueue->addb(waiting_tx_character);
			if (tqueue->left() < 2) {
				CSerial::setCTS(false);
			}
		} else {
			static Bits lcount=0;
			if (lcount<1000) {
				lcount++;
				LOG_MSG("MODEM: TX Buffer overflow!");
			}
		}
		ByteTransmitted();
		break;
	}
	case SERIAL_POLLING_EVENT: {
		if (rqueue->inuse()) {
			removeEvent(SERIAL_RX_EVENT);
			setEvent(SERIAL_RX_EVENT, (float)0.01);
		}
		Timer2();
		setEvent(SERIAL_POLLING_EVENT,1);
		break;
	}

	case MODEM_RING_EVENT: {
		break;
	}
	}
}

void TechBot::answer() 
{
    SavePrevresponse();
    setEvent("BOT UNDERSTAND**");
    
    if(null_input())
    {
        eventManager("NULL INPUT**");
    }
    else if(null_input_repetition())
    {
        eventManager("NULL INPUT REPETITION**");
    }
    else if(isUserRepeat())
    {
        manageUserRepeat();
    }
    else if(isaskedusername())
    {
        std::cout<<"I THINK IT IS "<<user_name<<std::endl;
        return;
    }
    else
    {
        selectMatch();
    }
    
    if(user_want_to_quit())
    {
        TB_bQuitProgram = 1;
        eventManager("USER WANTS TO QUIT**");
    }
    else if(TB_Input.find("BYE")!=std::string::npos)
        return;

   else if(!isAIunderstand())
    {
        eventManager("BOT DON'T UNDERSTAND**");
       // update_unkown_input_list();
    }
    
    if(RespLISTonse.size() > 0)
    {
        chooseOutput();
        SaveAI_response();
        initPre_response();

        if(isAIRepeat())
        {
            manageRepeat();
        }
        Savelog("TechTron");
        print_response();
        //speak(TB_Response);
    }
}

bool CNullModem::ServerListen() {
	// Start the server listen port.
	serversocket = new TCPServerSocket(serverport);
	if (!serversocket->isopen) return false;
	LOG_MSG("Serial%d: Nullmodem server waiting for connection on port %d...",
		COMNUMBER,serverport);
	setEvent(SERIAL_SERVER_POLLING_EVENT, 50);
	setCD(false);
	return true;
}