/*
* Copyright 2000-2009 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.intellij.uiDesigner.designSurface;
import com.intellij.ide.palette.impl.PaletteToolWindowManager;
import com.intellij.openapi.actionSystem.*;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.uiDesigner.FormEditingUtil;
import com.intellij.uiDesigner.palette.ComponentItem;
import com.intellij.uiDesigner.propertyInspector.InplaceContext;
import com.intellij.uiDesigner.radComponents.RadComponent;
import com.intellij.uiDesigner.radComponents.RadRootContainer;
import com.intellij.util.ui.UIUtil;
import gnu.trove.TIntArrayList;
import org.jetbrains.annotations.NotNull;
import javax.swing.*;
import java.awt.*;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
/**
* @author Anton Katilin
* @author Vladimir Kondratyev
*/
public final class MainProcessor extends EventProcessor{
private static final Logger LOG = Logger.getInstance("#com.intellij.uiDesigner.MainProcessor");
private static final int DRAGGER_SIZE = 10;
private EventProcessor myCurrentProcessor;
@NotNull private final InsertComponentProcessor myInsertComponentProcessor;
@NotNull private final GuiEditor myEditor;
private boolean myInsertFeedbackEnabled = true;
private Point myLastMousePosition = new Point(0, 0);
public MainProcessor(@NotNull final GuiEditor editor){
myEditor = editor;
myInsertComponentProcessor = new InsertComponentProcessor(myEditor);
}
protected void processKeyEvent(final KeyEvent e){
if (e.getKeyCode() == KeyEvent.VK_SHIFT) {
if (e.getID() == KeyEvent.KEY_PRESSED) {
if ((myCurrentProcessor != null && myCurrentProcessor.isDragActive()) ||
(PaletteToolWindowManager.getInstance(myEditor).getActiveItem(ComponentItem.class) != null &&
myCurrentProcessor != myInsertComponentProcessor)) {
myEditor.setDesignTimeInsets(12);
}
}
else {
myEditor.setDesignTimeInsets(2);
}
}
if (myCurrentProcessor != null) {
myCurrentProcessor.processKeyEvent(e);
}
else if (e.getID() == KeyEvent.KEY_TYPED && Character.isLetterOrDigit(e.getKeyChar()) &&
(e.getModifiers() & (InputEvent.ALT_MASK | InputEvent.CTRL_MASK | InputEvent.META_MASK)) == 0) {
final ArrayList<RadComponent> selection = FormEditingUtil.getAllSelectedComponents(myEditor);
if (selection.size() > 0) {
final RadComponent component = selection.get(0);
final InplaceEditingLayer inplaceLayer = myEditor.getInplaceEditingLayer();
inplaceLayer.startInplaceEditing(component, component.getDefaultInplaceProperty(),
component.getDefaultInplaceEditorBounds(), new InplaceContext(false, e.getKeyChar()));
e.consume();
}
}
}
public Point getLastMousePosition() {
return myLastMousePosition;
}
protected void processMouseEvent(final MouseEvent e){
myLastMousePosition = e.getPoint();
if (myCurrentProcessor != null && myCurrentProcessor.isDragActive()) {
return;
}
// Here is a good place to handle right and wheel mouse clicking. All mouse
// motion events should go further
if (e.isPopupTrigger()) {
RadComponent component = FormEditingUtil.getRadComponentAt(myEditor.getRootContainer(), e.getX(), e.getY());
if (component != null && !component.isSelected()) {
FormEditingUtil.selectSingleComponent(myEditor, component);
}
final ActionManager actionManager = ActionManager.getInstance();
final ActionPopupMenu popupMenu = actionManager.createActionPopupMenu(
ActionPlaces.GUI_DESIGNER_EDITOR_POPUP,
(ActionGroup)actionManager.getAction(IdeActions.GROUP_GUI_DESIGNER_EDITOR_POPUP)
);
popupMenu.getComponent().show(e.getComponent(), e.getX(), e.getY());
return;
}
final int id = e.getID();
if(
(MouseEvent.BUTTON2 == e.getButton() || MouseEvent.BUTTON3 == e.getButton()) &&
(
MouseEvent.MOUSE_PRESSED == id ||
MouseEvent.MOUSE_RELEASED == id ||
MouseEvent.MOUSE_CLICKED == id
)
){
return;
}
// Handle all left mouse events and all motion events
final RadComponent componentAt = FormEditingUtil.getRadComponentAt(myEditor.getRootContainer(), e.getX(), e.getY());
if (componentAt != null) {
final Point p1 = SwingUtilities.convertPoint(e.getComponent(), e.getPoint(), componentAt.getDelegee());
final Component deepestComponentAt = SwingUtilities.getDeepestComponentAt(componentAt.getDelegee(), p1.x, p1.y);
final Point p2 = SwingUtilities.convertPoint(e.getComponent(), e.getPoint(), deepestComponentAt);
EventProcessor processor = componentAt.getEventProcessor(e);
if (processor != null) {
myCurrentProcessor = processor;
}
else {
final Component source = deepestComponentAt != null ? deepestComponentAt : componentAt.getDelegee();
componentAt.processMouseEvent(new MouseEvent(source,
id,
e.getWhen(),
e.getModifiers(),
p2.x,
p2.y,
e.getClickCount(),
e.isPopupTrigger(),
e.getButton()
));
}
}
Cursor cursor = Cursor.getDefaultCursor();
if(id==MouseEvent.MOUSE_MOVED){
if (PaletteToolWindowManager.getInstance(myEditor).getActiveItem(ComponentItem.class) != null) {
if (myInsertFeedbackEnabled) {
cursor = myInsertComponentProcessor.processMouseMoveEvent(e);
}
}
else if (myCurrentProcessor != null) {
myCurrentProcessor.processMouseEvent(e);
}
else {
final RadComponent component = FormEditingUtil.getRadComponentAt(myEditor.getRootContainer(), e.getX(), e.getY());
if (component != null) {
final Point point = SwingUtilities.convertPoint(e.getComponent(), e.getPoint(), component.getDelegee());
final int resizeMask = Painter.getResizeMask(component, point.x, point.y);
if (resizeMask != 0) {
cursor = Cursor.getPredefinedCursor(Painter.getResizeCursor(resizeMask));
}
updateDragger(e);
}
}
}
else if (id == MouseEvent.MOUSE_PRESSED) {
processMousePressed(e);
}
else if (id == MouseEvent.MOUSE_RELEASED) {
// not every press sets processor so its not a redundant 'if'
if (myCurrentProcessor != null) {
myCurrentProcessor.processMouseEvent(e);
myCurrentProcessor = null;
}
}
else if(id == MouseEvent.MOUSE_CLICKED){
processMouseClicked(e);
}
else if (id == MouseEvent.MOUSE_EXITED) {
myEditor.getActiveDecorationLayer().removeFeedback();
}
if (!e.isConsumed() && myCurrentProcessor != null) {
myCurrentProcessor.processMouseEvent(e);
}
if (myCurrentProcessor != null && myCurrentProcessor.isDragActive()) {
myEditor.getLayeredPane().setCursor(null);
}
else {
if(myCurrentProcessor!=null && myCurrentProcessor.getCursor()!=null){
cursor=myCurrentProcessor.getCursor();
}
myEditor.getLayeredPane().setCursor(cursor);
}
}
private void updateDragger(final MouseEvent e) {
final RadComponent component = FormEditingUtil.getRadComponentAt(myEditor.getRootContainer(), e.getX(), e.getY());
LOG.assertTrue(component != null);
// Dragger
final RadComponent oldDraggerHost = FormEditingUtil.getDraggerHost(myEditor);
RadComponent newDraggerHost = null;
for (RadComponent c = component; c != null && !(c instanceof RadRootContainer); c = c.getParent()) {
if (c.isSelected()) {
newDraggerHost = c;
break;
}
}
boolean keepOldHost = false;
if (oldDraggerHost != null && oldDraggerHost.isSelected()) {
final Point p = SwingUtilities.convertPoint(oldDraggerHost.getDelegee(), 0, 0, e.getComponent());
final int deltaX = e.getX() - p.x;
final int deltaY = e.getY() - p.y;
if(
deltaX > -DRAGGER_SIZE && deltaX < oldDraggerHost.getWidth() &&
deltaY > -DRAGGER_SIZE && deltaY < oldDraggerHost.getHeight()
){
keepOldHost = true;
newDraggerHost = null;
}
}
boolean shouldRepaint = false;
if (oldDraggerHost != null && !keepOldHost && oldDraggerHost != newDraggerHost){
oldDraggerHost.setDragger(false);
shouldRepaint = true;
}
if (newDraggerHost != null){
newDraggerHost.setDragger(true);
shouldRepaint = true;
}
if (shouldRepaint) {
myEditor.repaintLayeredPane();
}
}
private void removeDragger() {
final RadComponent oldDraggerHost = FormEditingUtil.getDraggerHost(myEditor);
if (oldDraggerHost != null) {
oldDraggerHost.setDragger(false);
myEditor.repaintLayeredPane();
}
}
private void processMousePressed(final MouseEvent e){
if(myCurrentProcessor != null){
if (myCurrentProcessor.needMousePressed()) {
myCurrentProcessor.processMouseEvent(e);
return;
}
// Sun sometimes skips mouse released events...
myCurrentProcessor.cancelOperation();
myCurrentProcessor = null;
}
RadComponent component = null;
final RadComponent draggerHost = FormEditingUtil.getDraggerHost(myEditor);
// Try to understand whether we pressed inside dragger area
if(draggerHost != null){
final JComponent delegee = draggerHost.getDelegee();
final Point p = SwingUtilities.convertPoint(delegee, 0, 0, e.getComponent());
if(
p.x - MainProcessor.DRAGGER_SIZE <= e.getX() && e.getX() <= p.x &&
p.y - MainProcessor.DRAGGER_SIZE <= e.getY() && e.getY() <= p.y
){
component = draggerHost;
}
}
// If user clicked not inside dragger then we have find RadComponent at the click point
if(component == null){
component = FormEditingUtil.getRadComponentAt(myEditor.getRootContainer(), e.getX(), e.getY());
}
if (component == null) {
return;
}
final ComponentItem selectedItem = PaletteToolWindowManager.getInstance(myEditor).getActiveItem(ComponentItem.class);
if (selectedItem != null) {
myInsertComponentProcessor.setSticky(UIUtil.isControlKeyDown(e));
myCurrentProcessor = myInsertComponentProcessor;
return;
}
if (!UIUtil.isControlKeyDown(e) && !e.isShiftDown()) {
if (!component.isSelected() || FormEditingUtil.getSelectedComponents(myEditor).size() != 1) {
FormEditingUtil.selectSingleComponent(myEditor, component);
}
}
final Point point = SwingUtilities.convertPoint(e.getComponent(), e.getPoint(), component.getDelegee());
final int resizeMask = Painter.getResizeMask(component, point.x, point.y);
LOG.debug("MainProcessor.processMousePressed: resizeMask at (" + point.x + "," + point.y + ") is " + resizeMask);
if (resizeMask != 0) {
if (component.getParent() != null) {
component = component.getParent().getActionTargetComponent(component);
}
myCurrentProcessor = new ResizeProcessor(myEditor, component, resizeMask);
}
else if (component instanceof RadRootContainer || e.isShiftDown()) {
myCurrentProcessor = new GroupSelectionProcessor(myEditor, component);
}
else if (!e.isShiftDown()) {
myCurrentProcessor = new DragSelectionProcessor(myEditor);
}
updateDragger(e);
}
private void processMouseClicked(final MouseEvent e){
if(e.getClickCount() != 2){ // inplace editing starts with double click
return;
}
myEditor.getInplaceEditingLayer().startInplaceEditing(e.getX(), e.getY());
}
protected boolean cancelOperation(){
if (myCurrentProcessor != null) {
if (myCurrentProcessor.cancelOperation()){
myCurrentProcessor = null;
myEditor.getLayeredPane().setCursor(Cursor.getDefaultCursor());
myEditor.getActiveDecorationLayer().removeFeedback();
return true;
}
}
else if (PaletteToolWindowManager.getInstance(myEditor).getActiveItem(ComponentItem.class) != null) {
cancelPaletteInsert();
return true;
}
return false;
}
void cancelPaletteInsert() {
PaletteToolWindowManager.getInstance(myEditor).clearActiveItem();
myEditor.getLayeredPane().setCursor(Cursor.getDefaultCursor());
myEditor.getActiveDecorationLayer().removeFeedback();
}
public void setInsertFeedbackEnabled(final boolean enabled) {
myInsertFeedbackEnabled = enabled;
}
public void startPasteProcessor(final ArrayList<RadComponent> componentsToPaste, final TIntArrayList xs, final TIntArrayList ys) {
removeDragger();
myEditor.hideIntentionHint();
myCurrentProcessor = new PasteProcessor(myEditor, componentsToPaste, xs, ys);
myCurrentProcessor.processMouseEvent(new MouseEvent(myEditor, MouseEvent.MOUSE_MOVED, 0, 0,
myLastMousePosition.x, myLastMousePosition.y,
1, false));
}
public void startInsertProcessor(@NotNull final ComponentItem componentToInsert, final ComponentDropLocation location) {
removeDragger();
myEditor.hideIntentionHint();
myInsertComponentProcessor.setComponentToInsert(componentToInsert);
myInsertComponentProcessor.setLastLocation(location);
myCurrentProcessor = myInsertComponentProcessor;
}
public void stopCurrentProcessor() {
myCurrentProcessor = null;
myEditor.getLayeredPane().setCursor(null);
}
public boolean isProcessorActive() {
return myCurrentProcessor != null;
}
}