void ArrowLine::drawShape(QPainter &p)
{
    p.setPen(darkGray);
    QCanvasLine::drawShape(p);

    double angle = computeAngle(startPoint().x(),
                                startPoint().y(),
                                endPoint().x(),
                                endPoint().y());
    QPointArray pts(3);

    QWMatrix m;
    int x, y;
    m.rotate(angle);
    m.map(-5, -2, &x, &y);
    pts.setPoint(0, x, y);
    m.map(-5, 2, &x, &y);
    pts.setPoint(1, x, y);
    m.map(0, 0, &x, &y);
    pts.setPoint(2, x, y);

    pts.translate(endPoint().x(), endPoint().y());

    p.setBrush(QColor(darkGray));
    p.drawPolygon(pts);
}

void AMBeamSelectPage::initializePage()
{
	AMViewPage::initializePage();

	disconnect(view(), SIGNAL(mousePressed(QPointF)), viewWizard(), SLOT(addPoint(QPointF)));
	disconnect(view(), SIGNAL(mouseLeftReleased(QPointF)), viewWizard(), SLOT(endPoint()));
	connect(view(), SIGNAL(mousePressed(QPointF)), viewWizard(), SLOT(addPoint(QPointF)));
	connect(view(), SIGNAL(mouseLeftReleased(QPointF)), viewWizard(), SLOT(endPoint()));
}

////////////////// PathInfo //////////////////
PathInfo::PathInfo(const Unit* owner, const float destX, const float destY, const float destZ, bool useStraightPath) :
    m_pathPolyRefs(NULL), m_polyLength(0), m_type(PATHFIND_BLANK), m_useStraightPath(useStraightPath),
    m_sourceUnit(owner), m_navMesh(NULL), m_navMeshQuery(NULL)
{
    PathNode endPoint(destX, destY, destZ);
    setEndPosition(endPoint);

    float x,y,z;
    m_sourceUnit->GetPosition(x, y, z);
    PathNode startPoint(x, y, m_sourceUnit->GetMap()->GetHeight(x,y,z,100.0f));
    setStartPosition(startPoint);

    PATH_DEBUG("++ PathInfo::PathInfo for %u \n", m_sourceUnit->GetGUID());

    uint32 mapId = m_sourceUnit->GetMapId();
    MMAP::MMapManager* mmap = MMAP::MMapFactory::createOrGetMMapManager();
    m_navMesh = mmap->GetNavMesh(mapId);
    m_navMeshQuery = mmap->GetNavMeshQuery(mapId);

    if (m_navMesh && m_navMeshQuery)
    {
        BuildPolyPath(startPoint, endPoint);
    }
    else
    {
        BuildShortcut();
        m_type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH);
    }
}

void PD_2DXYPS::DrawXAxes(const double& yVal,
                               const double& yaxOffset)
{
    Point2D stPoint(convXaxisMin, yVal + yaxOffset);
    Point2D endPoint(convXaxisMax, yVal + yaxOffset);
    DrawLine(stPoint, endPoint);
}

	void KviCanvasLine::draw(QPainter &p)
	{
		if(isEnabled())
		{
			p.setPen(pen());
			p.drawLine(startPoint(),endPoint());
		}

		if(isSelected())
		{
			p.setRasterOp(NotROP);
			p.setPen(QPen(DotLine));
			p.drawLine(startPoint(),endPoint());
			p.setRasterOp(CopyROP);
		}
	}

void Tranceiver::connect(String ipAddr) {
	semaphore.Acquire();

	//create socket
	socket=new Socket();
	socket->Construct(NET_SOCKET_AF_IPV4,
			NET_SOCKET_TYPE_STREAM, NET_SOCKET_PROTOCOL_TCP);

	unsigned long blockingModeSocket=0;
	socket->Ioctl(NET_SOCKET_FIONBIO, blockingModeSocket);

	//Connect to TCP Server
	Ip4Address ipAddress(ipAddr);
	NetEndPoint endPoint(ipAddress, PORT);
	result r=socket->Connect(endPoint);

	if(r!=E_SUCCESS) {
		AppLogException("CommandCenter : Connect Error");
	}

	//Create Packet Object
	packetSender=new PacketSender(socket);
	screenSender=new ScreenSender(socket);
	packetReceiver=new PacketReceiver(socket);

	//Start PacketReciever
	packetReceiver->setPacketListener(this);
	packetReceiver->Construct();
	packetReceiver->flag=true;
	packetReceiver->Start();

	//mServerConnectionListener->onServerConnected(ipAddr);

	semaphore.Release();
}

