void EditNoteDialog::setInputData()
{
    //initialize inputs for new note
    if (mode == CREATE_NEW)
    {
        //set date field value to selected date
        entryDate->set_text(selectedDate.toString());

        //initialize time field as current time +15min
        Glib::DateTime dateTime = Glib::DateTime::create_now_local().add_minutes(Preferences::prefs->getNewNoteMinutes());
        TimeValue timeValue = dateTime;
        entryTime->set_text(timeValue.toString());
    }

    //initialize inputs from existing note
    if (mode == EDIT)
    {
        entryTitle->set_text(noteData->getTitle());
        textDescription->get_buffer()->set_text(noteData->getDetails());
        entryDate->set_text(noteData->getDateText());
        entryTime->set_text(noteData->getTimeText());
        checkReminder->set_active(noteData->isReminder());
    }

}

// poll for writing
int Sock::poll_out(TimeValue &timeout)
{
#ifndef _WIN32	
	struct pollfd pollset[1];
	pollset[0].fd = sockfd;
	pollset[0].events = POLLOUT|POLLERR;
	pollset[0].revents = 0;
	int result =  ::poll(pollset, 1, timeout.msec());
	if (result > 0)
		return pollset[0].revents;
	else
		return result;
#else
	fd_set fds_write, fds_err;
	 FD_ZERO(&fds_write);
	 FD_ZERO(&fds_err);
	 FD_SET(sockfd, &fds_write);
	 FD_SET(sockfd, &fds_err);

	 int result = ::select(0, NULL, &fds_write, &fds_err, timeout.timeval());
	 if (result <= 0)
	 	return result;
	 unsigned revents = 0;
	if (FD_ISSET(sockfd, &fds_write)) revents |= POLLOUT;
	if (FD_ISSET(sockfd, &fds_err)) revents |= POLLERR;
	return revents;
#endif
}

int32 RTD::StopMeasurement(void)
{
    TimeValue StopTime;

    StopTime.set_to_current_time();
    return (StopTime.to_msec() - StartTime.to_msec());
}

//----------------------------------------------------------------------
// All logging eventually boils down to this function call. If we have
// a callback registered, then we call the logging callback. If we have
// a valid file handle, we also log to the file.
//----------------------------------------------------------------------
void
Log::VAPrintf(const char *format, va_list args)
{
    // Make a copy of our stream shared pointer in case someone disables our
    // log while we are logging and releases the stream
    StreamSP stream_sp(m_stream_sp);
    if (stream_sp)
    {
        static uint32_t g_sequence_id = 0;
        StreamString header;

        // Add a sequence ID if requested
        if (m_options.Test (LLDB_LOG_OPTION_PREPEND_SEQUENCE))
            header.Printf ("%u ", ++g_sequence_id);

        // Timestamp if requested
        if (m_options.Test (LLDB_LOG_OPTION_PREPEND_TIMESTAMP))
        {
            TimeValue now = TimeValue::Now();
            header.Printf ("%9d.%09.9d ", now.seconds(), now.nanoseconds());
        }

        // Add the process and thread if requested
        if (m_options.Test (LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD))
            header.Printf ("[%4.4x/%4.4" PRIx64 "]: ", getpid(), Host::GetCurrentThreadID());

        // Add the thread name if requested
        if (m_options.Test (LLDB_LOG_OPTION_PREPEND_THREAD_NAME))
        {
            llvm::SmallString<32> thread_name;
            ThisThread::GetName(thread_name);
            if (!thread_name.empty())
                header.Printf ("%s ", thread_name.c_str());
        }

        header.PrintfVarArg (format, args);
        header.PutCString("\n");

        if (m_options.Test(LLDB_LOG_OPTION_BACKTRACE)) 
        {
            std::string back_trace;
            llvm::raw_string_ostream stream(back_trace);
            llvm::sys::PrintStackTrace(stream);
            header.PutCString(back_trace.c_str());
        }

        if (m_options.Test(LLDB_LOG_OPTION_THREADSAFE))
        {
            static Mutex g_LogThreadedMutex(Mutex::eMutexTypeRecursive);
            Mutex::Locker locker(g_LogThreadedMutex);
            stream_sp->PutCString(header.GetString().c_str());
            stream_sp->Flush();
        }
        else
        {
            stream_sp->PutCString(header.GetString().c_str());
            stream_sp->Flush();
        }
    }
}

