ColorPickerItem::ColorPickerItem(QObject* parent)
: QObject(parent)
{
connect(this, SIGNAL(pickColor()), &m_selector, SLOT(startSelection()));
connect(&m_selector, SIGNAL(colorPicked(QColor)), SIGNAL(colorPicked(QColor)));
connect(&m_selector, SIGNAL(cancelled()), SIGNAL(cancelled()));
}
bool ServerLobbyRoomProtocol::notifyEventAsynchronous(Event* event)
{
assert(m_setup); // assert that the setup exists
if (event->getType() == EVENT_TYPE_MESSAGE)
{
NetworkString &data = event->data();
assert(data.size()); // message not empty
uint8_t message_type;
message_type = data.getUInt8();
Log::info("ServerLobbyRoomProtocol", "Message received with type %d.",
message_type);
switch(message_type)
{
case LE_CONNECTION_REQUESTED: connectionRequested(event); break;
case LE_REQUEST_BEGIN: startSelection(event); break;
case LE_KART_SELECTION: kartSelectionRequested(event); break;
case LE_VOTE_MAJOR: playerMajorVote(event); break;
case LE_VOTE_RACE_COUNT: playerRaceCountVote(event); break;
case LE_VOTE_MINOR: playerMinorVote(event); break;
case LE_VOTE_TRACK: playerTrackVote(event); break;
case LE_VOTE_REVERSE: playerReversedVote(event); break;
case LE_VOTE_LAPS: playerLapsVote(event); break;
case LE_RACE_FINISHED_ACK: playerFinishedResult(event); break;
} // switch
} // if (event->getType() == EVENT_TYPE_MESSAGE)
else if (event->getType() == EVENT_TYPE_DISCONNECTED)
{
clientDisconnected(event);
} // if (event->getType() == EVENT_TYPE_DISCONNECTED)
return true;
} // notifyEventAsynchronous
bool ClientLobbyRoomProtocol::notifyEventAsynchronous(Event* event)
{
assert(m_setup); // assert that the setup exists
if (event->getType() == EVENT_TYPE_MESSAGE)
{
const NetworkString &data = event->data();
assert(data.size()); // assert that data isn't empty
uint8_t message_type = data[0];
if (message_type == 0x03 ||
message_type == 0x06)
return false; // don't treat the event
event->removeFront(1);
Log::info("ClientLobbyRoomProtocol", "Asynchronous message of type %d", message_type);
if (message_type == 0x01) // new player connected
newPlayer(event);
else if (message_type == 0x02) // player disconnected
disconnectedPlayer(event);
else if (message_type == 0x04) // start race
startGame(event);
else if (message_type == 0x05) // start selection phase
startSelection(event);
else if (message_type == 0x80) // connection refused
connectionRefused(event);
else if (message_type == 0x81) // connection accepted
connectionAccepted(event);
else if (message_type == 0x82) // kart selection refused
kartSelectionRefused(event);
else if (message_type == 0xc0) // vote for major mode
playerMajorVote(event);
else if (message_type == 0xc1) // vote for race count
playerRaceCountVote(event);
else if (message_type == 0xc2) // vote for minor mode
playerMinorVote(event);
else if (message_type == 0xc3) // vote for track
playerTrackVote(event);
else if (message_type == 0xc4) // vote for reversed mode
playerReversedVote(event);
else if (message_type == 0xc5) // vote for laps
playerLapsVote(event);
return true;
} // message
else if (event->getType() == EVENT_TYPE_CONNECTED)
{
return true;
} // connection
else if (event->getType() == EVENT_TYPE_DISCONNECTED) // means we left essentially
{
NetworkManager::getInstance()->removePeer(m_server);
m_server = NULL;
NetworkManager::getInstance()->disconnected();
m_listener->requestTerminate(this);
NetworkManager::getInstance()->reset();
// probably the same as m_server
NetworkManager::getInstance()->removePeer(event->getPeer());
return true;
} // disconnection
return false;
} // notifyEventAsynchronous
int RectSelection::selection_stop(int _x, int _y)
{
stop_x_ = _x;
stop_y_ = _y;
rect_->setStartPoint(0,0);
getScenegraph()->removeDecorationByName(rect_->getName());
startSelection();
return GCL_TRUE;
}
bool ClientLobbyRoomProtocol::notifyEventAsynchronous(Event* event)
{
assert(m_setup); // assert that the setup exists
if (event->getType() == EVENT_TYPE_MESSAGE)
{
NetworkString &data = event->data();
assert(data.size()); // assert that data isn't empty
uint8_t message_type = data.getUInt8();
Log::info("ClientLobbyRoomProtocol", "Asynchronous message of type %d",
message_type);
switch(message_type)
{
case LE_NEW_PLAYER_CONNECTED: newPlayer(event); break;
case LE_PLAYER_DISCONNECTED : disconnectedPlayer(event); break;
case LE_START_RACE: startGame(event); break;
case LE_START_SELECTION: startSelection(event); break;
case LE_CONNECTION_REFUSED: connectionRefused(event); break;
case LE_CONNECTION_ACCEPTED: connectionAccepted(event); break;
case LE_KART_SELECTION_REFUSED: kartSelectionRefused(event); break;
case LE_VOTE_MAJOR : playerMajorVote(event); break;
case LE_VOTE_RACE_COUNT: playerRaceCountVote(event); break;
case LE_VOTE_MINOR: playerMinorVote(event); break;
case LE_VOTE_TRACK: playerTrackVote(event); break;
case LE_VOTE_REVERSE: playerReversedVote(event); break;
case LE_VOTE_LAPS: playerLapsVote(event); break;
} // switch
return true;
} // message
else if (event->getType() == EVENT_TYPE_DISCONNECTED)
{
// This means we left essentially.
// We can't delete STKHost from this thread, since the main
// thread might still test if STKHost exists and then call
// the ProtocolManager, which might already have been deleted.
// So only signal that STKHost should exit, which will be tested
// from the main thread.
STKHost::get()->requestShutdown();
return true;
} // disconnection
return false;
} // notifyEventAsynchronous
void Console::update()
{
if(!enabled) return;
//std::cout << "MOUSE x: " << Input::mouseX*(TF::width/1024.0f) << " MOUSE y: " << Input::mouseY*(TF::height/768.0f) << "\n";
//std::cout << "SCALE MOUSE x: " << Input::mouseScaleX << " SCALE MOUSE y: " << Input::mouseScaleY << "\n";
// if console is in pause state
if(paused)
{
// if the engine has been paused
if(TF::paused)
{
if(Input::leftMousePressed)
{
if(Input::down(TOAST_KEY_LSHIFT) || Input::down(TOAST_KEY_RSHIFT))
{
// TODO: implement entities drag
startDragEntities();
}
else
{
startSelection();
}
}
else
{
if(selecting) updateSelection();
if(dragging) moveEntities();
}
}
}
if(Input::pressed(toggleKey))
{
paused = !paused;
managePause();
}
}
BOOL LLViewerTextEditor::handleMouseDown(S32 x, S32 y, MASK mask)
{
BOOL handled = FALSE;
// Let scrollbar have first dibs
handled = LLView::childrenHandleMouseDown(x, y, mask) != NULL;
// enable I Agree checkbox if the user scrolled through entire text
BOOL was_scrolled_to_bottom = (mScrollbar->getDocPos() == mScrollbar->getDocPosMax());
if (mOnScrollEndCallback && was_scrolled_to_bottom)
{
mOnScrollEndCallback(mOnScrollEndData);
}
if( !handled && mTakesNonScrollClicks)
{
if (!(mask & MASK_SHIFT))
{
deselect();
}
BOOL start_select = TRUE;
if( allowsEmbeddedItems() )
{
setCursorAtLocalPos( x, y, FALSE );
llwchar wc = 0;
if (mCursorPos < getLength())
{
wc = getWChar(mCursorPos);
}
LLInventoryItem* item_at_pos = LLEmbeddedItems::getEmbeddedItem(wc);
if (item_at_pos)
{
mDragItem = item_at_pos;
mDragItemChar = wc;
mDragItemSaved = LLEmbeddedItems::getEmbeddedItemSaved(wc);
gFocusMgr.setMouseCapture( this );
mMouseDownX = x;
mMouseDownY = y;
S32 screen_x;
S32 screen_y;
localPointToScreen(x, y, &screen_x, &screen_y );
LLToolDragAndDrop::getInstance()->setDragStart( screen_x, screen_y );
start_select = FALSE;
}
else
{
mDragItem = NULL;
}
}
if( start_select )
{
// If we're not scrolling (handled by child), then we're selecting
if (mask & MASK_SHIFT)
{
S32 old_cursor_pos = mCursorPos;
setCursorAtLocalPos( x, y, TRUE );
if (hasSelection())
{
/* Mac-like behavior - extend selection towards the cursor
if (mCursorPos < mSelectionStart
&& mCursorPos < mSelectionEnd)
{
// ...left of selection
mSelectionStart = llmax(mSelectionStart, mSelectionEnd);
mSelectionEnd = mCursorPos;
}
else if (mCursorPos > mSelectionStart
&& mCursorPos > mSelectionEnd)
{
// ...right of selection
mSelectionStart = llmin(mSelectionStart, mSelectionEnd);
mSelectionEnd = mCursorPos;
}
else
{
mSelectionEnd = mCursorPos;
}
*/
// Windows behavior
mSelectionEnd = mCursorPos;
}
else
{
mSelectionStart = old_cursor_pos;
mSelectionEnd = mCursorPos;
}
// assume we're starting a drag select
mIsSelecting = TRUE;
}
else
{
setCursorAtLocalPos( x, y, TRUE );
startSelection();
}
gFocusMgr.setMouseCapture( this );
}
handled = TRUE;
}
if (hasTabStop())
{
setFocus(TRUE);
handled = TRUE;
}
// Delay cursor flashing
resetKeystrokeTimer();
return handled;
}
BOOL LLViewerTextEditor::handleDoubleClick(S32 x, S32 y, MASK mask)
{
BOOL handled = FALSE;
// let scrollbar have first dibs
handled = LLView::childrenHandleDoubleClick(x, y, mask) != NULL;
if( !handled && mTakesNonScrollClicks)
{
if( allowsEmbeddedItems() )
{
const LLTextSegment* cur_segment = getSegmentAtLocalPos( x, y );
if( cur_segment && cur_segment->getStyle()->getIsEmbeddedItem() )
{
if( openEmbeddedItemAtPos( cur_segment->getStart() ) )
{
deselect();
setFocus( FALSE );
return TRUE;
}
}
}
setCursorAtLocalPos( x, y, FALSE );
deselect();
const LLWString &text = getWText();
if( isPartOfWord( text[mCursorPos] ) )
{
// Select word the cursor is over
while ((mCursorPos > 0) && isPartOfWord(text[mCursorPos-1]))
{
mCursorPos--;
}
startSelection();
while ((mCursorPos < (S32)text.length()) && isPartOfWord( text[mCursorPos] ) )
{
mCursorPos++;
}
mSelectionEnd = mCursorPos;
}
else if ((mCursorPos < (S32)text.length()) && !iswspace( text[mCursorPos]) )
{
// Select the character the cursor is over
startSelection();
mCursorPos++;
mSelectionEnd = mCursorPos;
}
// We don't want handleMouseUp() to "finish" the selection (and thereby
// set mSelectionEnd to where the mouse is), so we finish the selection here.
mIsSelecting = FALSE;
// delay cursor flashing
resetKeystrokeTimer();
// take selection to 'primary' clipboard
updatePrimary();
handled = TRUE;
}
return handled;
}
void GraphWidget::startCtrlPtSelection(const int iMouseX, const int iMouseY)
{
startSelection(iMouseX, iMouseY);
m_bHasCtrlPtSelection = true;
}
void AbstractSelection::mousePressEvent(QMouseEvent *event, ImageArea &imageArea)
{
mButton = event->button();
mIsMouseMoved = false;
if (mIsSelectionExists)
{
imageArea.setImage(mImageCopy);
paint(imageArea);
if (mButton == Qt::RightButton)
{
mIsSelectionAdjusting = true;
startAdjusting(imageArea);
}
if (event->pos().x() > mTopLeftPoint.x() &&
event->pos().x() < mBottomRightPoint.x() &&
event->pos().y() > mTopLeftPoint.y() &&
event->pos().y() < mBottomRightPoint.y())
{
if (!mIsSelectionAdjusting)
{
makeUndoCommand(imageArea);
}
if (!mIsImageSelected)
{
startMoving(imageArea);
if (!mIsSelectionAdjusting)
{
mIsImageSelected = true;
}
}
else
{
drawBorder(imageArea);
}
mIsSelectionMoving = true;
mMoveDiffPoint = mBottomRightPoint - event->pos();
return;
}
else if (event->pos().x() >= mBottomRightPoint.x() &&
event->pos().x() <= mBottomRightPoint.x() + 6 &&
event->pos().y() >= mBottomRightPoint.y() &&
event->pos().y() <= mBottomRightPoint.y() + 6)
{
if (!mIsSelectionAdjusting)
{
makeUndoCommand(imageArea);
}
startResizing(imageArea);
mIsSelectionResizing = true;
return;
}
else
{
clearSelection(imageArea);
}
}
if (event->button() == Qt::LeftButton)
{
mBottomRightPoint = mTopLeftPoint = event->pos();
mHeight = mWidth = 0;
mImageCopy = *imageArea.getImage();
startSelection(imageArea);
mIsPaint = true;
}
}