double LikelihoodField::computeWeight(const std::vector<double>& measurement, const std::vector<double>& state, const Grid<double>& map){
	double q = 1;
	//Get location of range finder in global coordinates
	std::vector<double> locationRF = this->rf->getLocation(state);
	std::vector<double> endPoint(2);
	//Temporary variables
	double z,minDist,dist,sample, beamAngle;
	for(int i = 0; i < (int)measurement.size(); i++){
		//Current measurement
		z = measurement[i];
		beamAngle = this->rf->getBeamAngle(i);
		if (z != this->rf->getErrorValue()){
			//Compute end position of current beam
			endPoint[0] = locationRF[0] + z * cos(beamAngle + state[2]);
			endPoint[1] = locationRF[1] + z * sin(beamAngle + state[2]);
			//Find nearest occupied cell in map
			minDist = 0;
			for(int j = 0; j < map.getNumberCells(); j++){
				Cell<double> c = map.getCell(j);
				if(c.value > this->parameters[4]){
					dist = c.getDistanceToCenter(endPoint);
					if(dist < minDist || minDist == 0)
						minDist = dist;
				}
			}
			//Update probability of measurement
			sample = Tools::probNormal(minDist, this->parameters[0]);
			q = q * (this->parameters[1] * sample + this->parameters[2]/this->parameters[3]);
		}
	}
	return q;
}

RTRVector3D RTRSegment::pointAt(int coordinate, double val) const
{
    //TODO Not finished... I want to sleep!!
    double ratio = (val - beginningPoint(coordinate)) / (endPoint(coordinate) - beginningPoint(coordinate));
    RTRVector3D ret = beginningPoint + (endPoint - beginningPoint) * ratio;
    ret(coordinate) = val;
    return ret;
}

void
VNode::render() const
{
    glColor3f(0,1,0);
    glLineWidth(MaxWidth);
    DrawLine( m_location, endPoint() );
    int numChildren = (int)m_children.size();
    for(int i=0; i<numChildren; ++i)
        m_children[i]->render();
}

bool QgsCurve::isClosed() const
{
  if ( numPoints() == 0 )
    return false;

  //don't consider M-coordinates when testing closedness
  QgsPointV2 start = startPoint();
  QgsPointV2 end = endPoint();
  return ( qgsDoubleNear( start.x(), end.x(), 1E-8 ) &&
           qgsDoubleNear( start.y(), end.y(), 1E-8 ) &&
           qgsDoubleNear( start.z(), end.z(), 1E-8 ) );
}

int server()
{
	printf("Give me the printer Number : 0 or 1");
	int no;
	scanf("%d",&no);

	char buffer[256] = { '\0' };

	    // Create a local endpoint.
	if(no==0)
	    sprintf(buffer, "tcp://58.198.176.121:5555");
	else
		sprintf(buffer, "tcp://58.198.176.121:5557");


	    Theron::EndPoint endPoint("server", buffer);

	    // Connect to the remote endpoint.

	    	sprintf(buffer, "tcp://58.198.176.121:5556");
	    	if (!endPoint.Connect(buffer))
	    	{
	    		printf("ERROR: Connection failed - check networking is enabled.\n");
	    		return 1;
	    	}



	    // The framework and receiver are tied to the endpoint.
	    if(no==0)
	    {
	    	//Theron::Receiver receiver(endPoint, "receiver");

	    	Theron::Framework framework(endPoint);

	    	Printer printer(no,framework, "printer");
	    	Printer1 printer1(no,framework, "printer1");
	    	//receiver.Wait();
	    	while(1);

	    }
	    else
	    {
	    	Theron::Receiver receiver(endPoint, "receiver1");
	    	Theron::Framework framework(endPoint);

	    	Printer printer1(no,framework,"printer");
	    	receiver.Wait();

	    }


}

