// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
bool
ScrollBarSlider::moved(MouseMessage& message)
{
if(_oldMousePos.x() >= 0.0f)
{
if(state() == Button::down)
{
int value = _scrollBar.value();
switch(_scrollBar.justification())
{
case ScrollBar::horizontal:
{
const float delta = message.x() - _oldMousePos.x();
if(delta != 0) moveHorizontally(delta);
}
break;
case ScrollBar::vertical:
{
const float delta = message.y() - _oldMousePos.y();
if(delta != 0) moveVertically(delta);
}
break;
}
if(value != _scrollBar.value()) _scrollBar.sliderMoved(_scrollBar.value());
}
}
_oldMousePos.setX(message.x());
_oldMousePos.setY(message.y());
return true;
}
bool ColorWheel::onProcessMessage(ui::Message* msg)
{
switch (msg->type()) {
case kMouseDownMessage:
captureMouse();
// Continue...
case kMouseMoveMessage: {
MouseMessage* mouseMsg = static_cast<MouseMessage*>(msg);
app::Color color = pickColor(
mouseMsg->position()
- getBounds().getOrigin());
if (color != app::Color::fromMask()) {
base::ScopedValue<bool> switcher(m_lockColor, m_harmonyPicked, false);
StatusBar::instance()->showColor(0, "", color);
if (hasCapture())
ColorChange(color, mouseMsg->buttons());
}
break;
}
case kMouseUpMessage:
if (hasCapture()) {
releaseMouse();
}
return true;
case kSetCursorMessage: {
MouseMessage* mouseMsg = static_cast<MouseMessage*>(msg);
app::Color color = pickColor(
mouseMsg->position()
- getBounds().getOrigin());
if (color.getType() != app::Color::MaskType) {
ui::set_mouse_cursor(kEyedropperCursor);
return true;
}
break;
}
}
return Widget::onProcessMessage(msg);
}
void ClickableControl::MouseDown(const Point& position, const MouseMessage& message) {
if (message.GetMouseButton() == MouseButton::Left) {
SetIsFocused(true);
BeginPress(PressType::Mouse);
CheckIsMousePressed(position, message.wParam);
}
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
bool
FrameWindowMouseListener::moved(MouseMessage& message)
{
bool isHandled = false;
if(frameWindow_.isMovable())
{
if(WindowManager::instance().captureWindow() == &frameWindow_)
{
Core::Vector2 delta(message.x() - _oldMousePos.x(), message.y() - _oldMousePos.y());
frameWindow_.setPosition(frameWindow_.position() + delta);
}
_oldMousePos.setX(message.x());
_oldMousePos.setY(message.y());
isHandled = true;
}
return isHandled;
}
bool ColorSpectrum::onProcessMessage(ui::Message* msg)
{
switch (msg->type()) {
case kMouseDownMessage:
captureMouse();
// Continue...
case kMouseMoveMessage: {
MouseMessage* mouseMsg = static_cast<MouseMessage*>(msg);
app::Color color = pickColor(mouseMsg->position());
if (color != app::Color::fromMask()) {
StatusBar::instance()->showColor(0, "", color);
if (hasCapture())
ColorChange(color, mouseMsg->buttons());
}
break;
}
case kMouseUpMessage:
if (hasCapture()) {
releaseMouse();
}
return true;
case kSetCursorMessage: {
MouseMessage* mouseMsg = static_cast<MouseMessage*>(msg);
if (childrenBounds().contains(mouseMsg->position())) {
ui::set_mouse_cursor(kEyedropperCursor);
return true;
}
break;
}
}
return Widget::onProcessMessage(msg);
}
bool onProcessMessage(Message* msg) override {
switch (msg->type()) {
case kSetCursorMessage:
ui::set_mouse_cursor(kArrowCursor);
return true;
case kMouseUpMessage: {
MouseMessage* mouseMsg = static_cast<MouseMessage*>(msg);
if (mouseMsg->right()) {
if (hasCapture()) {
releaseMouse();
Popup();
setSelected(false);
return true;
}
}
break;
}
}
return SkinButton<Button>::onProcessMessage(msg);
}
bool ColorTintShadeTone::onProcessMessage(ui::Message* msg)
{
switch (msg->type()) {
case kMouseDownMessage:
if (manager()->getCapture())
break;
captureMouse();
// Continue...
case kMouseMoveMessage: {
MouseMessage* mouseMsg = static_cast<MouseMessage*>(msg);
if (msg->type() == kMouseDownMessage)
m_capturedInHue = inHueBarArea(mouseMsg->position());
app::Color color = getColorByPosition(mouseMsg->position());
if (color != app::Color::fromMask()) {
StatusBar::instance()->showColor(0, "", color);
if (hasCapture())
ColorChange(color, mouseMsg->buttons());
}
break;
}
case kMouseUpMessage:
if (hasCapture()) {
releaseMouse();
}
return true;
case kSetCursorMessage: {
MouseMessage* mouseMsg = static_cast<MouseMessage*>(msg);
if (childrenBounds().contains(mouseMsg->position())) {
ui::set_mouse_cursor(kEyedropperCursor);
return true;
}
break;
}
}
return ColorSelector::onProcessMessage(msg);
}
bool StateWithWheelBehavior::onMouseWheel(Editor* editor, MouseMessage* msg)
{
int dz = msg->wheelDelta().x + msg->wheelDelta().y;
WHEEL_ACTION wheelAction = WHEEL_NONE;
bool scrollBigSteps = false;
// Alt+mouse wheel changes the fg/bg colors
if (msg->altPressed()) {
if (msg->shiftPressed())
wheelAction = WHEEL_BG;
else
wheelAction = WHEEL_FG;
}
// Normal behavior: mouse wheel zooms
else if (Preferences::instance().editor.zoomWithWheel()) {
if (msg->ctrlPressed())
wheelAction = WHEEL_FRAME;
else if (msg->wheelDelta().x != 0 || msg->shiftPressed())
wheelAction = WHEEL_HSCROLL;
else
wheelAction = WHEEL_ZOOM;
}
// For laptops, it's convenient to that Ctrl+wheel zoom (because
// it's the "pinch" gesture).
else {
if (msg->ctrlPressed())
wheelAction = WHEEL_ZOOM;
else if (msg->wheelDelta().x != 0 || msg->shiftPressed())
wheelAction = WHEEL_HSCROLL;
else
wheelAction = WHEEL_VSCROLL;
}
switch (wheelAction) {
case WHEEL_NONE:
// Do nothing
break;
case WHEEL_FG:
{
int newIndex = 0;
if (ColorBar::instance()->getFgColor().getType() == app::Color::IndexType) {
int lastIndex = get_current_palette()->size()-1;
newIndex = ColorBar::instance()->getFgColor().getIndex() + dz;
newIndex = MID(0, newIndex, lastIndex);
}
ColorBar::instance()->setFgColor(app::Color::fromIndex(newIndex));
}
break;
case WHEEL_BG:
{
int newIndex = 0;
if (ColorBar::instance()->getBgColor().getType() == app::Color::IndexType) {
int lastIndex = get_current_palette()->size()-1;
newIndex = ColorBar::instance()->getBgColor().getIndex() + dz;
newIndex = MID(0, newIndex, lastIndex);
}
ColorBar::instance()->setBgColor(app::Color::fromIndex(newIndex));
}
break;
case WHEEL_FRAME:
{
Command* command = CommandsModule::instance()->getCommandByName
((dz < 0) ? CommandId::GotoNextFrame:
CommandId::GotoPreviousFrame);
if (command)
UIContext::instance()->executeCommand(command);
}
break;
case WHEEL_ZOOM: {
MouseMessage* mouseMsg = static_cast<MouseMessage*>(msg);
render::Zoom zoom = editor->zoom();
if (dz < 0) {
while (dz++ < 0)
zoom.in();
}
else {
while (dz-- > 0)
zoom.out();
}
if (editor->zoom() != zoom) {
bool center = Preferences::instance().editor.zoomFromCenterWithWheel();
editor->setZoomAndCenterInMouse(
zoom, mouseMsg->position(),
(center ? Editor::ZoomBehavior::CENTER:
Editor::ZoomBehavior::MOUSE));
}
break;
}
case WHEEL_HSCROLL:
case WHEEL_VSCROLL: {
View* view = View::getView(editor);
gfx::Point scroll = view->viewScroll();
gfx::Point delta(0, 0);
if (msg->preciseWheel()) {
delta = msg->wheelDelta();
}
else {
gfx::Rect vp = view->viewportBounds();
if (wheelAction == WHEEL_HSCROLL) {
delta.x = dz * vp.w;
}
else {
delta.y = dz * vp.h;
}
if (scrollBigSteps) {
delta /= 2;
}
else {
delta /= 10;
}
}
editor->setEditorScroll(scroll+delta, true);
break;
}
}
return true;
}
bool ToolBar::ToolStrip::onProcessMessage(Message* msg)
{
switch (msg->type()) {
case kMouseDownMessage:
captureMouse();
// fallthrough
case kMouseMoveMessage: {
MouseMessage* mouseMsg = static_cast<MouseMessage*>(msg);
gfx::Point mousePos = mouseMsg->position();
ToolBox* toolbox = App::instance()->getToolBox();
Tool* hot_tool = NULL;
Rect toolrc;
int index = 0;
for (ToolIterator it = toolbox->begin(); it != toolbox->end(); ++it) {
Tool* tool = *it;
if (tool->getGroup() == m_group) {
toolrc = getToolBounds(index++);
if (toolrc.contains(Point(mousePos.x, mousePos.y))) {
hot_tool = tool;
break;
}
}
}
// Hot button changed
if (m_hotTool != hot_tool) {
m_hotTool = hot_tool;
invalidate();
// Show the tooltip for the hot tool
if (m_hotTool && !hasCapture())
m_toolbar->openTipWindow(m_group, m_hotTool);
else
m_toolbar->closeTipWindow();
if (m_hotTool)
StatusBar::instance()->showTool(0, m_hotTool);
}
if (hasCapture()) {
if (m_hotTool)
m_toolbar->selectTool(m_hotTool);
Widget* pick = getManager()->pick(mouseMsg->position());
if (ToolBar* bar = dynamic_cast<ToolBar*>(pick)) {
releaseMouse();
MouseMessage* mouseMsg2 = new MouseMessage(
kMouseDownMessage,
mouseMsg->buttons(),
mouseMsg->position());
mouseMsg2->addRecipient(bar);
getManager()->enqueueMessage(mouseMsg2);
}
}
break;
}
case kMouseUpMessage:
if (hasCapture()) {
releaseMouse();
closeWindow();
}
break;
}
return Widget::onProcessMessage(msg);
}
bool ToolBar::onProcessMessage(Message* msg)
{
switch (msg->type()) {
case kMouseDownMessage: {
MouseMessage* mouseMsg = static_cast<MouseMessage*>(msg);
ToolBox* toolbox = App::instance()->getToolBox();
int groups = toolbox->getGroupsCount();
Rect toolrc;
ToolGroupList::iterator it = toolbox->begin_group();
for (int c=0; c<groups; ++c, ++it) {
ToolGroup* tool_group = *it;
Tool* tool = m_selectedInGroup[tool_group];
toolrc = getToolGroupBounds(c);
if (mouseMsg->position().y >= toolrc.y &&
mouseMsg->position().y < toolrc.y+toolrc.h) {
selectTool(tool);
openPopupWindow(c, tool_group);
// We capture the mouse so the user can continue navigating
// the ToolBar to open other groups while he is pressing the
// mouse button.
captureMouse();
}
}
toolrc = getToolGroupBounds(ConfigureToolIndex);
if (mouseMsg->position().y >= toolrc.y &&
mouseMsg->position().y < toolrc.y+toolrc.h) {
Command* conf_tools_cmd =
CommandsModule::instance()->getCommandByName(CommandId::ConfigureTools);
UIContext::instance()->executeCommand(conf_tools_cmd);
}
toolrc = getToolGroupBounds(MiniEditorVisibilityIndex);
if (mouseMsg->position().y >= toolrc.y &&
mouseMsg->position().y < toolrc.y+toolrc.h) {
// Switch the state of the mini editor
MiniEditorWindow* miniEditorWindow =
App::instance()->getMainWindow()->getMiniEditor();
bool state = miniEditorWindow->isMiniEditorEnabled();
miniEditorWindow->setMiniEditorEnabled(!state);
}
break;
}
case kMouseMoveMessage: {
MouseMessage* mouseMsg = static_cast<MouseMessage*>(msg);
ToolBox* toolbox = App::instance()->getToolBox();
int groups = toolbox->getGroupsCount();
Tool* new_hot_tool = NULL;
int new_hot_index = NoneIndex;
Rect toolrc;
ToolGroupList::iterator it = toolbox->begin_group();
for (int c=0; c<groups; ++c, ++it) {
ToolGroup* tool_group = *it;
Tool* tool = m_selectedInGroup[tool_group];
toolrc = getToolGroupBounds(c);
if (mouseMsg->position().y >= toolrc.y &&
mouseMsg->position().y < toolrc.y+toolrc.h) {
new_hot_tool = tool;
new_hot_index = c;
if ((m_openOnHot) && (m_hotTool != new_hot_tool) && hasCapture()) {
openPopupWindow(c, tool_group);
}
break;
}
}
toolrc = getToolGroupBounds(ConfigureToolIndex);
if (mouseMsg->position().y >= toolrc.y &&
mouseMsg->position().y < toolrc.y+toolrc.h) {
new_hot_index = ConfigureToolIndex;
}
toolrc = getToolGroupBounds(MiniEditorVisibilityIndex);
if (mouseMsg->position().y >= toolrc.y &&
mouseMsg->position().y < toolrc.y+toolrc.h) {
new_hot_index = MiniEditorVisibilityIndex;
}
// hot button changed
if (new_hot_tool != m_hotTool ||
new_hot_index != m_hotIndex) {
m_hotTool = new_hot_tool;
m_hotIndex = new_hot_index;
invalidate();
if (!m_currentStrip) {
if (m_hotIndex != NoneIndex && !hasCapture())
openTipWindow(m_hotIndex, m_hotTool);
else
closeTipWindow();
}
if (m_hotTool) {
if (hasCapture())
selectTool(m_hotTool);
else
StatusBar::instance()->showTool(0, m_hotTool);
}
}
// We can change the current tool if the user is dragging the
// mouse over the ToolBar.
if (hasCapture()) {
MouseMessage* mouseMsg = static_cast<MouseMessage*>(msg);
Widget* pick = getManager()->pick(mouseMsg->position());
if (ToolStrip* strip = dynamic_cast<ToolStrip*>(pick)) {
releaseMouse();
MouseMessage* mouseMsg2 = new MouseMessage(
kMouseDownMessage,
mouseMsg->buttons(),
mouseMsg->position());
mouseMsg2->addRecipient(strip);
getManager()->enqueueMessage(mouseMsg2);
}
}
break;
}
case kMouseUpMessage:
if (!hasCapture())
break;
if (!m_openedRecently) {
if (m_popupWindow && m_popupWindow->isVisible())
m_popupWindow->closeWindow(this);
}
m_openedRecently = false;
releaseMouse();
// fallthrough
case kMouseLeaveMessage:
if (hasCapture())
break;
closeTipWindow();
if (!m_popupWindow || !m_popupWindow->isVisible()) {
m_tipOpened = false;
m_hotTool = NULL;
m_hotIndex = NoneIndex;
invalidate();
}
StatusBar::instance()->clearText();
break;
case kTimerMessage:
if (static_cast<TimerMessage*>(msg)->timer() == &m_tipTimer) {
if (m_tipWindow)
m_tipWindow->openWindow();
m_tipTimer.stop();
m_tipOpened = true;
}
break;
}
return Widget::onProcessMessage(msg);
}
bool IntEntry::onProcessMessage(Message* msg)
{
switch (msg->type()) {
// Reset value if it's out of bounds when focus is lost
case kFocusLeaveMessage:
setValue(MID(m_min, getValue(), m_max));
deselectText();
break;
case kMouseDownMessage:
requestFocus();
captureMouse();
openPopup();
selectAllText();
return true;
case kMouseMoveMessage:
if (hasCapture()) {
MouseMessage* mouseMsg = static_cast<MouseMessage*>(msg);
Widget* pick = manager()->pick(mouseMsg->position());
if (pick == &m_slider) {
releaseMouse();
MouseMessage mouseMsg2(kMouseDownMessage,
mouseMsg->pointerType(),
mouseMsg->buttons(),
mouseMsg->modifiers(),
mouseMsg->position());
m_slider.sendMessage(&mouseMsg2);
}
}
break;
case kMouseWheelMessage:
if (isEnabled()) {
int oldValue = getValue();
int newValue = oldValue
+ static_cast<MouseMessage*>(msg)->wheelDelta().x
- static_cast<MouseMessage*>(msg)->wheelDelta().y;
newValue = MID(m_min, newValue, m_max);
if (newValue != oldValue) {
setValue(newValue);
selectAllText();
}
return true;
}
break;
case kKeyDownMessage:
if (hasFocus() && !isReadOnly()) {
KeyMessage* keymsg = static_cast<KeyMessage*>(msg);
int chr = keymsg->unicodeChar();
if (chr >= 32 && (chr < '0' || chr > '9')) {
// "Eat" all keys that aren't number
return true;
}
// Else we use the default Entry processing function which
// will process keys like Left/Right arrows, clipboard
// handling, etc.
}
break;
}
return Entry::onProcessMessage(msg);
}
bool FileList::onProcessMessage(Message* msg)
{
switch (msg->type()) {
case kMouseDownMessage:
captureMouse();
case kMouseMoveMessage:
if (hasCapture()) {
MouseMessage* mouseMsg = static_cast<MouseMessage*>(msg);
int th = getTextHeight();
int y = getBounds().y;
IFileItem* old_selected = m_selected;
m_selected = NULL;
// rows
for (FileItemList::iterator
it=m_list.begin();
it!=m_list.end(); ++it) {
IFileItem* fi = *it;
gfx::Size itemSize = getFileItemSize(fi);
if (((mouseMsg->position().y >= y) &&
(mouseMsg->position().y < y+th+4*jguiscale())) ||
(it == m_list.begin() && mouseMsg->position().y < y) ||
(it == m_list.end()-1 && mouseMsg->position().y >= y+th+4*jguiscale())) {
m_selected = fi;
makeSelectedFileitemVisible();
break;
}
y += itemSize.h;
}
if (old_selected != m_selected) {
generatePreviewOfSelectedItem();
invalidate();
// Emit "FileSelected" event.
onFileSelected();
}
}
break;
case kMouseUpMessage:
if (hasCapture()) {
releaseMouse();
}
break;
case kKeyDownMessage:
if (hasFocus()) {
KeyMessage* keyMsg = static_cast<KeyMessage*>(msg);
KeyScancode scancode = keyMsg->scancode();
int unicodeChar = keyMsg->unicodeChar();
int select = getSelectedIndex();
View* view = View::getView(this);
int bottom = m_list.size();
switch (scancode) {
case kKeyUp:
if (select >= 0)
select--;
else
select = 0;
break;
case kKeyDown:
if (select >= 0)
select++;
else
select = 0;
break;
case kKeyHome:
select = 0;
break;
case kKeyEnd:
select = bottom-1;
break;
case kKeyPageUp:
case kKeyPageDown: {
int sgn = (scancode == kKeyPageUp) ? -1: 1;
gfx::Rect vp = view->getViewportBounds();
if (select < 0)
select = 0;
select += sgn * vp.h / (getTextHeight()+4*jguiscale());
break;
}
case kKeyLeft:
case kKeyRight:
if (select >= 0) {
gfx::Rect vp = view->getViewportBounds();
int sgn = (scancode == kKeyLeft) ? -1: 1;
gfx::Point scroll = view->getViewScroll();
scroll.x += vp.w/2*sgn;
view->setViewScroll(scroll);
}
break;
case kKeyEnter:
case kKeyEnterPad:
if (m_selected) {
if (m_selected->isBrowsable()) {
setCurrentFolder(m_selected);
return true;
}
if (m_selected->isFolder()) {
// Do nothing (is a folder but not browseable).
return true;
}
else {
// Emit "FileAccepted" event.
onFileAccepted();
return true;
}
}
else
return Widget::onProcessMessage(msg);
case kKeyBackspace:
goUp();
return true;
default:
if (unicodeChar == ' ' ||
(utolower(unicodeChar) >= 'a' &&
utolower(unicodeChar) <= 'z') ||
(unicodeChar >= '0' &&
unicodeChar <= '9')) {
if (ui::clock() - m_isearchClock > ISEARCH_KEYPRESS_INTERVAL_MSECS)
m_isearch.clear();
m_isearch.push_back(unicodeChar);
int i, chrs = m_isearch.size();
FileItemList::iterator
link = m_list.begin() + ((select >= 0) ? select: 0);
for (i=MAX(select, 0); i<bottom; ++i, ++link) {
IFileItem* fi = *link;
if (ustrnicmp(fi->getDisplayName().c_str(),
m_isearch.c_str(),
chrs) == 0) {
select = i;
break;
}
}
m_isearchClock = ui::clock();
// Go to selectIndex...
}
else
return Widget::onProcessMessage(msg);
}
if (bottom > 0)
selectIndex(MID(0, select, bottom-1));
return true;
}
break;
case kMouseWheelMessage: {
View* view = View::getView(this);
if (view) {
gfx::Point scroll = view->getViewScroll();
scroll += static_cast<MouseMessage*>(msg)->wheelDelta() * 3*(getTextHeight()+4*jguiscale());
view->setViewScroll(scroll);
}
break;
}
case kDoubleClickMessage:
if (m_selected) {
if (m_selected->isBrowsable()) {
setCurrentFolder(m_selected);
return true;
}
else {
onFileAccepted(); // Emit "FileAccepted" event.
return true;
}
}
break;
}
return Widget::onProcessMessage(msg);
}
bool Entry::onProcessMessage(Message* msg)
{
switch (msg->type()) {
case kTimerMessage:
if (hasFocus() && static_cast<TimerMessage*>(msg)->timer() == &m_timer) {
// Blinking caret
m_state = m_state ? false: true;
invalidate();
}
break;
case kFocusEnterMessage:
if (shouldStartTimer(true))
m_timer.start();
m_state = true;
invalidate();
if (m_lock_selection) {
m_lock_selection = false;
}
else {
selectAllText();
m_recent_focused = true;
}
// Start processing dead keys
if (m_translate_dead_keys)
os::instance()->setTranslateDeadKeys(true);
break;
case kFocusLeaveMessage:
invalidate();
m_timer.stop();
if (!m_lock_selection)
deselectText();
m_recent_focused = false;
// Stop processing dead keys
if (m_translate_dead_keys)
os::instance()->setTranslateDeadKeys(false);
break;
case kKeyDownMessage:
if (hasFocus() && !isReadOnly()) {
// Command to execute
EntryCmd cmd = EntryCmd::NoOp;
KeyMessage* keymsg = static_cast<KeyMessage*>(msg);
KeyScancode scancode = keymsg->scancode();
switch (scancode) {
case kKeyLeft:
if (msg->ctrlPressed() || msg->altPressed())
cmd = EntryCmd::BackwardWord;
else if (msg->cmdPressed())
cmd = EntryCmd::BeginningOfLine;
else
cmd = EntryCmd::BackwardChar;
break;
case kKeyRight:
if (msg->ctrlPressed() || msg->altPressed())
cmd = EntryCmd::ForwardWord;
else if (msg->cmdPressed())
cmd = EntryCmd::EndOfLine;
else
cmd = EntryCmd::ForwardChar;
break;
case kKeyHome:
cmd = EntryCmd::BeginningOfLine;
break;
case kKeyEnd:
cmd = EntryCmd::EndOfLine;
break;
case kKeyDel:
if (msg->shiftPressed())
cmd = EntryCmd::Cut;
else if (msg->ctrlPressed())
cmd = EntryCmd::DeleteForwardToEndOfLine;
else
cmd = EntryCmd::DeleteForward;
break;
case kKeyInsert:
if (msg->shiftPressed())
cmd = EntryCmd::Paste;
else if (msg->ctrlPressed())
cmd = EntryCmd::Copy;
break;
case kKeyBackspace:
if (msg->ctrlPressed())
cmd = EntryCmd::DeleteBackwardWord;
else
cmd = EntryCmd::DeleteBackward;
break;
default:
// Map common macOS/Windows shortcuts for Cut/Copy/Paste/Select all
#if defined __APPLE__
if (msg->onlyCmdPressed())
#else
if (msg->onlyCtrlPressed())
#endif
{
switch (scancode) {
case kKeyX: cmd = EntryCmd::Cut; break;
case kKeyC: cmd = EntryCmd::Copy; break;
case kKeyV: cmd = EntryCmd::Paste; break;
case kKeyA: cmd = EntryCmd::SelectAll; break;
}
}
break;
}
if (cmd == EntryCmd::NoOp) {
if (keymsg->unicodeChar() >= 32) {
executeCmd(EntryCmd::InsertChar, keymsg->unicodeChar(),
(msg->shiftPressed()) ? true: false);
// Select dead-key
if (keymsg->isDeadKey()) {
if (lastCaretPos() < m_maxsize)
selectText(m_caret-1, m_caret);
}
return true;
}
// Consume all key down of modifiers only, e.g. so the user
// can press first "Ctrl" key, and then "Ctrl+C"
// combination.
else if (keymsg->scancode() >= kKeyFirstModifierScancode) {
return true;
}
else {
break; // Propagate to manager
}
}
executeCmd(cmd, keymsg->unicodeChar(),
(msg->shiftPressed()) ? true: false);
return true;
}
break;
case kMouseDownMessage:
captureMouse();
case kMouseMoveMessage:
if (hasCapture()) {
bool is_dirty = false;
int c = getCaretFromMouse(static_cast<MouseMessage*>(msg));
if (static_cast<MouseMessage*>(msg)->left() || !isPosInSelection(c)) {
// Move caret
if (m_caret != c) {
setCaretPos(c);
is_dirty = true;
invalidate();
}
// Move selection
if (m_recent_focused) {
m_recent_focused = false;
m_select = m_caret;
}
else if (msg->type() == kMouseDownMessage)
m_select = m_caret;
}
// Show the caret
if (is_dirty) {
if (shouldStartTimer(true))
m_timer.start();
m_state = true;
}
return true;
}
break;
case kMouseUpMessage:
if (hasCapture()) {
releaseMouse();
MouseMessage* mouseMsg = static_cast<MouseMessage*>(msg);
if (mouseMsg->right()) {
// This flag is disabled in kFocusEnterMessage message handler.
m_lock_selection = true;
showEditPopupMenu(mouseMsg->position());
requestFocus();
}
}
return true;
case kDoubleClickMessage:
forwardWord();
m_select = m_caret;
backwardWord();
invalidate();
return true;
case kMouseEnterMessage:
case kMouseLeaveMessage:
// TODO theme stuff
if (isEnabled())
invalidate();
break;
}
return Widget::onProcessMessage(msg);
}
bool ComboBoxEntry::onProcessMessage(Message* msg)
{
switch (msg->type()) {
case kKeyDownMessage:
if (hasFocus()) {
KeyMessage* keymsg = static_cast<KeyMessage*>(msg);
KeyScancode scancode = keymsg->scancode();
if (!m_comboBox->isEditable()) {
if (scancode == kKeySpace ||
scancode == kKeyEnter ||
scancode == kKeyEnterPad) {
m_comboBox->switchListBox();
return true;
}
}
else {
if (scancode == kKeyEnter ||
scancode == kKeyEnterPad) {
m_comboBox->switchListBox();
return true;
}
}
}
break;
case kMouseDownMessage:
if (m_comboBox->isClickOpen()) {
m_comboBox->switchListBox();
}
if (m_comboBox->isEditable()) {
getManager()->setFocus(this);
}
else {
captureMouse();
return true;
}
break;
case kMouseUpMessage:
if (hasCapture())
releaseMouse();
break;
case kMouseMoveMessage:
if (hasCapture()) {
MouseMessage* mouseMsg = static_cast<MouseMessage*>(msg);
Widget* pick = getManager()->pick(mouseMsg->position());
Widget* listbox = m_comboBox->m_listbox;
if (pick != NULL && (pick == listbox || pick->hasAncestor(listbox))) {
releaseMouse();
MouseMessage mouseMsg2(kMouseDownMessage,
mouseMsg->buttons(), mouseMsg->position());
pick->sendMessage(&mouseMsg2);
return true;
}
}
break;
}
return Entry::onProcessMessage(msg);
}
bool PaletteView::onProcessMessage(Message* msg)
{
switch (msg->type()) {
case kMouseDownMessage:
captureMouse();
/* continue... */
case kMouseMoveMessage: {
MouseMessage* mouseMsg = static_cast<MouseMessage*>(msg);
gfx::Rect cpos = getChildrenBounds();
int req_w, req_h;
request_size(&req_w, &req_h);
int mouse_x = MID(cpos.x, mouseMsg->position().x, cpos.x+req_w-this->border_width.r-1);
int mouse_y = MID(cpos.y, mouseMsg->position().y, cpos.y+req_h-this->border_width.b-1);
app::Color color = getColorByPosition(mouse_x, mouse_y);
if (color.getType() == app::Color::IndexType) {
int idx = color.getIndex();
StatusBar::instance()->showColor(0, "", color, 255);
if (hasCapture() && idx != m_currentEntry) {
if (!msg->ctrlPressed())
clearSelection();
if (msg->shiftPressed())
selectRange(m_rangeAnchor, idx);
else
selectColor(idx);
// Emit signal
IndexChange(idx);
}
}
if (hasCapture())
return true;
break;
}
case kMouseUpMessage:
releaseMouse();
return true;
case kMouseWheelMessage: {
View* view = View::getView(this);
if (view) {
gfx::Point scroll = view->getViewScroll();
scroll += static_cast<MouseMessage*>(msg)->wheelDelta() * 3 * m_boxsize;
view->setViewScroll(scroll);
}
break;
}
case kMouseLeaveMessage:
StatusBar::instance()->clearText();
break;
}
return Widget::onProcessMessage(msg);
}
bool StandbyState::onMouseWheel(Editor* editor, MouseMessage* msg)
{
int dz = msg->wheelDelta().x + msg->wheelDelta().y;
WHEEL_ACTION wheelAction = WHEEL_NONE;
bool scrollBigSteps = false;
// Alt+mouse wheel changes the fg/bg colors
if (msg->altPressed()) {
if (msg->shiftPressed())
wheelAction = WHEEL_BG;
else
wheelAction = WHEEL_FG;
}
// Normal behavior: mouse wheel zooms
else if (UIContext::instance()->settings()->getZoomWithScrollWheel()) {
if (msg->ctrlPressed())
wheelAction = WHEEL_FRAME;
else if (msg->wheelDelta().x != 0 || msg->shiftPressed())
wheelAction = WHEEL_HSCROLL;
else
wheelAction = WHEEL_ZOOM;
}
// For laptops, it's convenient to that Ctrl+wheel zoom (because
// it's the "pinch" gesture).
else {
if (msg->ctrlPressed())
wheelAction = WHEEL_ZOOM;
else if (msg->wheelDelta().x != 0 || msg->shiftPressed())
wheelAction = WHEEL_HSCROLL;
else
wheelAction = WHEEL_VSCROLL;
}
switch (wheelAction) {
case WHEEL_NONE:
// Do nothing
break;
case WHEEL_FG:
{
int newIndex = 0;
if (ColorBar::instance()->getFgColor().getType() == app::Color::IndexType) {
newIndex = ColorBar::instance()->getFgColor().getIndex() + dz;
newIndex = MID(0, newIndex, 255);
}
ColorBar::instance()->setFgColor(app::Color::fromIndex(newIndex));
}
break;
case WHEEL_BG:
{
int newIndex = 0;
if (ColorBar::instance()->getBgColor().getType() == app::Color::IndexType) {
newIndex = ColorBar::instance()->getBgColor().getIndex() + dz;
newIndex = MID(0, newIndex, 255);
}
ColorBar::instance()->setBgColor(app::Color::fromIndex(newIndex));
}
break;
case WHEEL_FRAME:
{
Command* command = CommandsModule::instance()->getCommandByName
((dz < 0) ? CommandId::GotoNextFrame:
CommandId::GotoPreviousFrame);
if (command)
UIContext::instance()->executeCommand(command, NULL);
}
break;
case WHEEL_ZOOM: {
MouseMessage* mouseMsg = static_cast<MouseMessage*>(msg);
int zoom = MID(MIN_ZOOM, editor->zoom()-dz, MAX_ZOOM);
if (editor->zoom() != zoom)
editor->setZoomAndCenterInMouse(zoom,
mouseMsg->position().x, mouseMsg->position().y,
Editor::kDontCenterOnZoom);
break;
}
case WHEEL_HSCROLL:
case WHEEL_VSCROLL: {
View* view = View::getView(editor);
gfx::Rect vp = view->getViewportBounds();
int dx = 0;
int dy = 0;
if (wheelAction == WHEEL_HSCROLL) {
dx = dz * vp.w;
}
else {
dy = dz * vp.h;
}
if (scrollBigSteps) {
dx /= 2;
dy /= 2;
}
else {
dx /= 10;
dy /= 10;
}
gfx::Point scroll = view->getViewScroll();
editor->hideDrawingCursor();
editor->setEditorScroll(scroll.x+dx, scroll.y+dy, true);
editor->showDrawingCursor();
break;
}
}
return true;
}
void ClickableControl::MouseUp(const Point& position, const MouseMessage& message) {
if (message.GetMouseButton() == MouseButton::Left) {
EndPress(PressType::Mouse);
}
}
bool Entry::onProcessMessage(Message* msg)
{
switch (msg->type()) {
case kTimerMessage:
if (hasFocus() && static_cast<TimerMessage*>(msg)->timer() == &m_timer) {
// Blinking caret
m_state = m_state ? false: true;
invalidate();
}
break;
case kFocusEnterMessage:
m_timer.start();
m_state = true;
invalidate();
if (m_lock_selection) {
m_lock_selection = false;
}
else {
selectAllText();
m_recent_focused = true;
}
break;
case kFocusLeaveMessage:
invalidate();
m_timer.stop();
if (!m_lock_selection)
deselectText();
m_recent_focused = false;
break;
case kKeyDownMessage:
if (hasFocus() && !isReadOnly()) {
// Command to execute
EntryCmd cmd = EntryCmd::NoOp;
KeyMessage* keymsg = static_cast<KeyMessage*>(msg);
KeyScancode scancode = keymsg->scancode();
switch (scancode) {
case kKeyLeft:
if (msg->ctrlPressed())
cmd = EntryCmd::BackwardWord;
else
cmd = EntryCmd::BackwardChar;
break;
case kKeyRight:
if (msg->ctrlPressed())
cmd = EntryCmd::ForwardWord;
else
cmd = EntryCmd::ForwardChar;
break;
case kKeyHome:
cmd = EntryCmd::BeginningOfLine;
break;
case kKeyEnd:
cmd = EntryCmd::EndOfLine;
break;
case kKeyDel:
if (msg->shiftPressed())
cmd = EntryCmd::Cut;
else
cmd = EntryCmd::DeleteForward;
break;
case kKeyInsert:
if (msg->shiftPressed())
cmd = EntryCmd::Paste;
else if (msg->ctrlPressed())
cmd = EntryCmd::Copy;
break;
case kKeyBackspace:
cmd = EntryCmd::DeleteBackward;
break;
default:
// Map common Windows shortcuts for Cut/Copy/Paste
#if defined __APPLE__
if (msg->onlyCmdPressed())
#else
if (msg->onlyCtrlPressed())
#endif
{
switch (scancode) {
case kKeyX: cmd = EntryCmd::Cut; break;
case kKeyC: cmd = EntryCmd::Copy; break;
case kKeyV: cmd = EntryCmd::Paste; break;
}
}
else if (keymsg->unicodeChar() >= 32) {
// Ctrl and Alt must be unpressed to insert a character
// in the text-field.
if ((msg->keyModifiers() & (kKeyCtrlModifier | kKeyAltModifier)) == 0) {
cmd = EntryCmd::InsertChar;
}
}
break;
}
if (cmd == EntryCmd::NoOp)
break;
executeCmd(cmd, keymsg->unicodeChar(),
(msg->shiftPressed()) ? true: false);
return true;
}
break;
case kMouseDownMessage:
captureMouse();
case kMouseMoveMessage:
if (hasCapture()) {
gfx::Point mousePos = static_cast<MouseMessage*>(msg)->position();
base::utf8_const_iterator utf8_begin = base::utf8_const_iterator(getText().begin());
base::utf8_const_iterator utf8_end = base::utf8_const_iterator(getText().end());
int textlen = base::utf8_length(getText());
int c, x;
bool move = true;
bool is_dirty = false;
// Backward scroll
if (mousePos.x < getBounds().x) {
if (m_scroll > 0) {
m_caret = --m_scroll;
move = false;
is_dirty = true;
invalidate();
}
}
// Forward scroll
else if (mousePos.x >= getBounds().x2()) {
if (m_scroll < textlen - getAvailableTextLength()) {
m_scroll++;
x = getBounds().x + this->border_width.l;
for (c=m_scroll; utf8_begin != utf8_end; ++c) {
int ch = (c < textlen ? *(utf8_begin+c) : ' ');
x += getFont()->charWidth(ch);
if (x > getBounds().x2()-this->border_width.r) {
c--;
break;
}
}
m_caret = c;
move = false;
is_dirty = true;
invalidate();
}
}
c = getCaretFromMouse(static_cast<MouseMessage*>(msg));
if (static_cast<MouseMessage*>(msg)->left() ||
(move && !isPosInSelection(c))) {
// Move caret
if (move) {
if (m_caret != c) {
m_caret = c;
is_dirty = true;
invalidate();
}
}
// Move selection
if (m_recent_focused) {
m_recent_focused = false;
m_select = m_caret;
}
else if (msg->type() == kMouseDownMessage)
m_select = m_caret;
}
// Show the caret
if (is_dirty) {
m_timer.start();
m_state = true;
}
return true;
}
break;
case kMouseUpMessage:
if (hasCapture()) {
releaseMouse();
MouseMessage* mouseMsg = static_cast<MouseMessage*>(msg);
if (mouseMsg->right()) {
// This flag is disabled in kFocusEnterMessage message handler.
m_lock_selection = true;
showEditPopupMenu(mouseMsg->position());
requestFocus();
}
}
return true;
case kDoubleClickMessage:
forwardWord();
m_select = m_caret;
backwardWord();
invalidate();
return true;
case kMouseEnterMessage:
case kMouseLeaveMessage:
// TODO theme stuff
if (isEnabled())
invalidate();
break;
}
return Widget::onProcessMessage(msg);
}
bool IntEntry::onProcessMessage(Message* msg)
{
switch (msg->type()) {
// Reset value if it's out of bounds when focus is lost
case kFocusLeaveMessage:
setValue(MID(m_min, getValue(), m_max));
deselectText();
break;
case kMouseDownMessage:
requestFocus();
captureMouse();
openPopup();
selectAllText();
return true;
case kMouseMoveMessage:
if (hasCapture()) {
MouseMessage* mouseMsg = static_cast<MouseMessage*>(msg);
Widget* pick = getManager()->pick(mouseMsg->position());
if (pick == &m_slider) {
releaseMouse();
MouseMessage mouseMsg2(kMouseDownMessage,
mouseMsg->buttons(),
mouseMsg->modifiers(),
mouseMsg->position());
m_slider.sendMessage(&mouseMsg2);
}
}
break;
case kMouseWheelMessage:
if (isEnabled()) {
int oldValue = getValue();
int newValue = oldValue
+ static_cast<MouseMessage*>(msg)->wheelDelta().x
- static_cast<MouseMessage*>(msg)->wheelDelta().y;
newValue = MID(m_min, newValue, m_max);
if (newValue != oldValue) {
setValue(newValue);
selectAllText();
}
return true;
}
break;
case kKeyDownMessage:
if (hasFocus() && !isReadOnly()) {
KeyMessage* keymsg = static_cast<KeyMessage*>(msg);
int chr = keymsg->unicodeChar();
if (chr < '0' || chr > '9') {
// By-pass Entry::onProcessMessage()
return Widget::onProcessMessage(msg);
}
}
break;
}
return Entry::onProcessMessage(msg);
}
bool Tabs::onProcessMessage(Message* msg)
{
switch (msg->type()) {
case kMouseEnterMessage:
case kMouseMoveMessage:
calculateHot();
return true;
case kMouseLeaveMessage:
if (m_hot != NULL) {
m_hot = NULL;
invalidate();
}
return true;
case kMouseDownMessage:
case kMouseUpMessage:
if (m_hot != NULL) {
MouseMessage* mouseMsg = static_cast<MouseMessage*>(msg);
if (m_selected != m_hot) {
m_selected = m_hot;
invalidate();
}
// Left button is processed in mouse down message, right
// button is processed in mouse up.
if (m_selected && m_delegate &&
((mouseMsg->left() && msg->type() == kMouseDownMessage) ||
(!mouseMsg->left() && msg->type() == kMouseUpMessage))) {
m_delegate->clickTab(this, m_selected->view, mouseMsg->buttons());
}
}
return true;
case kMouseWheelMessage: {
int dz =
(static_cast<MouseMessage*>(msg)->wheelDelta().x -
static_cast<MouseMessage*>(msg)->wheelDelta().y) * getBounds().w/6;
m_begScrollX = m_scrollX;
if (m_ani != ANI_SMOOTH_SCROLL)
m_endScrollX = m_scrollX + dz;
else
m_endScrollX += dz;
// Limit endScrollX position (to improve animation ending to the correct position)
{
int max_x = getMaxScrollX();
m_endScrollX = MID(0, m_endScrollX, max_x);
}
startAni(ANI_SMOOTH_SCROLL);
return true;
}
case kTimerMessage: {
switch (m_ani) {
case ANI_NONE:
// Do nothing
break;
case ANI_SCROLL: {
ScrollButton* button = dynamic_cast<ScrollButton*>(getManager()->getCapture());
if (button != NULL)
setScrollX(m_scrollX + button->getDirection()*8*static_cast<TimerMessage*>(msg)->count());
break;
}
case ANI_SMOOTH_SCROLL: {
if (m_ani_t == ANI_SMOOTH_SCROLL_TICKS) {
stopAni();
setScrollX(m_endScrollX);
}
else {
// Lineal
//setScrollX(m_begScrollX + m_endScrollX - m_begScrollX) * m_ani_t / 10);
// Exponential
setScrollX(m_begScrollX +
(m_endScrollX - m_begScrollX) * (1.0-std::exp(-10.0 * m_ani_t / (double)ANI_SMOOTH_SCROLL_TICKS)));
}
break;
}
case ANI_ADDING_TAB: {
if (m_ani_t == ANI_ADDING_TAB_TICKS)
stopAni();
invalidate();
break;
}
case ANI_REMOVING_TAB: {
if (m_ani_t == ANI_REMOVING_TAB_TICKS)
stopAni();
invalidate();
break;
}
}
++m_ani_t;
break;
}
}
return Widget::onProcessMessage(msg);
}