int64_t HeapTimer::RegisterTimer(const TimeValue& interval,
        const TimeValue& delay,
        CallbackObject* cb_obj,
        void* data)
{
    if (interval.Sec() == 0 && interval.Usec() == 0)
        return -1;

    if (cur_size_ >= heap_size_)
        return -1;

    TimerNode* new_node = new TimerNode;
    if (new_node == NULL)
        return -1;

    new_node->cb_obj            = cb_obj;
    new_node->data              = data;
    new_node->timer_id          = PopFreeTimerId();
    new_node->interval_time     = interval;
    new_node->expire_time       = ExpireTime(TimeValue(time(NULL)), delay);

    if (cur_size_ + 2 >= heap_size_)
        GrowHeap();

    RotateUp(new_node, cur_size_, GetParentPos(cur_size_));
    cur_size_++;

    LOG(INFO) << "RegisterTimer TimerSize[" << GetTimerSize() << "] TimerId[" << new_node->timer_id <<"]";

    return new_node->timer_id;
}

uint16_t ConnectionFileDescriptor::GetListeningPort(uint32_t timeout_sec)
{
    uint16_t bound_port = 0;
    if (timeout_sec == UINT32_MAX)
        m_port_predicate.WaitForValueNotEqualTo (0, bound_port);
    else
    {
        TimeValue timeout = TimeValue::Now();
        timeout.OffsetWithSeconds(timeout_sec);
        m_port_predicate.WaitForValueNotEqualTo (0, bound_port, &timeout);
    }
    return bound_port;
}

void
RoutingStatsScene::addRp(uint32_t nodeId, QString destination, qreal time, RoutePathElementsVector_t elements)
{
    NodeIdDest_t nd = { nodeId, destination };
    if(m_rps.find(nd) == m_rps.end())
    {
        TimeValue <RoutePathElementsVector_t> tv;
        tv.add(time, elements);
        m_rps[nd] = tv;
        return;
    }
    TimeValue <RoutePathElementsVector_t> & tv = m_rps[nd];
    tv.add(time, elements);
}

void
RoutingStatsScene::add(uint32_t nodeId, qreal time, QString rt)
{
    if(m_nodeIdTimeValues.find(nodeId) == m_nodeIdTimeValues.end())
    {
        TimeValue <QString> tv;
        tv.add(time, rt);
        m_nodeIdTimeValues[nodeId] = tv;
        addToProxyWidgetsMap(nodeId, "", rt);
        return;
    }
    TimeValue <QString> & tv = m_nodeIdTimeValues[nodeId];
    tv.add(time, rt);

}

void
PacketsScene::addPackets ()
{
  bool foundNodes = setUpNodeLines ();
  if (!foundNodes)
    return;
  Table * table = PacketsMode::getInstance ()->getTable ();
  table->removeAllRows ();
  uint32_t count = 0;
  uint32_t maxPackets = 10000;

  if (m_packetPathItem)
    {
      removeItem (m_packetPathItem);
    }
  m_packetPathItem = new QGraphicsPathItem;
  addItem (m_packetPathItem);
  m_packetPath = QPainterPath ();
  TimeValue <AnimEvent*> *events = AnimatorMode::getInstance ()->getEvents ();
  for (TimeValue<AnimEvent *>::TimeValue_t::const_iterator i = events->Begin ();
      i != events->End ();
      ++i)
    {
      AnimEvent * ev = i->second;
      if (ev->m_type == AnimEvent::PACKET_FBTX_EVENT)
        {
          AnimPacketEvent * packetEvent = static_cast<AnimPacketEvent *> (ev);
          if (!isAllowedNode (packetEvent->m_fromId))
            continue;
          if (!isAllowedNode (packetEvent->m_toId))
            continue;
          if (packetEvent->m_fbRx > m_toTime)
              continue;
          if (packetEvent->m_fbTx < m_fromTime)
              continue;

          if ((count == maxPackets) && m_showGraph)
            AnimatorMode::getInstance ()->showPopup ("Currently only the first " + QString::number (maxPackets) + " packets will be shown. Table will be fully populated");
          addPacket (packetEvent->m_fbTx, packetEvent->m_fbRx, packetEvent->m_fromId, packetEvent->m_toId, packetEvent->m_metaInfo, count < maxPackets );
          AnimatorMode::getInstance ()->keepAppResponsive ();
          ++count;

        }
    }
  table->adjust ();
  m_infoWidget->setVisible (false);

}