int client()
{
	  char buffer[256] = { '\0' };

	    // Create a local endpoint.
	    sprintf(buffer, "tcp://58.198.176.121:5556");
	    Theron::EndPoint endPoint("client", buffer);

	    // Connect to the remote endpoint.
	    sprintf(buffer, "tcp://58.198.176.121:5555");
	    if (!endPoint.Connect(buffer))
	    {
	        printf("ERROR: Connection failed - check networking is enabled.\n");
	        return 1;
	    }
	    else
	    {
	    	printf("Connected to %s\n",buffer);
	    }
	    sprintf(buffer, "tcp://58.198.176.121:5557");
	    if (!endPoint.Connect(buffer))
	    {
	        printf("ERROR: Connection failed - check networking is enabled.\n");
	        return 1;
	    }
	    else
	    {
	    	printf("Connected to %s\n",buffer);
	    }

	    // The framework is tied to the endpoint.
	    Theron::Framework framework(endPoint);

	    // Send messages to the server in a loop until the user enters 'exit'.
	    // Note that if the server hasn't started listening yet it may miss the first messages!
	    printf("Enter lines of text (max 256 chars per line). Type 'exit' to end.\n");

	    while (strcmp(buffer, "exit") != 0)
	    {
	        // Send the text in a messages to the remote 'printer' actor using its unique name.
	        gets(buffer);
	        framework.Send(
	            TextMessage(buffer),
	            Theron::Address(),
	            Theron::Address("printer"));

	        framework.Send(
	  	            double(28.234),
	  	            Theron::Address(),
	  	            Theron::Address("printer1"));
	    }
}

void
VNode::grow(const Vector2& targetPoint, bool& reachedTarget,
            VINENODES& newChildren, VINENODES& staleChildren)
{
    incrementGrowth();
    setEndPoint();

    float distance = sqrt( pow((targetPoint.X - endPoint().X),2) + pow((targetPoint.Y - endPoint().Y),2) );
    reachedTarget = bool(distance <= GrowthIncrement);

    if(!reachedTarget)
    {
        if(maxLengthReached())
        {
            staleChildren.push_back(this);
            addRandomizedChildren(endPoint(), targetPoint);
            int sz = (int)m_children.size();
            for( int i=0; i<sz; ++i )
                newChildren.push_back(m_children[i]);
        }
    }
}

QgsAbstractGeometry *QgsCurve::boundary() const
{
  if ( isEmpty() )
    return nullptr;

  if ( isClosed() )
    return nullptr;

  QgsMultiPoint *multiPoint = new QgsMultiPoint();
  multiPoint->addGeometry( new QgsPoint( startPoint() ) );
  multiPoint->addGeometry( new QgsPoint( endPoint() ) );
  return multiPoint;
}

/**
 * Return whether on seq. line.
 * Takes into account destruction box if shown.
 *
 * @param p The point to investigate.
 * @return  Non-zero if point is on this sequence line.
 */
int SeqLineWidget::onWidget(const QPoint & p)
{
    int nOnWidget = 0;
    QPoint sp = startPoint();
    QPoint ep = endPoint();
    //see if on widget ( for message creation )
    if( sp.x() - m_nMouseDownEpsilonX < p.x()
            && ep.x() + m_nMouseDownEpsilonX > p.x()
            && sp.y() < p.y() && ep.y() + 3 > p.y() )
    {
        nOnWidget = 1;
    }
    return nOnWidget;
}

void ReportPrintSetting::drawPosition(int type, QString content, QPainter &painter,
                                      int drawType,QString img,
                                      int fontSize, const QString family,
                                      bool bold)
{
    ReportFormDefinition report;
    // QString file("../tcdstation/reportForm.xml");
    QString file("reportForm.xml");
    report.ReadReportContent(file);
    QRectF rectF;
    report.GetPosition(type,rectF);

    QFont font;
    font.setPointSize(fontSize);
    font.setBold(bold);
    font.setFamily(family);

    painter.setFont(font);
    if(drawType == SPLITTER)
    {
        QPoint startPoint(rectF.x(),rectF.y());
        QPoint endPoint(rectF.x()+rectF.width(),rectF.y()+rectF.height());
        painter.drawLine(startPoint,endPoint);
    }
    else if(drawType == TEXT)
    {
        painter.drawText(rectF,Qt::TextWordWrap,content);
    }
    else if(drawType == IMAGE)
    {
        //QImage image(img);
        QPixmap pixmap;
        pixmap.load(img);
        //painter.drawImage(rectF,image);
        painter.drawPixmap(rectF.x(),rectF.y(),rectF.width(),rectF.height(),pixmap);
    }
    else if(drawType == WIDGET)
    {
        QPixmap grabImage;
        QRect rect;
        rect.setSize(QSize(rectF.width(),rectF.height()));
        m_tableView->resize(rect.size());
        grabImage = m_tableView->grab(QRect(0,0,m_tableView->width(),m_tableView->height()));


        grabImage.scaled(rect.size(),Qt::KeepAspectRatio);
        painter.drawPixmap(rectF.x(),rectF.y(),grabImage);
    }

}

