void EDA_DRAW_PANEL::DrawCrossHair( wxDC* aDC, EDA_COLOR_T aColor )
{
if( m_cursorLevel != 0 || aDC == NULL || !m_showCrossHair )
return;
wxPoint cursor = GetParent()->GetCrossHairPosition();
GRSetDrawMode( aDC, GR_XOR );
if( GetParent()->m_cursorShape != 0 ) // Draws full screen crosshair.
{
wxSize clientSize = GetClientSize();
// Y axis
wxPoint lineStart( cursor.x, aDC->DeviceToLogicalY( 0 ) );
wxPoint lineEnd( cursor.x, aDC->DeviceToLogicalY( clientSize.y ) );
GRLine( &m_ClipBox, aDC, lineStart, lineEnd, 0, aColor );
// X axis
lineStart = wxPoint( aDC->DeviceToLogicalX( 0 ), cursor.y );
lineEnd = wxPoint( aDC->DeviceToLogicalX( clientSize.x ), cursor.y );
GRLine( &m_ClipBox, aDC, lineStart, lineEnd, 0, aColor );
}
else
{
int len = aDC->DeviceToLogicalXRel( CURSOR_SIZE );
GRLine( &m_ClipBox, aDC, cursor.x - len, cursor.y,
cursor.x + len, cursor.y, 0, aColor );
GRLine( &m_ClipBox, aDC, cursor.x, cursor.y - len,
cursor.x, cursor.y + len, 0, aColor );
}
}
void Embellishment::paintGrace(QPainter *painter, qreal leftEdge, qreal yPos, QString &addition)
{
QPointF lineStart = QPointF(leftEdge+m_graceWidth-1.5, yPos-m_graceHeight*0.3);
//Draw Gracehead
if(hasLineThroughHead(yPos)){
m_graceWithLineRect.moveTopLeft(QPointF(leftEdge, yPos-m_graceWithLineRect.height()/2));
m_svgRenderer->render(painter, "melody_fill_line" + addition, m_graceWithLineRect);
lineStart.setX(lineStart.x()+m_spaceForLine/2);
} else {
m_graceRect.moveTopLeft(QPointF(leftEdge, yPos-m_graceRect.height()/2));
m_svgRenderer->render(painter, "melody_fill" + addition, m_graceRect);
}
//Draw Stem
QPointF lineEnd(lineStart);
if(m_pitches.count() == 1){
//lineEnd.setY( lineEnd.y()-m_singleGraceStemLength);
m_flagRect.moveBottomLeft(QPointF(lineStart.x(), yPos-m_pitchList->lineHeight()/2.5));
m_svgRenderer->render(painter, "flag3_up" + addition, m_flagRect);
lineEnd.setY( m_flagRect.top()-1 );
} else {
lineEnd.setY( m_embellishTop );
}
painter->drawLine(lineStart, lineEnd);
}
// If this is an expires line, then modify it by adding timeNow to the expiration time value.
// Otherwise don't mess with it.
void RegistrationDbTestContext::timeShiftExpiresLine(UtlString& line, long timeNow)
{
const char* EXPIRES_BEGIN = "<expires>";
const int EXPIRES_TAG_LENGTH = 9;
const char* EXPIRES_END = "</expires>";
ssize_t pos1, pos2;
// If the line has an expiration value, then time-shift it
if (((pos1 = line.index(EXPIRES_BEGIN)) != UTL_NOT_FOUND) &&
((pos2 = line.index(EXPIRES_END)) != UTL_NOT_FOUND))
{
pos1 += EXPIRES_TAG_LENGTH; // skip past the tag, to the expires value
CPPUNIT_ASSERT(pos2 > pos1); // expires value cannot be empty
UtlString timeText(line(pos1, pos2 - pos1));
char* endptr = NULL;
long timeNumber = strtol(timeText, &endptr, 10);
CPPUNIT_ASSERT_EQUAL(*endptr, '\0');
char newTime[20]; // room for up to a 64-bit number, may have minus sign
int newTimeLen = sprintf(newTime, "%ld", timeNow + timeNumber);
CPPUNIT_ASSERT(newTimeLen > 0);
// Replace the old expiration value with the new shifted value
UtlString lineEnd(line(pos2, line.length() - pos2));
line.replace(pos1, newTimeLen, newTime);
line.replace(pos1 + newTimeLen, lineEnd.length(), lineEnd);
}
}
void RGB24Buffer::drawLine(int x1, int y1, int x2, int y2, RGBColor color )
{
Rectangle<int> rect;
rect.corner = Vector2d<int>(0,0);
rect.size = Vector2d<int>(w - 1,h - 1);
Vector2d32 lineStart(x1,y1);
Vector2d32 lineEnd(x2,y2);
rect.clipCohenSutherland(lineStart, lineEnd);
drawLineSimple(lineStart.x(), lineStart.y(),lineEnd.x(), lineEnd.y(), color);
}
void IntersectionUnitTests::IntersectionTest()
{
Intersection intersection;
Vector2 lineStart(5,10);
Vector2 lineEnd(2,4);
Vector2 circleCentre(3,6);
float circleRadius = 2.0f;
TEST_ASSERT(intersection.LineCircleIntersection(lineStart,lineEnd,circleCentre, circleRadius) == true);
}
void IntersectionUnitTests::IntersectionTestFail()
{
Intersection intersection;
Vector2 lineStart(1,1);
Vector2 lineEnd(2,2);
Vector2 circleCentre(400, 200);
float circleRadius = 1.0f;
TEST_ASSERT(intersection.LineCircleIntersection(lineStart,lineEnd,circleCentre, circleRadius) == false);
}
void IntersectionUnitTests::IntersectionTestBoundaryPass()
{
Intersection intersection;
Vector2 lineStart(3,0);
Vector2 lineEnd(3,4);
Vector2 circleCentre(2, 2);
float circleRadius = 1.0f;
TEST_ASSERT(intersection.LineCircleIntersection(lineStart,lineEnd,circleCentre, circleRadius) == true);
}
bool update (CodeDocument& codeDoc, int lineNum,
CodeDocument::Iterator& source,
CodeTokeniser* tokeniser, const int tabSpaces,
const CodeDocument::Position& selStart,
const CodeDocument::Position& selEnd)
{
Array <SyntaxToken> newTokens;
newTokens.ensureStorageAllocated (8);
if (tokeniser == nullptr)
{
const String line (codeDoc.getLine (lineNum));
addToken (newTokens, line, line.length(), -1);
}
else if (lineNum < codeDoc.getNumLines())
{
const CodeDocument::Position pos (codeDoc, lineNum, 0);
createTokens (pos.getPosition(), pos.getLineText(),
source, *tokeniser, newTokens);
}
replaceTabsWithSpaces (newTokens, tabSpaces);
int newHighlightStart = 0;
int newHighlightEnd = 0;
if (selStart.getLineNumber() <= lineNum && selEnd.getLineNumber() >= lineNum)
{
const String line (codeDoc.getLine (lineNum));
CodeDocument::Position lineStart (codeDoc, lineNum, 0), lineEnd (codeDoc, lineNum + 1, 0);
newHighlightStart = indexToColumn (jmax (0, selStart.getPosition() - lineStart.getPosition()),
line, tabSpaces);
newHighlightEnd = indexToColumn (jmin (lineEnd.getPosition() - lineStart.getPosition(), selEnd.getPosition() - lineStart.getPosition()),
line, tabSpaces);
}
if (newHighlightStart != highlightColumnStart || newHighlightEnd != highlightColumnEnd)
{
highlightColumnStart = newHighlightStart;
highlightColumnEnd = newHighlightEnd;
}
else if (tokens == newTokens)
{
return false;
}
tokens.swapWith (newTokens);
return true;
}
int main(int, char**){
MyImage image;
//Set up parameters for the line segment
vec2 lineStart(100, 200);
vec2 lineEnd(500, 220);
//Line drawing - midpoint algorithm
//determine if we do a x-loop or y-loop
//TODO: Rasterize the line using the mid-point algorithm
image.show();
// image.save("output.png"); ///< Does not work on Windows!
return EXIT_SUCCESS;
}
TL::Tree::Expr
parseExpression(TL::System& s, const TL::u32string& input)
{
TL::Parser::U32Iterator lineBegin(
TL::Parser::makeUTF32Iterator(input.begin()));
TL::Parser::U32Iterator lineEnd(
TL::Parser::makeUTF32Iterator(input.end())
);
TL::Parser::StreamPosIterator posbegin(lineBegin, input,
0,0);
TL::Parser::StreamPosIterator posend(lineEnd);
TL::Tree::Expr result;
REQUIRE(s.parseExpression(posbegin, posend, result));
return result;
}
void TestSnapStrategy::testProject()
{
//tests for positive point values but backwards leaning line
ExtensionSnapStrategy toTestOne;
qreal toCompWithOne = -1;
QPointF lineStart(4,4);
QPointF lineEnd(2,2);
QPointF comparisonPoint(6,6);
qreal resultingRealOne = toTestOne.project(lineStart, lineEnd, comparisonPoint);
QCOMPARE(resultingRealOne, toCompWithOne);
//testing for for negative point values
ExtensionSnapStrategy toTestTwo;
qreal toCompWithTwo = -4;
QPointF lineStart_2(-2,-2);
QPointF lineEnd_2(-4,-4);
QPointF comparisonPoint_2(6,6);
qreal resultingRealTwo = toTestTwo.project(lineStart_2, lineEnd_2, comparisonPoint_2);
QCOMPARE(resultingRealTwo, toCompWithTwo);
//testing for negative and positive point values
ExtensionSnapStrategy toTestThree;
qreal toCompWithThree = (10*(6/sqrt(72.0)) + 10*(6/sqrt(72.0))) / sqrt(72.0); //diffLength = sqrt(72), scalar = (10*(6/sqrt(72)) + 10*(6/sqrt(72)))
QPointF lineStart_3(-2,-2);
QPointF lineEnd_3(4, 4);
QPointF comparisonPoint_3(8,8);
qreal resultingRealThree = toTestThree.project(lineStart_3, lineEnd_3, comparisonPoint_3);
QCOMPARE(resultingRealThree, toCompWithThree);
//Below we test the formula itself for the dot-product by using values we know return t=0.5
//Formula for how to use the t value is:
//ProjectionPoint = lineStart*(1-resultingReal) + resultingReal*lineEnd; (this is the formula used in BoundingBoxSnapStrategy::squareDistanceToLine())
//Note: The angle of the line from projection point to comparison point is always 90 degrees
ExtensionSnapStrategy toTestFour;
qreal toCompWithFour = 0.5;
QPointF lineStart_4(2,1);
QPointF lineEnd_4(6,3);
QPointF comparisonPoint_4(3,4);
qreal resultingRealFour = toTestFour.project(lineStart_4, lineEnd_4, comparisonPoint_4);
QCOMPARE(resultingRealFour, toCompWithFour);
}
void EDA_DRAW_PANEL::DrawCrossHair( wxDC* aDC, COLOR4D aColor )
{
if( m_cursorLevel != 0 || aDC == NULL || !m_showCrossHair )
return;
wxPoint cursor = GetParent()->GetCrossHairPosition();
#ifdef USE_WX_GRAPHICS_CONTEXT
// Normally cursor color is set to white, so when it is xored with white
// background, it is painted black effectively. wxGraphicsContext does not have
// xor operation, so we need to invert the color manually.
aColor.Invert();
#else
GRSetDrawMode( aDC, GR_XOR );
#endif
if( GetParent()->GetGalDisplayOptions().m_fullscreenCursor )
{
wxSize clientSize = GetClientSize();
// Y axis
wxPoint lineStart( cursor.x, aDC->DeviceToLogicalY( 0 ) );
wxPoint lineEnd( cursor.x, aDC->DeviceToLogicalY( clientSize.y ) );
GRLine( &m_ClipBox, aDC, lineStart, lineEnd, 0, aColor );
// X axis
lineStart = wxPoint( aDC->DeviceToLogicalX( 0 ), cursor.y );
lineEnd = wxPoint( aDC->DeviceToLogicalX( clientSize.x ), cursor.y );
GRLine( &m_ClipBox, aDC, lineStart, lineEnd, 0, aColor );
}
else
{
int len = aDC->DeviceToLogicalXRel( CURSOR_SIZE );
GRLine( &m_ClipBox, aDC, cursor.x - len, cursor.y,
cursor.x + len, cursor.y, 0, aColor );
GRLine( &m_ClipBox, aDC, cursor.x, cursor.y - len,
cursor.x, cursor.y + len, 0, aColor );
}
}
void TubeRendererThread::run()
{
int numThreads = GLFunctions::idealThreadCount;
int chunkSize = m_data.size() / numThreads;
int begin = m_id * chunkSize;
int end = m_id * chunkSize + chunkSize;
if ( m_id == numThreads - 1 )
{
end = m_data.size();
}
// for all voxels:
for ( int i = begin; i < end; ++i )
{
QVector<float> fib = m_data[i];
QVector<float> extra = m_extraData[i];
if ( fib.size() < 9 )
{
printf( "fib with size < 3 detected" );
continue;
}
int numFloats = fib.size();
QVector3D lineStart( fib[0], fib[1], fib[2] );
QVector3D lineEnd( fib[numFloats-3], fib[numFloats-2], fib[numFloats-1] );
QVector3D globalColor( fabs( lineStart.x() - lineEnd.x() ), fabs( lineStart.y() - lineEnd.y() ), fabs( lineStart.z() - lineEnd.z() ) );
globalColor.normalize();
// push back the first vertex, done seperately because of nomal calculation
QVector3D localColor( fib[0] - fib[3], fib[1] - fib[4], fib[2] - fib[5] );
localColor.normalize();
m_verts->push_back( fib[0] );
m_verts->push_back( fib[1] );
m_verts->push_back( fib[2] );
m_verts->push_back( localColor.x() );
m_verts->push_back( localColor.y() );
m_verts->push_back( localColor.z() );
m_verts->push_back( globalColor.x() );
m_verts->push_back( globalColor.y() );
m_verts->push_back( globalColor.z() );
m_verts->push_back( extra.first() );
m_verts->push_back( 1.0 );
m_verts->push_back( fib[0] );
m_verts->push_back( fib[1] );
m_verts->push_back( fib[2] );
m_verts->push_back( localColor.x() );
m_verts->push_back( localColor.y() );
m_verts->push_back( localColor.z() );
m_verts->push_back( globalColor.x() );
m_verts->push_back( globalColor.y() );
m_verts->push_back( globalColor.z() );
m_verts->push_back( extra.first() );
m_verts->push_back( -1.0 );
for ( int k = 1; k < fib.size() / 3 - 1; ++k )
{
QVector3D localColor( fib[k*3-3] - fib[k*3+3], fib[k*3-2] - fib[k*3+4], fib[k*3-1] - fib[k*3+5] );
localColor.normalize();
m_verts->push_back( fib[k*3] );
m_verts->push_back( fib[k*3+1] );
m_verts->push_back( fib[k*3+2] );
m_verts->push_back( localColor.x() );
m_verts->push_back( localColor.y() );
m_verts->push_back( localColor.z() );
m_verts->push_back( globalColor.x() );
m_verts->push_back( globalColor.y() );
m_verts->push_back( globalColor.z() );
m_verts->push_back( extra[k] );
m_verts->push_back( 1.0 );
m_verts->push_back( fib[k*3] );
m_verts->push_back( fib[k*3+1] );
m_verts->push_back( fib[k*3+2] );
m_verts->push_back( localColor.x() );
m_verts->push_back( localColor.y() );
m_verts->push_back( localColor.z() );
m_verts->push_back( globalColor.x() );
m_verts->push_back( globalColor.y() );
m_verts->push_back( globalColor.z() );
m_verts->push_back( extra[k] );
m_verts->push_back( -1.0 );
}
QVector3D localColor2( fib[numFloats-6] - fib[numFloats-3], fib[numFloats-5] - fib[numFloats-2], fib[numFloats-4] - fib[numFloats-1] );
localColor.normalize();
// push back the last vertex, done seperately because of nomal calculation
m_verts->push_back( fib[numFloats-3] );
m_verts->push_back( fib[numFloats-2] );
m_verts->push_back( fib[numFloats-1] );
m_verts->push_back( localColor2.x() );
m_verts->push_back( localColor2.y() );
m_verts->push_back( localColor2.z() );
m_verts->push_back( globalColor.x() );
m_verts->push_back( globalColor.y() );
m_verts->push_back( globalColor.z() );
m_verts->push_back( extra.last() );
m_verts->push_back( 1.0 );
m_verts->push_back( fib[numFloats-3] );
m_verts->push_back( fib[numFloats-2] );
m_verts->push_back( fib[numFloats-1] );
m_verts->push_back( localColor2.x() );
m_verts->push_back( localColor2.y() );
m_verts->push_back( localColor2.z() );
m_verts->push_back( globalColor.x() );
m_verts->push_back( globalColor.y() );
m_verts->push_back( globalColor.z() );
m_verts->push_back( extra.last() );
m_verts->push_back( -1.0 );
}
}
bool update (CodeDocument& document, int lineNum,
CodeDocument::Iterator& source,
CodeTokeniser* analyser, const int spacesPerTab,
const CodeDocument::Position& selectionStart,
const CodeDocument::Position& selectionEnd)
{
OwnedArray <SyntaxToken> newTokens;
if (analyser == 0)
{
newTokens.add (new SyntaxToken (document.getLine (lineNum), -1));
}
else if (lineNum < document.getNumLines())
{
const CodeDocument::Position pos (&document, lineNum, 0);
createTokens (pos.getPosition(), pos.getLineText(),
source, analyser, newTokens);
}
replaceTabsWithSpaces (newTokens, spacesPerTab);
int newHighlightStart = 0;
int newHighlightEnd = 0;
if (selectionStart.getLineNumber() <= lineNum && selectionEnd.getLineNumber() >= lineNum)
{
const String line (document.getLine (lineNum));
CodeDocument::Position lineStart (&document, lineNum, 0), lineEnd (&document, lineNum + 1, 0);
newHighlightStart = indexToColumn (jmax (0, selectionStart.getPosition() - lineStart.getPosition()),
line, spacesPerTab);
newHighlightEnd = indexToColumn (jmin (lineEnd.getPosition() - lineStart.getPosition(), selectionEnd.getPosition() - lineStart.getPosition()),
line, spacesPerTab);
}
if (newHighlightStart != highlightColumnStart || newHighlightEnd != highlightColumnEnd)
{
highlightColumnStart = newHighlightStart;
highlightColumnEnd = newHighlightEnd;
}
else
{
if (tokens.size() == newTokens.size())
{
bool allTheSame = true;
for (int i = newTokens.size(); --i >= 0;)
{
if (*tokens.getUnchecked(i) != *newTokens.getUnchecked(i))
{
allTheSame = false;
break;
}
}
if (allTheSame)
return false;
}
}
tokens.swapWithArray (newTokens);
return true;
}
// FormatError
//------------------------------------------------------------------------------
void Error::FormatError( const BFFIterator & iter,
uint32_t errNum,
const Function * function,
const char * message, ... )
{
ASSERT( message );
AStackString< 4096 > buffer;
va_list args;
va_start(args, message);
buffer.VFormat( message, args );
va_end( args );
// get human readable info about the position of the error
uint32_t line = 0;
uint32_t column = 0;
const char * lineStart = nullptr;
iter.GetPosInfo( line, column, lineStart );
// convert to full path and '/'->'\' cleanup
const AStackString<> fileName( iter.GetFileName() );
AStackString<> fullPath;
NodeGraph::CleanPath( fileName, fullPath );
// deliberately using OUTPUT here to avoid "Error:" in front
OUTPUT( "%s(%u,%u): FASTBuild Error #%04u - %s%s%s\n",
fullPath.Get(),
line,
column,
errNum,
function ? function->GetName().Get() : "",
function ? "() - " : "",
buffer.Get() );
// find the line end
BFFIterator lineEnd( iter );
while ( !lineEnd.IsAtEnd() )
{
if (( *lineEnd != '\r' ) && ( *lineEnd != '\n' ))
{
lineEnd++;
continue;
}
break;
}
// if line is too crazy to be useful, don't print anything more
size_t lineLength = lineEnd.GetCurrent() - lineStart;
if ( lineLength >= 256 )
{
return;
}
// print the problematic line
AString::Copy( lineStart, buffer.Get(), lineLength );
FLOG_ERROR( "%s", buffer.Get() );
// point to the specific pos where parsing broke
// (taking into account tabs)
char * c = buffer.Get();
const char * end = c + column - 1;
for ( ; c < end; ++c )
{
if ( *c != '\t' )
{
*c = ' ';
}
}
AString::Copy( "^", c, 1 );
FLOG_ERROR( buffer.Get() );
AString::Copy( "\\--here", c, 8 );
FLOG_ERROR( buffer.Get() );
}
void SFMLCursesTextBox::updateTextBox()
{
/*
std::string word = "";
int col = 0;
int line = 0;
for(std::string::iterator stringIt(m_text.begin()); stringIt != m_text.end(); stringIt++)
{
if(*stringIt == ' ' || stringIt == m_text.end() - 1) //word is complete
{
//WARNING: If a word is longer than the width that word and any after will not be printed
//needs mid-word linebreaking
//left justified
if(stringIt == m_text.end() - 1)
word += *stringIt;
if(word.length() > static_cast<unsigned int>(m_cursesSize.y))
break;
if(word.length() > static_cast<unsigned int>(m_cursesSize.y - col)) //word too long for this line, move onto next one
{
line++;
col = 0;
}
if(line >= m_cursesSize.x) //past the last line
break;
for(std::string::iterator wordIt(word.begin()); wordIt != word.end(); wordIt++)
{
setTile(SFMLCursesChar(m_window, std::string("") + *wordIt), sf::Vector2i(line,col));
col++;
}
if(col < m_cursesSize.y - 1)
{
setTile(SFMLCursesChar(m_window, " "), sf::Vector2i(line,col));
col++;
}
word = "";
}
else
{
word += *stringIt;
}
}
*/
clearTiles(" ", m_textColor, m_backColor);
std::string::const_iterator lineBegin(m_text.begin());
std::string::const_iterator lineEnd(m_text.begin());
unsigned int line = 0;
while(lineBegin != m_text.end())
{
std::string::const_iterator lastLineEnd(lineEnd);
unsigned int position = m_text.find(" ", lineEnd - m_text.begin() + 1);
if(position != std::string::npos)
lineEnd = m_text.begin() + position;
else
lineEnd = m_text.end();
if(lineEnd - lineBegin > m_cursesSize.y || lineEnd == m_text.end()) //too much for this line
{
if(!(lineEnd - lineBegin > m_cursesSize.y))
lastLineEnd = lineEnd;
//backtrack, print, next line
unsigned int col = 0;
//unsigned int spacePadding = 0;
unsigned int wordCount = std::count(lineBegin, lastLineEnd, ' ') + 1;
unsigned int wordCountRemaining = wordCount;
unsigned int extraSpace = m_cursesSize.y - (lastLineEnd - lineBegin);
unsigned int extraSpaceRemaining = extraSpace;
//print with proper alignment
switch(m_alignment)
{
case Alignment::Left:
col = 0;
break;
case Alignment::Right:
col = m_cursesSize.y - (lastLineEnd - lineBegin);
break;
case Alignment::Center:
col = m_cursesSize.y/2 - (lastLineEnd - lineBegin)/2;
break;
case Alignment::Justify:
col = 0;
break;
}
for(lineBegin; lineBegin != lastLineEnd; lineBegin++)
{
setTile(SFMLCursesChar(m_window, std::string("") + *lineBegin, m_textColor, m_backColor), sf::Vector2i(line,col));
switch(m_alignment)
{
case Alignment::Left:
case Alignment::Right:
case Alignment::Center:
col++;
break;
case Alignment::Justify:
col++;
if(extraSpaceRemaining > 0 && *lineBegin == ' ' && lastLineEnd != m_text.end())
{
col++;
extraSpaceRemaining--;
if(extraSpaceRemaining >= wordCountRemaining - 1)
{
col++;
extraSpaceRemaining--;
}
wordCountRemaining--;
}
break;
}
}
if(lineBegin != m_text.end())
lineBegin++;
else
break;
line++;
wordCount = 0;
}
if(line >= static_cast<unsigned int>(m_cursesSize.x))
break;
}
}
static void httpServerEngineCycle(void *param) {
FskErr err = kFskErrNone, retVal = kFskErrNeedMoreTime;
FskHTTPServerRequest request = (FskHTTPServerRequest)param;
int amt, ret, chunkSize = 0;
UInt32 chunkSizeL;
char *s, *p;
Boolean readSomeMore, needsDispose = false;
FskThreadRemoveDataHandler(&request->dataHandler);
switch (request->state) {
case kHTTPNewSession:
FskInstrumentedItemSendMessage(request, kFskHTTPInstrMsgRequestState, request);
FskTimeGetNow(&request->stats.requestStarted);
request->state = kHTTPReadRequestHeaders;
case kHTTPReadRequestHeaders:
FskInstrumentedItemSendMessage(request, kFskHTTPInstrMsgRequestState, request);
shoveBuffer(request->in);
amt = request->in.bufferSize - request->in.max;
if (amt) {
err = FskNetSocketRecvTCP(request->skt, &request->in.buf[request->in.max], amt, &ret);
switch (err) {
case kFskErrNone:
#if SUPPORT_INSTRUMENTATION
if (FskInstrumentedItemHasListeners(request)) {
FskHTTPInstrMsgDataRecord msg;
msg.buffer = &request->in.buf[request->in.max];
msg.amt = ret;
FskInstrumentedItemSendMessage(request, kFskHTTPInstrMsgRequestRecvData, &msg);
}
#endif
request->http->stats.requestsStarted += 1;
request->in.max += ret;
request->state = kHTTPProcessRequestHeaders;
request->stats.bytesReceived += ret;
request->http->stats.bytesReceived += ret;
break;
case kFskErrNoData:
retVal = kFskErrNoData;
break;
case kFskErrConnectionClosed:
if (request->stats.bytesReceived) {
request->state = kHTTPSocketError;
}
else {
request->state = kHTTPDone;
}
break;
default:
FskInstrumentedItemSendMessage(request, kFskHTTPInstrMsgErrString, "kHTTPReadRequestHeaders: RecvTCP - error");
request->state = kHTTPSocketError;
break;
}
}
else
request->state = kHTTPProcessRequestHeaders;
if (request->state != kHTTPProcessRequestHeaders)
break;
case kHTTPProcessRequestHeaders:
FskInstrumentedItemSendMessage(request, kFskHTTPInstrMsgRequestState, request);
amt = request->in.max - request->in.pos;
if (amt) {
ret = FskHeadersParseChunk(&request->in.buf[request->in.pos], amt, kFskHeaderTypeRequest, request->requestHeaders);
if (ret < 0) {
err = kFskErrBadData;
request->state = kHTTPSocketError;
break;
}
request->in.pos += ret;
if (request->requestHeaders->headersParsed) {
httpProcessRequestHeaders(request);
}
else if (ret != amt) {
// odd case - we didn't consume all the data, but
// the header parsing isn't complete.
request->state = kHTTPServerError;
}
}
else
request->state = kHTTPReadRequestHeaders;
if (request->state != kHTTPReadRequestBody)
break;
case kHTTPReadRequestBody:
FskInstrumentedItemSendMessage(request, kFskHTTPInstrMsgRequestState, request);
readSomeMore = false;
amt = request->in.max - request->in.pos;
if (request->requestBodyContentLength > 0) {
if (amt) {
request->state = kHTTPProcessRequestBody;
}
else {
request->in.max = 0;
request->in.pos = 0;
readSomeMore = true;
}
}
else if (request->requestBodyChunked) { // chunked
if (amt == 0) {
readSomeMore = true;
}
else {
p = &request->in.buf[request->in.pos];
while ((amt > 1) && lineEnd(p)) {
// consume line-ends
amt -= 2;
request->in.pos += 2;
p += 2;
}
while ((amt > 1) && !lineEnd(p)) {
// scan for chunk size
amt--;
p++;
}
if ((amt > 1) && lineEnd(p)) {
// convert the chunksize
s = &request->in.buf[request->in.pos];
chunkSize = FskStrHexToNum(s, p-s);
p += 2; //lineend
request->requestBodyContentLength = chunkSize;
request->in.pos += (p-s);
request->state = kHTTPReadRequestBody;
if (0 == chunkSize) {
// we've read the end indicator (0)
if ((amt > 1) && lineEnd(p))
request->in.pos += 2; // consume last cr/lf }
request->requestBodyChunked = false;
}
}
else {
readSomeMore = true;
}
}
}
else {
// we're done reading chunks
// we're done reading the request
request->state = kHTTPPrepareResponse;
doCallCondition(request->http->callbacks->requestCondition, request, kFskHTTPConditionRequestRequestFinished, request->refCon);
}
if (readSomeMore) {
shoveBuffer(request->in);
err = FskNetSocketRecvTCP(request->skt, &request->in.buf[request->in.max], request->in.bufferSize - request->in.max, &ret);
switch (err) {
case kFskErrNone:
#if SUPPORT_INSTRUMENTATION
if (FskInstrumentedItemHasListeners(request)) {
FskHTTPInstrMsgDataRecord msg;
msg.buffer = &request->in.buf[request->in.max];
msg.amt = ret;
FskInstrumentedItemSendMessage(request, kFskHTTPInstrMsgRequestRecvData, &msg);
}
#endif
request->in.max += ret;
if (request->requestBodyChunked) // chunked?
request->state = kHTTPReadRequestBody;
else
request->state = kHTTPProcessRequestBody;
request->stats.bytesReceived += ret;
request->http->stats.bytesReceived += ret;
break;
case kFskErrNoData:
retVal = kFskErrNoData;
break;
default:
FskInstrumentedItemSendMessage(request, kFskHTTPInstrMsgErrString, "kHTTPReadRequestBody: RecvTCP - error");
request->http->stats.requestsFailed += 1;
request->state = kHTTPSocketError;
break;
}
}
if (request->state != kHTTPProcessRequestBody)
break;
case kHTTPProcessRequestBody:
FskInstrumentedItemSendMessage(request, kFskHTTPInstrMsgRequestState, request);
amt = request->in.max - request->in.pos;
if (amt > request->requestBodyContentLength) {
if (false == request->requestBodyChunked)
request->requestBodyContentLength = amt;
else
amt = request->requestBodyContentLength;
}
chunkSizeL = (UInt32)chunkSize;
err = doDataCallback(request->http->callbacks->requestReceiveRequest, request, &request->in.buf[request->in.pos], amt, &chunkSizeL, request->refCon);
chunkSize = (int)chunkSizeL;
if (kFskErrNone == err) {
if (chunkSize) {
request->in.pos += chunkSize;
request->requestBodyContentLength -= chunkSize;
request->stats.requestBodyReceived += chunkSize;
if (false == request->requestBodyChunked) {
if (0 == request->requestBodyContentLength)
request->state = kHTTPPrepareResponse;
else
request->state = kHTTPReadRequestBody;
}
else
request->state = kHTTPReadRequestBody;
}
else {
// data callback wants to suspend the session and not
// consume the chunk, it can do so
if (request->state != kHTTPSessionSuspend)
request->state = kHTTPServerError;
}
}
else {
// the data callback returned an error.
if (request->state != kHTTPSessionSuspend)
request->state = kHTTPServerError;
}
if (request->state != kHTTPPrepareResponse)
break;
doCallCondition(request->http->callbacks->requestCondition, request, kFskHTTPConditionRequestRequestFinished, request->refCon);
if (request->state != kHTTPPrepareResponse)
break;
case kHTTPPrepareResponse:
FskInstrumentedItemSendMessage(request, kFskHTTPInstrMsgRequestState, request);
request->state = kHTTPProcessResponse;
err = doCallCondition(request->http->callbacks->requestCondition, request, kFskHTTPConditionRequestGenerateResponseHeaders, request->refCon);
if (err == kFskErrNeedMoreTime)
request->state = kHTTPSessionSuspend;
else if (err)
request->responseHeaders->responseCode = 500;
if (request->state != kHTTPProcessResponse)
break;
case kHTTPProcessResponse:
request->state = kHTTPGetDataChunk;
httpPrepareResponseHeaders(request);
if (request->state != kHTTPGetDataChunk)
break;
case kHTTPGetDataChunk:
FskInstrumentedItemSendMessage(request, kFskHTTPInstrMsgRequestState, request);
if (0 == FskStrCompare(kFskStrHEAD, FskHeaderMethod(request->requestHeaders))) {
request->state = kHTTPSendDataChunk;
request->nextState = kHTTPSetupNextRequest;
break;
}
p = &request->out.buf[request->out.max];
if (request->transferEncoding == kFskTransferEncodingChunked) {
request->out.max += 6;
}
chunkSize = 0;
amt = (request->out.bufferSize - request->out.max) - 2;
// fetch response data from callback
chunkSizeL = (UInt32)chunkSize;
err = doDataCallback(request->http->callbacks->requestGenerateResponseBody, request, &request->out.buf[request->out.max], amt, &chunkSizeL, request->refCon);
chunkSize = (int)chunkSizeL;
FskInstrumentedTypePrintfDebug(&gFskHTTPServerTypeInstrumentation, "doDataCallback returns err: %d, chunkSize: %d\n", err, chunkSize);
if ((kFskErrNone != err) && (kFskErrEndOfFile != err)) {
FskInstrumentedTypePrintfDebug(&gFskHTTPServerTypeInstrumentation, "about to doCallCondition -requestResponseFinished - FAIL\n");
doCallCondition(request->http->callbacks->requestCondition, request, kFskHTTPConditionRequestResponseFinished, request->refCon);
request->http->stats.requestsFailed += 1;
request->state = kHTTPServerError;
break;
}
request->out.max += chunkSize;
if ((0 == chunkSize) && (request->state == kHTTPSessionSuspend)) {
if (kFskTransferEncodingChunked == request->transferEncoding)
request->out.max -= 6;
break;
}
request->state = kHTTPSendDataChunk;
if ((chunkSize == 0) || (kFskErrEndOfFile == err)) {
request->nextState = kHTTPSetupNextRequest;
}
else
request->nextState = kHTTPGetDataChunk;
if (request->transferEncoding == kFskTransferEncodingChunked) {
FskStrNumToHex(chunkSize, p, 4);
p += 4;
*p++ = kFskCR;
*p++ = kFskLF;
if (chunkSize)
p += chunkSize;
*p++ = kFskCR;
*p++ = kFskLF;
request->out.max += 2;
}
request->stats.bodyBytesSent += chunkSize;
if (request->state != kHTTPSendDataChunk)
break;
case kHTTPSendDataChunk:
FskInstrumentedItemSendMessage(request, kFskHTTPInstrMsgRequestState, request);
FskInstrumentedTypePrintfDebug(&gFskHTTPServerTypeInstrumentation, " - request->out.max %d - request->out.pos %d\n", request->out.max, request->out.pos);
amt = request->out.max - request->out.pos;
if (0 == amt) {
FskInstrumentedTypePrintfDebug(&gFskHTTPServerTypeInstrumentation, "amt is zero now - transition to next state.\n");
request->state = request->nextState;
break;
}
err = FskNetSocketSendTCP(request->skt, &request->out.buf[request->out.pos], amt, &ret);
switch (err) {
case kFskErrNone:
#if SUPPORT_INSTRUMENTATION
if (FskInstrumentedItemHasListeners(request)) {
FskHTTPInstrMsgDataRecord msg;
msg.buffer = &request->out.buf[request->out.pos];
msg.amt = ret;
FskInstrumentedItemSendMessage(request, kFskHTTPInstrMsgRequestSendData, &msg);
}
#endif
request->out.pos += ret;
request->stats.bytesSent += ret;
request->http->stats.bytesSent += ret;
if (request->transferEncoding == kFskTransferEncodingChunked) {
request->stats.bytesSent -= 8;
}
if (request->out.pos == request->out.max) {
request->out.pos = 0;
request->out.max = 0;
request->state = request->nextState;
}
break;
case kFskErrNoData:
retVal = kFskErrSocketFull;
break;
default:
FskInstrumentedItemSendMessage(request, kFskHTTPInstrMsgErrString, "kHTTPSendDataChunk: SendTCP - error");
request->state = kHTTPSocketError;
request->http->stats.requestsFailed += 1;
break;
}
if (request->state != kHTTPSetupNextRequest)
break;
case kHTTPSetupNextRequest:
FskInstrumentedItemSendMessage(request, kFskHTTPInstrMsgRequestState, request);
FskTimeGetNow(&request->stats.requestStopped);
request->http->stats.requestsFinished += 1;
doCallCondition(request->http->callbacks->requestCondition, request, kFskHTTPConditionRequestResponseFinished, request->refCon);
request->state = kHTTPDone;
if (request->keepAlive && !request->http->stopped) {
if ((request->in.max - request->in.pos) > 0) {
FskHeaderStructDispose(request->requestHeaders);
FskHeaderStructDispose(request->responseHeaders);
FskHeaderStructNew(&request->requestHeaders);
FskHeaderStructNew(&request->responseHeaders);
request->keepAlive = false;
request->out.max = 0;
request->out.pos = 0;
FskMemSet(&request->stats, 0, sizeof(request->stats));
FskTimeGetNow(&request->stats.requestStarted);
request->state = kHTTPProcessRequestHeaders;
}
}
if (request->state != kHTTPDone)
break;
case kHTTPDone:
FskInstrumentedItemSendMessage(request, kFskHTTPInstrMsgRequestState, request);
if (request->keepAlive && !request->http->stopped) {
FskHeaderStructDispose(request->requestHeaders);
FskHeaderStructDispose(request->responseHeaders);
FskHeaderStructNew(&request->requestHeaders);
FskHeaderStructNew(&request->responseHeaders);
request->keepAlive = false;
request->in.max = 0;
request->in.pos = 0;
request->out.max = 0;
request->out.pos = 0;
FskMemSet(&request->stats, 0, sizeof(request->stats));
retVal = kFskErrNoData; // will cause data handler to be installed
request->state = kHTTPNewSession;
}
else {
request->state = kHTTPClose;
retVal = kFskErrNeedMoreTime;
}
break;
case kHTTPFulfillExpectation:
FskInstrumentedItemSendMessage(request, kFskHTTPInstrMsgRequestState, request);
request->state = kHTTPSendDataChunk;
request->nextState = kHTTPReadRequestBody;
request->out.max += snprintf(request->out.buf, request->out.bufferSize, "%s %d %s\r\n\r\n", httpProtocolVersionString(request), 100, FskFindResponse(100));
break;
case kHTTPDenyExpectation:
FskInstrumentedItemSendMessage(request, kFskHTTPInstrMsgRequestState, request);
request->state = kHTTPSendDataChunk;
request->nextState = kHTTPDone;
request->out.max += snprintf(request->out.buf, request->out.bufferSize, "%s %d %s\r\n\r\n", httpProtocolVersionString(request), 417, FskFindResponse(417));
break;
case kHTTPServerError:
FskInstrumentedItemSendMessage(request, kFskHTTPInstrMsgRequestState, request);
request->state = kHTTPSocketError;
// fall through
case kHTTPSocketError:
FskInstrumentedItemSendMessage(request, kFskHTTPInstrMsgRequestState, request);
request->http->stats.connectionsAborted++;
doCallCondition(request->http->callbacks->requestCondition, request, kFskHTTPConditionRequestErrorAbort, request->refCon);
request->state = kHTTPClose;
// fall through
case kHTTPClose:
FskInstrumentedItemSendMessage(request, kFskHTTPInstrMsgRequestState, request);
request->state = kHTTPRequestComplete;
needsDispose = true;
break;
case kHTTPRequestComplete:
FskInstrumentedItemSendMessage(request, kFskHTTPInstrMsgRequestState, request);
retVal = kFskErrNone; // request is finished, don't call back
break;
case kHTTPSessionSuspend:
FskInstrumentedItemSendMessage(request, kFskHTTPInstrMsgRequestState, request);
retVal = kFskErrNone; // do nothing in suspend state
break;
default:
FskInstrumentedItemSendMessage(request, kFskHTTPInstrMsgRequestState, request);
request->state = kHTTPClose; // unknown state
break;
;
}
if ((request->state == kHTTPServerError)
|| (request->state == kHTTPSocketError)
|| (request->state == kHTTPDone)
|| (request->state == kHTTPClose))
retVal = kFskErrNeedMoreTime;
if (retVal == kFskErrNoData) {
FskThreadAddDataHandler(&request->dataHandler, (FskThreadDataSource)request->skt, httpServerDataHandler, true, false, request);
}
else if (retVal == kFskErrSocketFull) {
FskThreadAddDataHandler(&request->dataHandler, (FskThreadDataSource)request->skt, httpServerDataHandler, false, true, request);
}
else if (retVal == kFskErrNeedMoreTime) {
FskTimeCallbackScheduleNextRun(request->cycleCallback, httpServerTimeCycle, request);
}
else if (retVal == kFskErrNone) {
// nothing doin
}
else {
FskInstrumentedTypePrintfDebug(&gFskHTTPServerTypeInstrumentation, "httpCycle - weird retVal %d\n", retVal);
}
if (needsDispose) {
FskListRemove((FskList*)&request->http->activeRequests, request);
FskTimeCallbackDispose(request->keepAliveKillCallback);
request->keepAliveKillCallback = NULL;
if (kFskErrNone != doCallCondition(request->http->callbacks->requestCondition, request, kFskHTTPConditionConnectionTerminating, request->refCon))
FskHTTPServerRequestDispose(request);
}
else {
if ((retVal == kFskErrNeedMoreTime) || ((retVal != kFskErrNone) && request->keepAlive)) {
FskTimeCallbackScheduleFuture(request->keepAliveKillCallback, FskHTTPServerRequestGetKeepAliveTimeout(request), 0, httpKillKeepAlive, request);
}
}
}
void TEditor::handleEvent( TEvent& event )
{
TView::handleEvent( event );
convertEvent( event );
Boolean centerCursor = Boolean(!cursorVisible());
uchar selectMode = 0;
if( selecting == True || (getShiftState() & 0x03) != 0 )
selectMode = smExtend;
switch( event.what )
{
case evMouseDown:
if( event.mouse.doubleClick == True )
selectMode |= smDouble;
do {
lock();
if( event.what == evMouseAuto )
{
TPoint mouse = makeLocal( event.mouse.where );
TPoint d = delta;
if( mouse.x < 0 )
d.x--;
if( mouse.x >= size.x )
d.x++;
if( mouse.y < 0 )
d.y--;
if( mouse.y >= size.y )
d.y++;
scrollTo(d.x, d.y);
}
setCurPtr(getMousePtr(event.mouse.where), selectMode);
selectMode |= smExtend;
unlock();
} while( mouseEvent(event, evMouseMove + evMouseAuto) );
break;
case evKeyDown:
if( event.keyDown.charScan.charCode == 9 ||
( event.keyDown.charScan.charCode >= 32 && event.keyDown.charScan.charCode < 255 ) )
{
lock();
if( overwrite == True && hasSelection() == False )
if( curPtr != lineEnd(curPtr) )
selEnd = nextChar(curPtr);
insertText( &event.keyDown.charScan.charCode, 1, False);
trackCursor(centerCursor);
unlock();
}
else
return;
break;
case evCommand:
switch( event.message.command )
{
case cmFind:
find();
break;
case cmReplace:
replace();
break;
case cmSearchAgain:
doSearchReplace();
break;
default:
lock();
switch( event.message.command )
{
case cmCut:
clipCut();
break;
case cmCopy:
clipCopy();
// hideSelect(); // JS 12.4.94
break;
case cmPaste:
clipPaste();
break;
case cmUndo:
undo();
break;
case cmClear:
deleteSelect();
break;
case cmCharLeft:
setCurPtr(prevChar(curPtr), selectMode);
break;
case cmCharRight:
setCurPtr(nextChar(curPtr), selectMode);
break;
case cmWordLeft:
setCurPtr(prevWord(curPtr), selectMode);
break;
case cmWordRight:
setCurPtr(nextWord(curPtr), selectMode);
break;
case cmLineStart:
setCurPtr(lineStart(curPtr), selectMode);
break;
case cmLineEnd:
setCurPtr(lineEnd(curPtr), selectMode);
break;
case cmLineUp:
setCurPtr(lineMove(curPtr, -1), selectMode);
break;
case cmLineDown:
setCurPtr(lineMove(curPtr, 1), selectMode);
break;
case cmPageUp:
setCurPtr(lineMove(curPtr, -(size.y-1)), selectMode);
break;
case cmPageDown:
setCurPtr(lineMove(curPtr, size.y-1), selectMode);
break;
case cmTextStart:
setCurPtr(0, selectMode);
break;
case cmTextEnd:
setCurPtr(bufLen, selectMode);
break;
case cmNewLine:
newLine();
break;
case cmBackSpace:
deleteRange(prevChar(curPtr), curPtr, True);
break;
case cmDelChar:
deleteRange(curPtr, nextChar(curPtr), True);
break;
case cmDelWord:
deleteRange(curPtr, nextWord(curPtr), False);
break;
case cmDelStart:
deleteRange(lineStart(curPtr), curPtr, False);
break;
case cmDelEnd:
deleteRange(curPtr, lineEnd(curPtr), False);
break;
case cmDelLine:
deleteRange(lineStart(curPtr), nextLine(curPtr), False);
break;
case cmInsMode:
toggleInsMode();
break;
case cmStartSelect:
startSelect();
break;
case cmHideSelect:
hideSelect();
break;
case cmIndentMode:
autoIndent = Boolean(!autoIndent);
break;
default:
unlock();
return;
}
trackCursor(centerCursor);
unlock();
break;
}
case evBroadcast:
switch( event.message.command )
{
case cmScrollBarChanged:
checkScrollBar( event, hScrollBar, delta.x );
checkScrollBar( event, vScrollBar, delta.y );
break;
default:
return;
}
}
clearEvent(event);
}
// ---------------------------------------------------------------
// strategie exploration en passant par la rangee en y = 1350
// ---------------------------------------------------------------
bool StrategyLargeAttackCL::preDefinedSkittleExploration2()
{
LOG_COMMAND("preDefinedLargeSkittleExploration2\n");
MvtMgr->setRobotDirection(MOVE_DIRECTION_FORWARD);
bool noRotation = true;
Point lineStart(2500, 1500);
Point lineEnd(3200, 1500);
Move->go2Target(lineStart,
MOVE_USE_DEFAULT_GAIN,
MOVE_USE_DEFAULT_SPEED,
noRotation);
Events->wait(evtEndMove);
if (!Events->isInWaitResult(EVENTS_MOVE_END)) {
// on n'a pas reussi
if (checkEndEvents()) return false; // c'est la fin du match?
CollisionEnum collision = checkCollisionEvents();
if (collision != COLLISION_NONE) {
if (!handleCollision(collision, lineStart, lineEnd))
return false;
} else {
LOG_WARNING("don't know what caused abort of movement. -> abort predefined exploration\n");
return false;
}
} else {
// go2Target succeeded its movement.
Move->rotate(0); // face right border
Events->wait(evtEndMove);
if (!Events->isInWaitResult(EVENTS_MOVE_END)) {
if (checkEndEvents()) return false; // end of match
// ok. normally the collision can only be on the left side...
CollisionEnum collision = checkCollisionEvents();
if (collision == COLLISION_LEFT) {
if (!handleCollision(collision, lineStart, lineEnd))
return false;
} else if (collision == COLLISION_NONE) {
LOG_WARNING("unhandled event. leaving function\n");
return false;
} else {
LOG_WARNING("collision, but most likely not a support\n");
return false;
}
}
}
bool endOfLine = false;
while (!endOfLine) {
Move->go2Target(lineEnd);
Events->wait(evtEndMove);
if (!Events->isInWaitResult(EVENTS_MOVE_END)) {
// let's hope it's a support.
if (checkEndEvents()) return false; // c'est la fin du match?
CollisionEnum collision = checkCollisionEvents();
if (collision != COLLISION_NONE) {
if (!handleCollision(collision, lineStart, lineEnd))
return false;
} else {
LOG_WARNING("don't know what caused abort of movement. -> abort predefined exploration\n");
return false;
}
if (!RobotPos->isTargetForward(lineEnd))
endOfLine = true;
} else {
// ok. no more supports detected
endOfLine = true;
}
}
LOG_INFO("predefined-large finished.\n");
//alignBorder();
// on recule un petit peu car on ne sais pas ce qu'on va se prendre en
// approchant du robot adverse!, mieux vaut tenir que courir
MvtMgr->setRobotDirection(MOVE_DIRECTION_BACKWARD);
Trajectory t;
t.clear();
t.push_back(Point(3144, 1350));
t.push_back(Point(3190, 1700));
Move->followTrajectory(t, TRAJECTORY_BASIC);
Events->wait(evtEndMove);
if (!Events->isInWaitResult(EVENTS_MOVE_END)) {
// on n'a pas reussi
// c'est la fin du match?
if (checkEndEvents()) return false;
// TODO manage collisions
return false;
}
//alignBorder();
// on va droit sur l'adversaire
MvtMgr->setRobotDirection(MOVE_DIRECTION_FORWARD);
Move->go2Target(Point(3190, 650));
Events->wait(evtEndMove);
if (!Events->isInWaitResult(EVENTS_MOVE_END)) {
// on n'a pas reussi
// c'est la fin du match?
if (checkEndEvents()) return false;
// TODO manage collisions
return false;
}
// on recule un peu
MvtMgr->setRobotDirection(MOVE_DIRECTION_BACKWARD);
Move->go2Target(Point(3190, 1050));
Events->wait(evtEndMove);
if (!Events->isInWaitResult(EVENTS_MOVE_END)) {
// on n'a pas reussi
// c'est la fin du match?
if (checkEndEvents()) return false;
// TODO manage collisions
return false;
}
t.clear();
t.push_back(Point(2550, 1050));
t.push_back(Point(2594, 1650));
t.push_back(Point(3340, 1650));
MvtMgr->setRobotDirection(MOVE_DIRECTION_FORWARD);
Move->followTrajectory(t, TRAJECTORY_BASIC);
Events->wait(evtEndMove);
if (!Events->isInWaitResult(EVENTS_MOVE_END)) {
// on n'a pas reussi
// c'est la fin du match?
if (checkEndEvents()) return false;
// TODO manage collisions
return false;
}
MvtMgr->setRobotDirection(MOVE_DIRECTION_BACKWARD);
Move->go2Target(Point(3190, 1650));
Events->wait(evtEndMove);
if (!Events->isInWaitResult(EVENTS_MOVE_END)) {
// on n'a pas reussi
// c'est la fin du match?
if (checkEndEvents()) return false;
// TODO manage collisions
return false;
}
return true;
}
ushort TEditor::nextLine( ushort p )
{
return nextChar(lineEnd(p));
}