//----------------------------------------------------------------------
// All logging eventually boils down to this function call. If we have
// a callback registered, then we call the logging callback. If we have
// a valid file handle, we also log to the file.
//----------------------------------------------------------------------
void
Log::PrintfWithFlagsVarArg (uint32_t flags, const char *format, va_list args)
{
    // Make a copy of our stream shared pointer in case someone disables our
    // log while we are logging and releases the stream
    StreamSP stream_sp(m_stream_sp);
    if (stream_sp)
    {
        static uint32_t g_sequence_id = 0;
        StreamString header;
		// Enabling the thread safe logging actually deadlocks right now.
		// Need to fix this at some point.
//        static Mutex g_LogThreadedMutex(Mutex::eMutexTypeRecursive);
//        Mutex::Locker locker (g_LogThreadedMutex);

        // Add a sequence ID if requested
        if (m_options.Test (LLDB_LOG_OPTION_PREPEND_SEQUENCE))
            header.Printf ("%u ", ++g_sequence_id);

        // Timestamp if requested
        if (m_options.Test (LLDB_LOG_OPTION_PREPEND_TIMESTAMP))
        {
            TimeValue now = TimeValue::Now();
            header.Printf ("%9d.%6.6d ", now.seconds(), now.nanoseconds());
        }

        // Add the process and thread if requested
        if (m_options.Test (LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD))
            header.Printf ("[%4.4x/%4.4" PRIx64 "]: ", getpid(), Host::GetCurrentThreadID());

        // Add the process and thread if requested
        if (m_options.Test (LLDB_LOG_OPTION_PREPEND_THREAD_NAME))
        {
            std::string thread_name (Host::GetThreadName (getpid(), Host::GetCurrentThreadID()));
            if (!thread_name.empty())
                header.Printf ("%s ", thread_name.c_str());
        }

        header.PrintfVarArg (format, args);
        stream_sp->Printf("%s\n", header.GetData());
        
        if (m_options.Test (LLDB_LOG_OPTION_BACKTRACE))
            Host::Backtrace (*stream_sp, 1024);
        stream_sp->Flush();
    }
}

void ConstraintPresenter::on_defaultDurationChanged(const TimeValue& val)
{
    auto width = val.toPixels(m_zoomRatio);
    m_view->setDefaultWidth(width);
    m_header->setWidth(width);

    if(rack())
    {
        rack()->setWidth(m_view->defaultWidth() - 20);
    }
}

void DataCollectorSolver::logQueryStats(const Query &query,
        QueryType type, TimeValue start, Solver::Validity validity) {
    int result;

    TimeValue duration = TimeValue::now() - start;
    std::string query_blob;
    std::pair<uint64_t, uint64_t> qids = serializer_.Serialize(query, query_blob);

    // Query structure
    sqlite3_clear_bindings(qinsert_stmt_);

    sqlite3_bind_int64(qinsert_stmt_, 1, qids.first);
    if (qids.second) {
        sqlite3_bind_int64(qinsert_stmt_, 2, qids.second);
    }
    sqlite3_bind_int64(qinsert_stmt_, 14,
            event_logger_->logEvent(g_s2e_state, EVENT_KLEE_QUERY, 1));

    sqlite3_bind_int(qinsert_stmt_, 3, query.constraints.head()->depth());
    sqlite3_bind_blob(qinsert_stmt_, 4,
            query_blob.c_str(), query_blob.size(), NULL);
    sqlite3_bind_int(qinsert_stmt_, 5, static_cast<int>(type));

    result = sqlite3_step(qinsert_stmt_);
    assert(result == SQLITE_DONE);
    sqlite3_reset(qinsert_stmt_);

    // Query results
    sqlite3_bind_int64(rinsert_stmt_, 1, qids.first);
    sqlite3_bind_int64(rinsert_stmt_, 2, duration.usec());
    if (type == TRUTH || type == VALIDITY) {
        sqlite3_bind_int(rinsert_stmt_, 3, static_cast<int>(validity));
    }
    result = sqlite3_step(rinsert_stmt_);
    assert(result == SQLITE_DONE);
    sqlite3_reset(rinsert_stmt_);
}

LNE_UINT ThreadMutex::Acquire(const TimeValue &tv)
{
	if(!IsAvailable())
		return LNERR_NOINIT;
#if defined(LNE_WIN32)
	DWORD ret = WaitForSingleObject(mutex_, (DWORD)tv.ToMillisecond());
	if(ret == WAIT_OBJECT_0)
		return LNERR_OK;
	if(ret == WAIT_TIMEOUT)
		return LNERR_TIMEOUT;
#else
	struct timespec ts;
	TimeValue dest;
	dest.Now();
	dest += tv;
	ts.tv_sec = dest.sec();
	ts.tv_nsec = dest.usec() * 1000;
	if(pthread_mutex_timedlock(&mutex_, &ts) == 0)
		return LNERR_OK;
	if(errno == ETIMEDOUT)
		return LNERR_TIMEOUT;
#endif
	return LNERR_UNKNOW;
}

