void GuiTextEditCtrl::onRender( Point2I offset, const RectI &updateRect )
{
RectI ctrlRect( offset, getExtent() );
//if opaque, fill the update rect with the fill color
if ( mProfile->mOpaque )
{
if ( !mTextValid )
GFX->getDrawUtil()->drawRectFill( ctrlRect, mProfile->mFillColorERR );
else if ( isFirstResponder() )
GFX->getDrawUtil()->drawRectFill( ctrlRect, mProfile->mFillColorHL );
else
GFX->getDrawUtil()->drawRectFill( ctrlRect, mProfile->mFillColor );
}
//if there's a border, draw the border
if ( mProfile->mBorder )
{
renderBorder( ctrlRect, mProfile );
if ( !mTextValid )
GFX->getDrawUtil()->drawRectFill( ctrlRect, mProfile->mFillColorERR );
}
drawText( ctrlRect, isFirstResponder() );
}
void GuiTextEditSliderCtrl::onPreRender()
{
if (isFirstResponder())
{
U32 timeElapsed = Platform::getVirtualMilliseconds() - mTimeLastCursorFlipped;
mNumFramesElapsed++;
if ((timeElapsed > 500) && (mNumFramesElapsed > 3))
{
mCursorOn = !mCursorOn;
mTimeLastCursorFlipped = Sim::getCurrentTime();
mNumFramesElapsed = 0;
setUpdate();
}
//update the cursor if the text is scrolling
if (mDragHit)
{
if ((mScrollDir < 0) && (mCursorPos > 0))
{
mCursorPos--;
}
else if ((mScrollDir > 0) && (mCursorPos < (S32)dStrlen(mText)))
{
mCursorPos++;
}
}
}
}
bool GuiTextEditSliderCtrl::onMouseWheelDown(const GuiEvent &event)
{
if ( !mActive || !mAwake || !mVisible )
return Parent::onMouseWheelDown(event);
if ( !isFirstResponder() && !mFocusOnMouseWheel )
{
GuiControl *parent = getParent();
if ( parent )
return parent->onMouseWheelUp( event );
return false;
}
mValue -= mIncAmount;
checkRange();
setValue();
setFirstResponder();
mCursorPos = mBlockStart = mBlockEnd = 0;
setUpdate();
return true;
}
void GuiScriptNotifyCtrl::setFirstResponder()
{
Parent::setFirstResponder();
// Call Script.
if( mOnGainFirstResponder && isFirstResponder() && isMethod( "onGainFirstResponder" ) )
Con::executef(this, "onGainFirstResponder" );
}
void GuiRiverEditorCtrl::on3DMouseDown(const Gui3DMouseEvent & event)
{
_process3DMouseDown( event );
mGizmo->on3DMouseDown( event );
if ( !isFirstResponder() )
setFirstResponder();
}
void CATextField::ccTouchEnded(CATouch *pTouch, CAEvent *pEvent)
{
CCPoint point = this->convertTouchToNodeSpace(pTouch);
if (this->getBounds().containsPoint(point))
{
becomeFirstResponder();
if (isFirstResponder())
{
this->showCursorMark();
if (m_nInputType == KEY_BOARD_INPUT_PASSWORD)
{
if (!m_sText.empty())
{
m_iCurPos =(int)m_vTextFiledChars.size();
m_iString_l_length = m_cImageSize.width;
}
m_pCursorMark->setCenterOrigin(CCPoint(getCursorX() + m_iHoriMargins, m_obContentSize.height / 2));
return;
}
calculateSelChars(point, m_iString_l_length, m_iString_r_length, m_iCurPos);
m_pCursorMark->setCenterOrigin(CCPoint(getCursorX() + m_iHoriMargins, m_obContentSize.height / 2));
}
#if CC_TARGET_PLATFORM==CC_PLATFORM_ANDROID
CCEGLView * pGlView = CAApplication::getApplication()->getOpenGLView();
pGlView->setIMECursorPos(getCursorPos(), getContentText());
#endif
}
else
{
hideCursorMark();
if (resignFirstResponder())
{
this->updateImage();
}
}
m_curSelCharRange = std::make_pair(m_iCurPos, m_iCurPos);
execCurSelCharRange();
}
void CATextView::ccTouchEnded(CATouch *pTouch, CAEvent *pEvent)
{
CAScheduler::unschedule(schedule_selector(CATextView::ccTouchTimer), this);
if (CATextToolBarView::isTextToolBarShow() || m_pTextSelView->isTextViewShow())
return;
CCPoint point = this->convertTouchToNodeSpace(pTouch);
if (!isScrollWindowNotOutSide())
{
if (this->getBounds().containsPoint(point))
{
becomeFirstResponder();
if (isFirstResponder())
{
this->showCursorMark();
int iCurLine = 0; int iCurPosX = 0;
calculateSelChars(point, iCurLine, iCurPosX, m_iCurPos);
m_pCursorMark->setCenterOrigin(CCPoint(iCurPosX, m_iLineHeight*1.25f*iCurLine + m_iLineHeight / 2));
CCPoint pt = m_pCursorMark->getCenterOrigin();
m_pTextArrView->showTextArrView(CCPoint(pt.x, pt.y + m_iLineHeight*1.2f + getContentOffset().y));
}
}
else
{
m_pTextArrView->hideTextArrView();
m_pTextSelView->hideTextSelView();
if (resignFirstResponder())
{
this->hideCursorMark();
}
}
}
m_curSelCharRange = std::make_pair(m_iCurPos, m_iCurPos);
execCurSelCharRange();
CAScrollView::ccTouchEnded(pTouch, pEvent);
}
void CATextField::ccTouchEnded(CATouch *pTouch, CAEvent *pEvent)
{
CATouchView::ccTouchEnded(pTouch, pEvent);
if (CATextToolBarView::isTextToolBarShow())
return;
if (m_bMoved)
{
m_bMoved = false;
return;
}
CCPoint point = this->convertTouchToNodeSpace(pTouch);
if (this->getBounds().containsPoint(point))
{
if (!isFirstResponder())
{
becomeFirstResponder();
}
calculateSelChars(point, m_iString_l_length, m_iString_r_length, m_iCurPos);
adjustCursorMove();
#if CC_TARGET_PLATFORM==CC_PLATFORM_ANDROID
CCEGLView * pGlView = CAApplication::getApplication()->getOpenGLView();
pGlView->setIMECursorPos(getCursorPos(), getContentText());
#endif
}
else
{
resignFirstResponder();
}
m_curSelCharRange = std::make_pair(m_iCurPos, m_iCurPos);
execCurSelCharRange();
}
void GuiDecalEditorCtrl::on3DMouseDown(const Gui3DMouseEvent & event)
{
mPerformedDragCopy = false;
if ( !isFirstResponder() )
setFirstResponder();
bool dblClick = ( event.mouseClickCount > 1 );
// Gather selected decal information
RayInfo ri;
bool hit = getRayInfo( event, &ri );
Point3F start = event.pos;
Point3F end = start + event.vec * 3000.0f; // use visible distance here??
DecalInstance *pDecal = gDecalManager->raycast( start, end );
if( mMode.compare("AddDecalMode") != 0 )
{
if ( mSELDecal )
{
// If our click hit the gizmo we are done.
if ( mGizmo->getSelection() != Gizmo::None )
{
mGizmo->on3DMouseDown( event );
char returnBuffer[256];
dSprintf(returnBuffer, sizeof(returnBuffer), "%f %f %f %f %f %f %f",
mSELDecal->mPosition.x, mSELDecal->mPosition.y, mSELDecal->mPosition.z,
mSELDecal->mTangent.x, mSELDecal->mTangent.y, mSELDecal->mTangent.z,
mSELDecal->mSize);
Con::executef( this, "prepGizmoTransform", Con::getIntArg(mSELDecal->mId), returnBuffer );
return;
}
}
if ( mHLDecal && pDecal == mHLDecal )
{
mHLDecal = NULL;
selectDecal( pDecal );
if ( isMethod( "onSelectInstance" ) )
{
char idBuf[512];
dSprintf(idBuf, 512, "%i", pDecal->mId);
Con::executef( this, "onSelectInstance", String(idBuf).c_str(), pDecal->mDataBlock->lookupName.c_str() );
}
return;
}
else if ( hit && !pDecal)
{
if ( dblClick )
setMode( String("AddDecalMode"), true );
return;
}
}
else
{
// If we accidently hit a decal, then bail(probably an accident). If the use hits the decal twice,
// then boot them into selection mode and select the decal.
if ( mHLDecal && pDecal == mHLDecal )
{
if ( dblClick )
{
mHLDecal = NULL;
selectDecal( pDecal );
if ( isMethod( "onSelectInstance" ) )
{
char idBuf[512];
dSprintf(idBuf, 512, "%i", pDecal->mId);
Con::executef( this, "onSelectInstance", String(idBuf).c_str(), pDecal->mDataBlock->lookupName.c_str() );
}
setMode( String("SelectDecalMode"), true );
}
return;
}
if ( hit && mCurrentDecalData ) // Create a new decal...
{
U8 flags = PermanentDecal | SaveDecal;
DecalInstance *decalInst = gDecalManager->addDecal( ri.point, ri.normal, 0.0f, mCurrentDecalData, 1.0f, -1, flags );
if ( decalInst )
{
// Give the decal an id
decalInst->mId = gDecalManager->mDecalInstanceVec.size();
gDecalManager->mDecalInstanceVec.push_back(decalInst);
selectDecal( decalInst );
// Grab the mission editor undo manager.
UndoManager *undoMan = NULL;
if ( !Sim::findObject( "EUndoManager", undoMan ) )
{
Con::errorf( "GuiMeshRoadEditorCtrl::on3DMouseDown() - EUndoManager not found!" );
return;
}
// Create the UndoAction.
DICreateUndoAction *action = new DICreateUndoAction("Create Decal");
action->addDecal( *decalInst );
action->mEditor = this;
// Submit it.
undoMan->addAction( action );
if ( isMethod( "onCreateInstance" ) )
{
char buffer[512];
dSprintf(buffer, 512, "%i", decalInst->mId);
Con::executef( this, "onCreateInstance", buffer, decalInst->mDataBlock->lookupName.c_str());
}
}
return;
}
}
if ( !mSELDecal )
return;
}
void GuiRoadEditorCtrl::on3DMouseDown(const Gui3DMouseEvent & event)
{
if ( !isFirstResponder() )
setFirstResponder();
// Get the clicked terrain position.
Point3F tPos;
if ( !getTerrainPos( event, tPos ) )
return;
mouseLock();
// Find any road / node at the clicked position.
// TODO: handle overlapping roads/nodes somehow, cycle through them.
DecalRoad *roadPtr = NULL;
S32 closestNodeIdx = -1;
F32 closestDist = F32_MAX;
DecalRoad *closestNodeRoad = NULL;
// First, find the closest node in any road to the clicked position.
for ( SimSetIterator iter(mRoadSet); *iter; ++iter )
{
roadPtr = static_cast<DecalRoad*>( *iter );
U32 idx;
if ( roadPtr->getClosestNode( tPos, idx ) )
{
Point3F nodePos = roadPtr->getNodePosition(idx);
F32 dist = ( nodePos - tPos ).len();
if ( dist < closestDist )
{
closestNodeIdx = idx;
closestDist = dist;
closestNodeRoad = roadPtr;
}
}
}
//
// Second, determine if the screen-space node rectangle
// contains the clicked position.
bool nodeClicked = false;
S32 clickedNodeIdx = -1;
if ( closestNodeIdx != -1 )
{
Point3F nodePos = closestNodeRoad->getNodePosition( closestNodeIdx );
Point3F temp;
project( nodePos, &temp );
Point2I screenPos( temp.x, temp.y );
RectI nodeRect( screenPos - mNodeHalfSize, mNodeHalfSize * 2 );
nodeClicked = nodeRect.pointInRect( event.mousePoint );
if ( nodeClicked )
clickedNodeIdx = closestNodeIdx;
}
//
// Determine the clickedRoad
//
DecalRoad *clickedRoadPtr = NULL;
U32 insertNodeIdx = 0;
if ( nodeClicked && (mSelRoad == NULL || closestNodeRoad == mSelRoad) )
{
// If a node was clicked, the owning road is always
// considered the clicked road.
clickedRoadPtr = closestNodeRoad;
}
else
{
// check the selected road first
if ( mSelRoad != NULL && mSelRoad->containsPoint( tPos, &insertNodeIdx ) )
{
clickedRoadPtr = mSelRoad;
nodeClicked = false;
clickedNodeIdx = -1;
}
else
{
// Otherwise, we must ask each road if it contains
// the clicked pos.
for ( SimSetIterator iter(mRoadSet); *iter; ++iter )
{
roadPtr = static_cast<DecalRoad*>( *iter );
if ( roadPtr->containsPoint( tPos, &insertNodeIdx ) )
{
clickedRoadPtr = roadPtr;
break;
}
}
}
}
// shortcuts
bool dblClick = ( event.mouseClickCount > 1 );
if( dblClick )
{
if( mMode == mSelectRoadMode )
{
setMode( mAddRoadMode, true );
return;
}
if( mMode == mAddNodeMode )
{
// Delete the node attached to the cursor.
deleteSelectedNode();
mMode = mAddRoadMode;
return;
}
}
//this check is here in order to bounce back from deleting a whole road with ctrl+z
//this check places the editor back into addroadmode
if ( mMode == mAddNodeMode )
{
if ( !mSelRoad )
mMode = mAddRoadMode;
}
if ( mMode == mSelectRoadMode )
{
// Did not click on a road or a node.
if ( !clickedRoadPtr )
{
setSelectedRoad( NULL );
setSelectedNode( -1 );
return;
}
// Clicked on a road that wasn't the currently selected road.
if ( clickedRoadPtr != mSelRoad )
{
setSelectedRoad( clickedRoadPtr );
setSelectedNode( -1 );
return;
}
// Clicked on a node in the currently selected road that wasn't
// the currently selected node.
if ( nodeClicked )
{
setSelectedNode( clickedNodeIdx );
return;
}
// Clicked a position on the currently selected road
// that did not contain a node.
//U32 newNode = clickedRoadPtr->insertNode( tPos, mDefaultWidth, insertNodeIdx );
//setSelectedNode( newNode );
}
else if ( mMode == mAddRoadMode )
{
if ( nodeClicked && clickedRoadPtr )
{
// A double-click on a node in Normal mode means set AddNode mode.
if ( clickedNodeIdx == 0 )
{
setSelectedRoad( clickedRoadPtr );
setSelectedNode( clickedNodeIdx );
mAddNodeIdx = clickedNodeIdx;
mMode = mAddNodeMode;
mSelNode = mSelRoad->insertNode( tPos, mDefaultWidth, mAddNodeIdx );
mIsDirty = true;
return;
}
else if ( clickedNodeIdx == clickedRoadPtr->mNodes.size() - 1 )
{
setSelectedRoad( clickedRoadPtr );
setSelectedNode( clickedNodeIdx );
mAddNodeIdx = U32_MAX;
mMode = mAddNodeMode;
mSelNode = mSelRoad->addNode( tPos, mDefaultWidth );
mIsDirty = true;
setSelectedNode( mSelNode );
return;
}
}
DecalRoad *newRoad = new DecalRoad;
newRoad->mMaterialName = mMaterialName;
newRoad->registerObject();
// Add to MissionGroup
SimGroup *missionGroup;
if ( !Sim::findObject( "MissionGroup", missionGroup ) )
Con::errorf( "GuiDecalRoadEditorCtrl - could not find MissionGroup to add new DecalRoad" );
else
missionGroup->addObject( newRoad );
newRoad->insertNode( tPos, mDefaultWidth, 0 );
U32 newNode = newRoad->insertNode( tPos, mDefaultWidth, 1 );
// Always add to the end of the road, the first node is the start.
mAddNodeIdx = U32_MAX;
setSelectedRoad( newRoad );
setSelectedNode( newNode );
mMode = mAddNodeMode;
// Disable the hover node while in addNodeMode, we
// don't want some random node enlarged.
mHoverNode = -1;
// Grab the mission editor undo manager.
UndoManager *undoMan = NULL;
if ( !Sim::findObject( "EUndoManager", undoMan ) )
{
Con::errorf( "GuiRoadEditorCtrl::on3DMouseDown() - EUndoManager not found!" );
return;
}
// Create the UndoAction.
MECreateUndoAction *action = new MECreateUndoAction("Create Road");
action->addObject( newRoad );
// Submit it.
undoMan->addAction( action );
//send a callback to script after were done here if one exists
if ( isMethod( "onRoadCreation" ) )
Con::executef( this, "onRoadCreation" );
return;
}
else if ( mMode == mAddNodeMode )
{
// Oops the road got deleted, maybe from an undo action?
// Back to NormalMode.
if ( mSelRoad )
{
// A double-click on a node in Normal mode means set AddNode mode.
if ( clickedNodeIdx == 0 )
{
submitUndo( "Add Node" );
mAddNodeIdx = clickedNodeIdx;
mMode = mAddNodeMode;
mSelNode = mSelRoad->insertNode( tPos, mDefaultWidth, mAddNodeIdx );
mIsDirty = true;
setSelectedNode( mSelNode );
return;
}
else
{
if( clickedRoadPtr && clickedNodeIdx == clickedRoadPtr->mNodes.size() - 1 )
{
submitUndo( "Add Node" );
mAddNodeIdx = U32_MAX;
mMode = mAddNodeMode;
mSelNode = mSelRoad->addNode( tPos, mDefaultWidth );
mIsDirty = true;
setSelectedNode( mSelNode );
return;
}
else
{
submitUndo( "Insert Node" );
// A single-click on empty space while in
// AddNode mode means insert / add a node.
//submitUndo( "Add Node" );
//F32 width = mSelRoad->getNodeWidth( mSelNode );
U32 newNode = mSelRoad->insertNode( tPos, mDefaultWidth, mAddNodeIdx);
mIsDirty = true;
setSelectedNode( newNode );
return;
}
}
}
}
else if ( mMode == mInsertPointMode && mSelRoad != NULL)
{
if ( clickedRoadPtr == mSelRoad )
{
F32 w0 = mSelRoad->getNodeWidth( insertNodeIdx );
F32 w1 = mSelRoad->getNodeWidth( insertNodeIdx + 1 );
F32 width = ( w0 + w1 ) * 0.5f;
submitUndo( "Insert Node" );
U32 newNode = mSelRoad->insertNode( tPos, width, insertNodeIdx + 1);
mIsDirty = true;
setSelectedNode( newNode );
return;
}
}
else if ( mMode == mRemovePointMode && mSelRoad != NULL)
{
if ( nodeClicked && clickedRoadPtr == mSelRoad )
{
setSelectedNode( clickedNodeIdx );
deleteSelectedNode();
return;
}
}
else if ( mMode == mMovePointMode )
{
if ( nodeClicked && clickedRoadPtr == mSelRoad )
{
setSelectedNode( clickedNodeIdx );
return;
}
}
else if ( mMode == mScalePointMode )
{
if ( nodeClicked && clickedRoadPtr == mSelRoad )
{
setSelectedNode( clickedNodeIdx );
return;
}
}
}
void GuiRiverEditorCtrl::on3DMouseDown(const Gui3DMouseEvent & event)
{
mGizmo->on3DMouseDown( event );
if ( !isFirstResponder() )
setFirstResponder();
// Get the raycast collision position
Point3F tPos;
if ( !getStaticPos( event, tPos ) )
return;
// Construct a LineSegment from the camera position to 1000 meters away in
// the direction clicked.
// If that segment hits the terrain, truncate the ray to only be that length.
// We will use a LineSegment/Sphere intersection test to determine if a RiverNode
// was clicked.
Point3F startPnt = event.pos;
Point3F endPnt = event.pos + event.vec * 1000.0f;
RayInfo ri;
if ( gServerContainer.castRay(startPnt, endPnt, StaticObjectType, &ri) )
endPnt = ri.point;
River *riverPtr = NULL;
River *clickedRiverPtr = NULL;
// Did we click on a river? check current selection first
U32 insertNodeIdx = -1;
Point3F collisionPnt;
if ( mSelRiver != NULL && mSelRiver->collideRay( event.pos, event.vec, &insertNodeIdx, &collisionPnt ) )
{
clickedRiverPtr = mSelRiver;
}
else
{
for ( SimSetIterator iter(mRiverSet); *iter; ++iter )
{
riverPtr = static_cast<River*>( *iter );
if ( riverPtr->collideRay( event.pos, event.vec, &insertNodeIdx, &collisionPnt ) )
{
clickedRiverPtr = riverPtr;
break;
}
}
}
// Did we click on a riverNode?
bool nodeClicked = false;
S32 clickedNodeIdx = -1;
F32 clickedNodeDist = mNodeSphereRadius;
// If we clicked on the currently selected river, only scan its nodes
if ( mSelRiver != NULL && clickedRiverPtr == mSelRiver )
{
for ( U32 i = 0; i < mSelRiver->mNodes.size(); i++ )
{
const Point3F &nodePos = mSelRiver->mNodes[i].point;
Point3F screenPos;
project( nodePos, &screenPos );
F32 dist = ( event.mousePoint - Point2I(screenPos.x, screenPos.y) ).len();
if ( dist < clickedNodeDist )
{
clickedNodeDist = dist;
clickedNodeIdx = i;
nodeClicked = true;
}
}
}
else
{
for ( SimSetIterator iter(mRiverSet); *iter; ++iter )
{
riverPtr = static_cast<River*>( *iter );
for ( U32 i = 0; i < riverPtr->mNodes.size(); i++ )
{
const Point3F &nodePos = riverPtr->mNodes[i].point;
Point3F screenPos;
project( nodePos, &screenPos );
F32 dist = ( event.mousePoint - Point2I(screenPos.x, screenPos.y) ).len();
if ( dist < clickedNodeDist )
{
// we found a hit!
clickedNodeDist = dist;
clickedNodeIdx = i;
nodeClicked = true;
clickedRiverPtr = riverPtr;
}
}
}
}
// shortcuts
bool dblClick = ( event.mouseClickCount > 1 );
if( dblClick )
{
if( mMode == mSelectRiverMode )
{
setMode( mAddRiverMode, true );
return;
}
if( mMode == mAddNodeMode )
{
// Delete the node attached to the cursor.
deleteSelectedNode();
mMode = mAddRiverMode;
return;
}
}
//this check is here in order to bounce back from deleting a whole road with ctrl+z
//this check places the editor back into addrivermode
if ( mMode == mAddNodeMode )
{
if ( !mSelRiver )
mMode = mAddRiverMode;
}
if ( mMode == mSelectRiverMode )
{
// Did not click on a River or a node.
if ( !clickedRiverPtr )
{
setSelectedRiver( NULL );
setSelectedNode( -1 );
return;
}
// Clicked on a River that wasn't the currently selected River.
if ( clickedRiverPtr != mSelRiver )
{
setSelectedRiver( clickedRiverPtr );
setSelectedNode( clickedNodeIdx );
return;
}
// Clicked on a node in the currently selected River that wasn't
// the currently selected node.
if ( nodeClicked )
{
setSelectedNode( clickedNodeIdx );
return;
}
}
else if ( mMode == mAddRiverMode )
{
if ( nodeClicked )
{
// A double-click on a node in Normal mode means set AddNode mode.
if ( clickedNodeIdx == 0 )
{
setSelectedRiver( clickedRiverPtr );
setSelectedNode( clickedNodeIdx );
mAddNodeIdx = clickedNodeIdx;
mMode = mAddNodeMode;
mSelNode = mSelRiver->insertNode( tPos, mDefaultWidth, mDefaultDepth, mDefaultNormal, mAddNodeIdx );
mIsDirty = true;
return;
}
else if ( clickedNodeIdx == clickedRiverPtr->mNodes.size() - 1 )
{
setSelectedRiver( clickedRiverPtr );
setSelectedNode( clickedNodeIdx );
mAddNodeIdx = U32_MAX;
mMode = mAddNodeMode;
mSelNode = mSelRiver->addNode( tPos, mDefaultWidth, mDefaultDepth, mDefaultNormal);
mIsDirty = true;
setSelectedNode( mSelNode );
return;
}
}
if ( !isMethod( "createRiver" ) )
{
Con::errorf( "GuiRiverEditorCtrl::on3DMouseDown - createRiver method does not exist." );
return;
}
const char *res = Con::executef( this, "createRiver" );
River *newRiver;
if ( !Sim::findObject( res, newRiver ) )
{
Con::errorf( "GuiRiverEditorCtrl::on3DMouseDown - createRiver method did not return a river object." );
return;
}
// Add to MissionGroup
SimGroup *missionGroup;
if ( !Sim::findObject( "MissionGroup", missionGroup ) )
Con::errorf( "GuiRiverEditorCtrl - could not find MissionGroup to add new River" );
else
missionGroup->addObject( newRiver );
Point3F pos( endPnt );
pos.z += mDefaultDepth * 0.5f;
newRiver->insertNode( pos, mDefaultWidth, mDefaultDepth, mDefaultNormal, 0 );
U32 newNode = newRiver->insertNode( pos, mDefaultWidth, mDefaultDepth, mDefaultNormal, 1 );
// Always add to the end of the road, the first node is the start.
mAddNodeIdx = U32_MAX;
setSelectedRiver( newRiver );
setSelectedNode( newNode );
mMode = mAddNodeMode;
// Disable the hover node while in addNodeMode, we
// don't want some random node enlarged.
mHoverNode = -1;
// Grab the mission editor undo manager.
UndoManager *undoMan = NULL;
if ( !Sim::findObject( "EUndoManager", undoMan ) )
{
Con::errorf( "GuiMeshRoadEditorCtrl::on3DMouseDown() - EUndoManager not found!" );
return;
}
// Create the UndoAction.
MECreateUndoAction *action = new MECreateUndoAction("Create MeshRoad");
action->addObject( newRiver );
// Submit it.
undoMan->addAction( action );
return;
}
else if ( mMode == mAddNodeMode )
{
// Oops the road got deleted, maybe from an undo action?
// Back to NormalMode.
if ( mSelRiver )
{
// A double-click on a node in Normal mode means set AddNode mode.
if ( clickedNodeIdx == 0 )
{
submitUndo( "Add Node" );
mAddNodeIdx = clickedNodeIdx;
mMode = mAddNodeMode;
mSelNode = mSelRiver->insertNode( tPos, mDefaultWidth, mDefaultDepth, mDefaultNormal, mAddNodeIdx );
mIsDirty = true;
setSelectedNode( mSelNode );
return;
}
else
{
if( clickedRiverPtr && clickedNodeIdx == clickedRiverPtr->mNodes.size() - 1 )
{
submitUndo( "Add Node" );
mAddNodeIdx = U32_MAX;
mMode = mAddNodeMode;
U32 newNode = mSelRiver->addNode( tPos, mDefaultWidth, mDefaultDepth, mDefaultNormal);
mIsDirty = true;
setSelectedNode( newNode );
return;
}
else
{
submitUndo( "Insert Node" );
// A single-click on empty space while in
// AddNode mode means insert / add a node.
//submitUndo( "Add Node" );
//F32 width = mSelRiver->getNodeWidth( mSelNode );
U32 newNode = mSelRiver->insertNode( tPos, mDefaultWidth, mDefaultDepth, mDefaultNormal, mAddNodeIdx);
mIsDirty = true;
setSelectedNode( newNode );
return;
}
}
}
}
else if ( mMode == mInsertPointMode && mSelRiver != NULL )
{
if ( clickedRiverPtr == mSelRiver )
{
// NOTE: I guess we have to determine the if the clicked ray intersects a road but not a specific node...
// in order to handle inserting nodes in the same way as for DecalRoad
U32 prevNodeIdx = insertNodeIdx;
U32 nextNodeIdx = ( prevNodeIdx + 1 > mSelRiver->mNodes.size() - 1 ) ? prevNodeIdx : prevNodeIdx + 1;
const RiverNode &prevNode = mSelRiver->mNodes[prevNodeIdx];
const RiverNode &nextNode = mSelRiver->mNodes[nextNodeIdx];
F32 width = ( prevNode.width + nextNode.width ) * 0.5f;
F32 depth = ( prevNode.depth + nextNode.depth ) * 0.5f;
Point3F normal = ( prevNode.normal + nextNode.normal ) * 0.5f;
normal.normalize();
submitUndo( "Insert Node" );
U32 newNode = mSelRiver->insertNode( collisionPnt, width, depth, normal, insertNodeIdx + 1 );
mIsDirty = true;
setSelectedNode( newNode );
return;
}
}
else if ( mMode == mRemovePointMode && mSelRiver != NULL )
{
if ( nodeClicked && clickedRiverPtr == mSelRiver )
{
setSelectedNode( clickedNodeIdx );
deleteSelectedNode();
return;
}
}
else if ( mMode == mMovePointMode )
{
if ( nodeClicked && clickedRiverPtr == mSelRiver )
{
setSelectedNode( clickedNodeIdx );
return;
}
}
else if ( mMode == mScalePointMode )
{
if ( nodeClicked && clickedRiverPtr == mSelRiver )
{
setSelectedNode( clickedNodeIdx );
return;
}
}
else if ( mMode == mRotatePointMode )
{
if ( nodeClicked && clickedRiverPtr == mSelRiver )
{
setSelectedNode( clickedNodeIdx );
return;
}
}
}
bool CATextView::ccTouchBegan(CATouch *pTouch, CAEvent *pEvent)
{
if (m_pTouches->count() > 0)
{
m_pTouches->replaceObjectAtIndex(0, pTouch);
return true;
}
bool isInertia = m_tInertia.getLength() < 1.0f;
if (!CAScrollView::ccTouchBegan(pTouch, pEvent))
return false;
CCPoint point = this->convertTouchToNodeSpace(pTouch);
if (this->getBounds().containsPoint(point))
{
becomeFirstResponder();
if (isFirstResponder())
{
m_pCursorMark->setVisible(true);
point.y += getContentOffset().y;
int iCurLine = point.y / m_iLineHeight;
if (m_vLinesTextView.empty())
{
iCurLine = 0;
}
else if (iCurLine >= m_vLinesTextView.size())
{
iCurLine = m_vLinesTextView.size() - 1;
}
int iHalfCharSize = 0;
int iStartPos = 0;
if (!m_vLinesTextView.empty())
{
m_iCurPos = iStartPos = m_vLinesTextView[iCurLine].iStartCharPos;
std::vector<TextAttribute>& v = m_vLinesTextView[iCurLine].TextAttrVect;
for (int i = 0, iStringLeftX = 0; i < v.size(); i++)
{
TextAttribute& t = v[i];
if (point.x >= iStringLeftX - iHalfCharSize && point.x < iStringLeftX + t.charlength / 2)
{
break;
}
iStringLeftX += t.charlength;
m_iCurPos += t.charSize;
iHalfCharSize = t.charlength / 2;
}
}
std::string s = m_szText.substr(iStartPos, m_iCurPos - iStartPos);
if (!s.empty() && s[0] == '\n')
{
s.erase(0, 1);
}
m_pCursorMark->setCenterOrigin(CCPoint(getStringLength(s), (iCurLine * 2 + 1) * (m_iLineHeight / 2)));
}
return true;
}
else
{
if (resignFirstResponder())
{
m_pCursorMark->setVisible(false);
return false;
}
return false;
}
return true;
}
bool CATextField::ccTouchBegan(CATouch *pTouch, CAEvent *pEvent)
{
if (isEditing)
{
return false;
}
CCPoint point = this->convertTouchToNodeSpace(pTouch);
if (this->getBounds().containsPoint(point))
{
becomeFirstResponder();
if (isFirstResponder())
{
m_pMark->setVisible(true);
attachWithIME();
if (m_nInputType ==KEY_BOARD_INPUT_PASSWORD)
{
m_pMark->setCenterOrigin(CCPoint(labelOrginX+m_rLabelRect.size.width, this->getBounds().size.height/2));
return true;
}
m_fString_left_length = 0;
int byteCount = 0;
for (std::vector<TextAttribute>::iterator itr = m_vByteLengthArr.begin(); itr!=m_vByteLengthArr.end(); itr++)
{
TextAttribute t =*(itr);
m_fString_left_length+=t.charlength;
byteCount += t.charsize;
if (m_fString_left_length>point.x-m_fString_left_offX)
{
m_sLeft_string = m_sText.substr(0,byteCount);
m_sRight_string = m_sText.substr(byteCount,m_sText.length());
m_fString_right_length = m_rLabelRect.size.width-m_fString_left_length;
break;
} else if(itr == m_vByteLengthArr.end()-1&&!spaceHolderIsOn)
{
m_sLeft_string = m_sText.substr(0,byteCount);
m_sRight_string = m_sText.substr(byteCount,m_sText.length());
m_fString_right_length = m_rLabelRect.size.width-m_fString_left_length;
}
}
m_pMark->setCenterOrigin(CCPoint(getCursorX()+labelOrginX, this->getBounds().size.height/2));
}
return true;
}
else
{
if (resignFirstResponder())
{
if (!strcmp(m_sText.c_str(), ""))
{
m_sText="";
spaceHolderIsOn=true;
this->updateImage();
}
m_pMark->setVisible(false);
return false;
}
return false;
}
return true;
}