void PD_2DXYPS::DrawXTic(const double& xVal,
                              const double& yVal,
                              const double& yaxOffset,
                              const double& ticLen,
                              const double& ticOffset)
{
    double xTran = TransformX(xVal);
    if (Limit::WithinOneLimit(convXaxisMin, convXaxisMax, xTran))
    {
        double ypt = yVal + yaxOffset - ticOffset;
        Point2D stPoint(xTran, ypt);
        Point2D endPoint(xTran, ypt + ticLen);
        DrawLine(stPoint, endPoint);
    }
}

/**
 * Arrow class contructor, that creates and arrow from a start item
 * to the endItem
 * @param startItem
 * @param endItem
 * @param parentGroup
 */
Arrow::Arrow(DocBlock *startItem, Block *endItem, BlockGroup *parentGroup)
    : QGraphicsLineItem(parentGroup)
{
    Q_ASSERT(startItem != 0);Q_ASSERT(endItem != 0);Q_ASSERT(parentGroup != 0);
    myStartItem = startItem;
    myEndItem = endItem;
    myColor = Qt::black;
    setPen(QPen(myColor, 0, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
    connect(myStartItem, SIGNAL(destroyed()), this, SLOT(deleteLater()));
    connect(myEndItem, SIGNAL(destroyed()), this, SLOT(deleteLater()));
    connect(myEndItem, SIGNAL(visibilityChanged(bool)), this, SLOT(updateVisibility(bool)));

    line1 = QLineF(startPoint(), midPoint());
    line2 = QLineF(midPoint(), endPoint());
}

bool QgsCurve::isClosed() const
{
  if ( numPoints() == 0 )
    return false;

  //don't consider M-coordinates when testing closedness
  QgsPoint start = startPoint();
  QgsPoint end = endPoint();

  bool closed = qgsDoubleNear( start.x(), end.x(), 1E-8 ) &&
                qgsDoubleNear( start.y(), end.y(), 1E-8 );
  if ( is3D() && closed )
    closed &= qgsDoubleNear( start.z(), end.z(), 1E-8 ) || ( std::isnan( start.z() ) && std::isnan( end.z() ) );
  return closed;
}

/**
 * Loads AssociationLine information saved in \a qElement XMI element.
 */
bool AssociationLine::loadFromXMI(QDomElement &qElement)
{
    QString layout = qElement.attribute(QLatin1String("layout"), QLatin1String("polyline"));
    m_layout = fromString(layout);

    QDomNode node = qElement.firstChild();

    m_points.clear();

    QDomElement startElement = node.toElement();
    if(startElement.isNull() || startElement.tagName() != QLatin1String("startpoint")) {
        return false;
    }
    QString x = startElement.attribute(QLatin1String("startx"), QLatin1String("0"));
    qreal nX = x.toFloat();
    QString y = startElement.attribute(QLatin1String("starty"), QLatin1String("0"));
    qreal nY = y.toFloat();
    QPointF startPoint(nX, nY);

    node = startElement.nextSibling();
    QDomElement endElement = node.toElement();
    if(endElement.isNull() || endElement.tagName() != QLatin1String("endpoint")) {
        return false;
    }
    x = endElement.attribute(QLatin1String("endx"), QLatin1String("0"));
    nX = x.toFloat();
    y = endElement.attribute(QLatin1String("endy"), QLatin1String("0"));
    nY = y.toFloat();
    QPointF endPoint(nX, nY);
    setEndPoints(startPoint, endPoint);
    QPointF point;
    node = endElement.nextSibling();
    QDomElement element = node.toElement();
    int i = 1;
    while(!element.isNull()) {
        if(element.tagName() == QLatin1String("point")) {
            x = element.attribute(QLatin1String("x"), QLatin1String("0"));
            y = element.attribute(QLatin1String("y"), QLatin1String("0"));
            point.setX(x.toFloat());
            point.setY(y.toFloat());
            insertPoint(i++, point);
        }
        node = element.nextSibling();
        element = node.toElement();
    }

    return true;
}