void Bullet::update(TimeValue time)
{
    if (isUpdating())
        dynamicsWorld_->stepSimulation(time.toSeconds(), 8, getSubstepSize().toSeconds());
}

void ConstraintPresenter::on_minDurationChanged(const TimeValue& min)
{
    m_view->setMinWidth(min.toPixels(m_zoomRatio));
}

void ConstraintPresenter::on_maxDurationChanged(const TimeValue& max)
{
    m_view->setMaxWidth(max.isInfinite(),
                        max.isInfinite()? -1 : max.toPixels(m_zoomRatio));
}

int	SockConnector::connect(SockStream &stream, InetAddr &addr, TimeValue &tv)
{	
	int rv = 0;

	// non-block socket
	stream.set_nonblocking();
	
	#ifdef _WIN32

	// connect
	rv = ::connect(stream.get_handle(), (const struct sockaddr *) addr.get_addr(), (socklen_t)addr.get_addr_size());
	if (rv != -1) {
		rv = 0;
	}
	else  {
		if (WSAGetLastError() == WSAEWOULDBLOCK) 
		{
			//printf("connect InProgress [%d]\n", sock);
			fd_set rset;
			fd_set wset;

			FD_ZERO(&rset);
			FD_ZERO(&wset);
			FD_SET(stream.get_handle(), &rset);			
			FD_SET(stream.get_handle(), &wset);			
			
			rv = ::select(0, &rset, &wset, NULL, (struct  timeval*)tv.timeval());
			if (rv == 0) {				
				perror("connect timeout");
				rv = -1;
			}
			else if (FD_ISSET(stream.get_handle(), &rset) || FD_ISSET(stream.get_handle(), &wset)) {
				int error = 0;
				socklen_t len = sizeof(error);
				if (getsockopt(stream.get_handle(), SOL_SOCKET, SO_ERROR, (char *)&error, &len) == 0) {
					// select error
					if (error == 0) {
						rv = 0;
					}
					else {
						closesocket(stream.get_handle());						
						perror("connect");		
						rv = -1;
					}	
				}
			}
			else {
				perror("connect");		
				rv = -1;

			}
		} 
		else {
			perror("connect");
			rv = -1;
		}
	}
	#endif

	// restore file status flags
	stream.set_blocking();
	
	return rv;
}

//// Other conversions
inline OSSIA::TimeValue time(const TimeValue& t)
{
    return t.isInfinite()
            ? OSSIA::Infinite
            : OSSIA::TimeValue{t.msec()};
}

void View::setDefaultDuration(const TimeValue& t)
{
    auto qtime = t.toQTime();
    if(qtime != m_defaultDur->time())
        m_defaultDur->setTime(qtime);
}

void EditNoteDialog::verifyInputData()
{
    const Glib::ustring title = entryTitle->get_text();
    const Glib::ustring desc = textDescription->get_buffer()->get_text(false);
    const Glib::ustring date = entryDate->get_text();
    const Glib::ustring time = entryTime->get_text();
    const bool isReminder = checkReminder->get_active();

    bool title_valid = false;
    bool date_valid = false;
    bool time_valid = false;

    //check title
    if (title.length() > 0)
    {
        title_valid = true;
    }

    //check date
    DateValue dateValue;
    if (dateValue.parseString(date))
    {
        date_valid = true;
    }

    //check time
    TimeValue timeValue;
    if (timeValue.parseString(time))
    {
        time_valid = true;
    }

    if (title_valid && date_valid && time_valid)
    {
        isInputDataValid = true;

        btnSave->set_sensitive(true);
        infoBar->setText(Gtk::MESSAGE_INFO, lang::getString(lang::EDIT_NOTE_INPUT_VALIDATED));

        //update note data
        noteData->setDate(dateValue);
        noteData->setTime(timeValue);
        noteData->setReminder(isReminder);
        noteData->setTitle(title);
        noteData->setDetails(desc);
    }
    else
    {
        isInputDataValid = false;

        btnSave->set_sensitive(false);

        std::string message = lang::getString(lang::EDIT_NOTE_INPUT_NOT_VALIDATED);

        if (!title_valid)
            message = lang::getString(lang::EDIT_NOTE_INPUT_CORRECT_TITLE);

        if (title_valid && !date_valid)
            message = lang::getString(lang::EDIT_NOTE_INPUT_CORRECT_DATE);

        if (title_valid && date_valid && !time_valid)
            message = lang::getString(lang::EDIT_NOTE_INPUT_CORRECT_TIME);

        infoBar->setText(Gtk::MESSAGE_ERROR, message);
    }
}