public void mouseReleased(MouseEvent e) {
   logEvent("MouseReleased", e);
   // send event to the pressedNode
   publishMouseEvent(
       e.getX(),
       e.getY(),
       EventBus.getSystem().getPressedNode(),
       org.joshy.gfx.event.MouseEvent.MouseReleased,
       e.getButton(),
       e.isShiftDown(),
       e.isAltDown(),
       e.isControlDown(),
       e.isMetaDown());
   // also send event to the top node under the cursor if it's not the pressedNode
   Node node = findTopNode(e.getX(), e.getY());
   if (node != EventBus.getSystem().getPressedNode()) {
     publishMouseEvent(
         e.getX(),
         e.getY(),
         node,
         org.joshy.gfx.event.MouseEvent.MouseReleased,
         e.getButton(),
         e.isShiftDown(),
         e.isAltDown(),
         e.isControlDown(),
         e.isMetaDown());
   }
   EventBus.getSystem().setPressedNode(null);
 }
 public void mouseMoved(MouseEvent e) {
   logEvent("MouseMoved", e);
   Node node = findTopNode(e.getX(), e.getY());
   if (node != hoverNode) {
     if (hoverNode != null) {
       Point2D point = convertSceneToNode(e.getX(), e.getY(), hoverNode);
       org.joshy.gfx.event.MouseEvent evt =
           new org.joshy.gfx.event.MouseEvent(
               org.joshy.gfx.event.MouseEvent.MouseExited,
               point.getX(),
               point.getY(),
               hoverNode,
               e.getButton(),
               e.isShiftDown(),
               e.isAltDown(),
               e.isControlDown(),
               e.isMetaDown());
       EventBus.getSystem().publish(evt);
     }
     hoverNode = node;
     if (hoverNode != null) {
       Point2D point = convertSceneToNode(e.getX(), e.getY(), hoverNode);
       org.joshy.gfx.event.MouseEvent evt =
           new org.joshy.gfx.event.MouseEvent(
               org.joshy.gfx.event.MouseEvent.MouseEntered,
               point.getX(),
               point.getY(),
               hoverNode,
               e.getButton(),
               e.isShiftDown(),
               e.isAltDown(),
               e.isControlDown(),
               e.isMetaDown());
       EventBus.getSystem().publish(evt);
     }
   }
   Point2D point = convertSceneToNode(e.getX(), e.getY(), node);
   org.joshy.gfx.event.MouseEvent evt =
       new org.joshy.gfx.event.MouseEvent(
           org.joshy.gfx.event.MouseEvent.MouseMoved,
           point.getX(),
           point.getY(),
           node,
           e.getButton(),
           e.isShiftDown(),
           e.isAltDown(),
           e.isControlDown(),
           e.isMetaDown());
   EventBus.getSystem().publish(evt);
 }
 public void mousePressed(MouseEvent e) {
   logEvent("MousePressed", e);
   Node node = findTopNode(e.getX(), e.getY());
   Point2D point = convertSceneToNode(e.getX(), e.getY(), node);
   org.joshy.gfx.event.MouseEvent evt =
       toEvent(e, point, node, org.joshy.gfx.event.MouseEvent.MousePressed);
   EventBus.getSystem().setPressedNode(node);
   EventBus.getSystem().publish(evt);
   if (evt.isControlPressed() && OSUtil.isMac() || evt.getButton() == 3 || e.isPopupTrigger()) {
     org.joshy.gfx.event.MouseEvent evt2 =
         toEvent(e, point, node, org.joshy.gfx.event.MouseEvent.OpenContextMenu);
     EventBus.getSystem().publish(evt2);
   }
 }
 public void windowClosing(WindowEvent e) {
   //        u.p("window is closing");
   EventBus.getSystem()
       .publish(
           new org.joshy.gfx.event.WindowEvent(
               org.joshy.gfx.event.WindowEvent.Closing, parent.getStage()));
 }
  public HSVColorPicker6() {
    EventBus.getSystem()
        .addListener(
            this,
            MouseEvent.MouseAll,
            new Callback<MouseEvent>() {
              public void call(MouseEvent mouseEvent) throws Exception {
                if (mouseEvent.getType() == MouseEvent.MousePressed) {
                  centerPoint = mouseEvent.getPointInNodeCoords(HSVColorPicker6.this);
                  startColor = color;
                  setDrawingDirty();
                }
                if (mouseEvent.getType() == MouseEvent.MouseDragged) {
                  double x = mouseEvent.getX() - centerPoint.getX();
                  double y = mouseEvent.getY() - centerPoint.getY();
                  float[] comps = toHSB(color);
                  float[] start = toHSB(startColor);
                  if (x > -10 && x < 10 && y > -10 && y < 10) {
                    return;
                  }
                  if (x > -5 && x < 5 && y > -100 && y < 100) {
                    double off = start[0];
                    color = FlatColor.hsb((y / 200.0 + off) * 360.0, comps[1], comps[2]);
                    setDrawingDirty();
                    return;
                  }

                  double sin = Math.sin(Math.toRadians(-30));
                  double cos = Math.cos(Math.toRadians(-30));
                  double tx = cos * x + sin * y;
                  double ty = sin * x + cos * y;
                  if (tx > -100 && tx < 100 && ty > -5 && ty < 5) {
                    double sat = (tx + 100) / 100.0;
                    sat = start[1] - (1 - sat);
                    sat = clamp(0, sat, 1);
                    color = FlatColor.hsb(comps[0] * 360, sat, comps[2]);
                    setDrawingDirty();
                    return;
                  }

                  sin = Math.sin(Math.toRadians(60));
                  cos = Math.cos(Math.toRadians(60));
                  tx = cos * x + sin * y;
                  ty = sin * x + cos * y;
                  if (tx > -5 && tx < 5 && ty > -100 && ty < 100) {
                    double bright = ty / 100.0;
                    bright = 1.0 - bright;
                    bright = start[2] - (1 - bright);
                    bright = clamp(0, bright, 1);
                    color = FlatColor.hsb(comps[0] * 360, comps[1], bright);
                    setDrawingDirty();
                    return;
                  }

                  return;
                }
              }
            });
  }
 public void setValue(double value) {
   if (value < getMin()) value = getMin();
   if (value > getMax()) value = getMax();
   if (this.value != value) {
     this.value = value;
     EventBus.getSystem().publish(new ChangedEvent(ChangedEvent.DoubleChanged, this.value, this));
     setDrawingDirty();
   }
 }
  public void mouseWheelMoved(MouseWheelEvent e) {

    Event.EventType type = ScrollEvent.ScrollVertical;
    Node node = findTopNode(e.getX(), e.getY());
    int rotation = e.getWheelRotation();
    if (e.isShiftDown()) {
      type = ScrollEvent.ScrollHorizontal;
    }
    EventBus.getSystem().publish(new ScrollEvent(type, node, rotation));
  }
 public void setSelectedFill(Paint paint) {
   this.selectedFill = paint;
   if (!locked) {
     if (paint instanceof FlatColor) {
       freerangeColorPickerPopup.setSelectedColor((FlatColor) paint);
       rgbhsvpicker.setSelectedColor((FlatColor) paint);
     }
   }
   EventBus.getSystem().publish(new ChangedEvent(ChangedEvent.ObjectChanged, selectedFill, this));
   setDrawingDirty();
 }
 protected MultiNodeAction(VectorDocContext context) {
   super(context);
   EventBus.getSystem()
       .addListener(
           Selection.SelectionChangeEvent.Changed,
           new Callback<Selection.SelectionChangeEvent>() {
             public void call(Selection.SelectionChangeEvent selectionChangeEvent)
                 throws Exception {
               setEnabled(selectionChangeEvent.getSelection().size() >= 2);
             }
           });
 }
 public GroupSelection(VectorDocContext context) {
   super();
   this.context = context;
   EventBus.getSystem()
       .addListener(
           Selection.SelectionChangeEvent.Changed,
           new Callback<Selection.SelectionChangeEvent>() {
             public void call(Selection.SelectionChangeEvent selectionChangeEvent)
                 throws Exception {
               setEnabled(selectionChangeEvent.getSelection().size() >= 2);
             }
           });
 }
 public void keyReleased(KeyEvent e) {
   Node node = Core.getShared().getFocusManager().findFocusedNode(parent);
   org.joshy.gfx.event.KeyEvent evt =
       new org.joshy.gfx.event.KeyEvent(
           org.joshy.gfx.event.KeyEvent.KeyReleased,
           org.joshy.gfx.event.KeyEvent.getKeyCodeFromAWT(e.getKeyCode()),
           node,
           e.getKeyChar(),
           e.isShiftDown(),
           e.isControlDown(),
           e.isAltDown(),
           e.isMetaDown());
   EventBus.getSystem().publish(evt);
 }
  private void setupColorTab(TabPanel panel) {
    freerangeColorPickerPopup = new FreerangeColorPickerPopup(null, 300, 170, false);
    freerangeColorPickerPopup.setOutsideColorProvider(
        new FreerangeColorPickerPopup.OutsideColorProvider() {
          @Override
          public FlatColor getColorAt(MouseEvent event) {
            if (context == null) return super.getColorAt(event);
            Point2D pt = event.getPointInNodeCoords(context.getSketchCanvas());
            pt = context.getSketchCanvas().transformToCanvas(pt.getX(), pt.getY());
            java.util.List<SNode> underCursor = new ArrayList<SNode>();
            for (SNode node : context.getDocument().getCurrentPage().getNodes()) {
              if (node.getTransformedBounds().contains(pt)) {
                underCursor.add(node);
              }
            }
            if (underCursor.isEmpty()) {
            } else {
              SNode node = underCursor.get(underCursor.size() - 1);
              if (node instanceof SShape) {
                SShape shape = ((SShape) node);
                if (shape.getFillPaint() instanceof FlatColor) {
                  return (FlatColor) shape.getFillPaint();
                }
              }
            }

            return super.getColorAt(
                event); // To change body of overridden methods use File | Settings | File
            // Templates.
          }
        });
    EventBus.getSystem()
        .addListener(
            freerangeColorPickerPopup,
            ChangedEvent.ColorChanged,
            new Callback<ChangedEvent>() {
              public void call(ChangedEvent event) throws Exception {
                locked = true;
                setSelectedFill((FlatColor) event.getValue());
                locked = false;
                if (!event.isAdjusting()) {
                  popup.setVisible(false);
                }
              }
            });
    panel.add("Color", freerangeColorPickerPopup);
  }
 @Override
 protected void setPressed(boolean pressed) {
   super.setPressed(pressed);
   if (pressed) {
     if (!popupadded) {
       Stage stage = getParent().getStage();
       stage.getPopupLayer().add(popup);
     }
     Point2D pt = NodeUtils.convertToScene(this, 0, getHeight());
     popup.setTranslateX(Math.round(Math.max(pt.getX(), 0)));
     popup.setTranslateY(Math.round(Math.max(pt.getY(), 0)));
     popup.setVisible(true);
     EventBus.getSystem().setPressedNode(popup);
   } else {
     // popup.setVisible(false);
   }
 }
 private void setupRGBTab(TabPanel panel) {
   rgbhsvpicker = new ColorPickerPanel(280, 250);
   panel.add("RGB/HSV", rgbhsvpicker);
   EventBus.getSystem()
       .addListener(
           rgbhsvpicker,
           ChangedEvent.ColorChanged,
           new Callback<ChangedEvent>() {
             public void call(ChangedEvent changedEvent) throws Exception {
               locked = true;
               setSelectedFill((FlatColor) changedEvent.getValue());
               if (!changedEvent.isAdjusting()) {
                 popup.setVisible(false);
               }
               locked = false;
             }
           });
 }
 public UngroupSelection(VectorDocContext context) {
   super();
   this.context = context;
   EventBus.getSystem()
       .addListener(
           Selection.SelectionChangeEvent.Changed,
           new Callback<Selection.SelectionChangeEvent>() {
             public void call(Selection.SelectionChangeEvent selectionChangeEvent)
                 throws Exception {
               for (SNode node : selectionChangeEvent.getSelection().items()) {
                 if (!(node instanceof SGroup)) {
                   setEnabled(false);
                   return;
                 }
               }
               setEnabled(true);
             }
           });
 }
  private TabPanel buildPanel() throws IOException {
    final TabPanel panel = new TabPanel();
    panel.setPrefWidth(300);
    panel.setPrefHeight(250);

    setupColorTab(panel);
    setupSwatchTab(panel);
    setupRGBTab(panel);
    setupGradientTab(panel);
    setupPatternTab(panel);

    // TODO: is this popup event really working?
    EventBus.getSystem()
        .addListener(
            panel,
            MouseEvent.MouseAll,
            new Callback<MouseEvent>() {
              public void call(MouseEvent event) {
                if (event.getType() == MouseEvent.MouseDragged) {
                  if (!popup.isVisible()) return;
                  Control control = panel.getSelected();
                  if (control instanceof ListView) {
                    ListView lv = (ListView) control;
                    Object item = lv.getItemAt(event.getPointInNodeCoords(lv));
                    if (item instanceof Paint) {
                      setSelectedFill((Paint) item);
                    }
                  }
                }
                if (event.getType() == MouseEvent.MouseReleased) {
                  Point2D pt = event.getPointInNodeCoords(panel);
                  pt =
                      new Point2D.Double(
                          pt.getX() + panel.getTranslateX(), pt.getY() + panel.getTranslateY());
                  if (panel.getVisualBounds().contains(pt)) {
                    popup.setVisible(false);
                  }
                }
              }
            });

    return panel;
  }
 public Scrollbar(boolean vertical) {
   this.vertical = vertical;
   if (vertical) {
     setHeight(100);
     setWidth(20);
   } else {
     setHeight(20);
     setWidth(100);
   }
   EventBus.getSystem()
       .addListener(
           this,
           MouseEvent.MouseAll,
           new Callback<MouseEvent>() {
             public void call(MouseEvent event) {
               processInput(event);
             }
           });
 }
 private void publishMouseEvent(
     int x,
     int y,
     Node node,
     Event.EventType eventType,
     int button,
     boolean shiftDown,
     boolean altDown,
     boolean controlDown,
     boolean commandDown) {
   Point2D point = convertSceneToNode(x, y, node);
   org.joshy.gfx.event.MouseEvent evt =
       new org.joshy.gfx.event.MouseEvent(
           eventType,
           point.getX(),
           point.getY(),
           node,
           button,
           shiftDown,
           altDown,
           controlDown,
           commandDown);
   EventBus.getSystem().publish(evt);
 }
  private ListView<Paint> setupGradientTab(TabPanel panel) {
    double size = 40;
    // linears
    Paint gf1 =
        new LinearGradientFill()
            .setStartX(0)
            .setStartXSnapped(Snap.Start)
            .setEndX(size)
            .setEndXSnapped(Snap.End)
            .setStartY(size / 2)
            .setStartYSnapped(Snap.Middle)
            .setEndY(size / 2)
            .setEndYSnapped(Snap.Middle)
            .addStop(0, FlatColor.BLACK)
            .addStop(1, FlatColor.WHITE);

    Paint gf2 =
        new LinearGradientFill()
            .setStartX(size / 2)
            .setStartXSnapped(Snap.Middle)
            .setEndX(size / 2)
            .setEndXSnapped(Snap.Middle)
            .setStartY(0)
            .setStartYSnapped(Snap.Start)
            .setEndY(size)
            .setEndYSnapped(Snap.End)
            .addStop(0, FlatColor.BLACK)
            .addStop(1, FlatColor.WHITE);

    Paint gf3 =
        new LinearGradientFill()
            .setStartX(0)
            .setStartXSnapped(Snap.Start)
            .setEndX(size)
            .setEndXSnapped(Snap.End)
            .setStartY(0)
            .setStartYSnapped(Snap.Start)
            .setEndY(size)
            .setEndYSnapped(Snap.End)
            .addStop(0, FlatColor.BLACK)
            .addStop(1, FlatColor.WHITE);

    // linears 2
    Paint gf6 =
        new LinearGradientFill()
            .setStartX(0)
            .setStartXSnapped(Snap.Start)
            .setStartY(size / 2)
            .setStartYSnapped(Snap.Middle)
            .setEndX(size)
            .setEndXSnapped(Snap.End)
            .setEndY(size / 2)
            .setEndYSnapped(Snap.Middle)
            .addStop(0.0, FlatColor.BLACK)
            .addStop(0.5, FlatColor.WHITE)
            .addStop(1.0, FlatColor.BLACK);

    // radials
    Paint gf4 =
        new RadialGradientFill()
            .setCenterX(size / 2)
            .setCenterY(size / 2)
            .setRadius(size / 2)
            .addStop(0, FlatColor.BLACK)
            .addStop(1, FlatColor.WHITE);

    Paint gf5 =
        new RadialGradientFill()
            .setCenterX(size / 2)
            .setCenterY(size / 2)
            .setRadius(size / 2)
            .addStop(0.0, FlatColor.BLACK)
            .addStop(0.5, FlatColor.WHITE)
            .addStop(1.0, FlatColor.BLACK);

    ListModel<Paint> gradientModel = ListView.createModel(gf1, gf2, gf3, gf6, gf4, gf5);
    final ListView<Paint> gradientList =
        new ListView<Paint>()
            .setModel(gradientModel)
            .setColumnWidth(size)
            .setRowHeight(size)
            .setOrientation(ListView.Orientation.HorizontalWrap)
            .setRenderer(paintItemRenderer);
    panel.add("gradients", gradientList);
    EventBus.getSystem()
        .addListener(
            gradientList,
            SelectionEvent.Changed,
            new Callback<SelectionEvent>() {
              public void call(SelectionEvent e) throws Exception {
                int n = e.getView().getSelectedIndex();
                setSelectedFill(gradientList.getModel().get(n));
                popup.setVisible(false);
              }
            });

    return gradientList;
  }
  private void setupSwatchTab(TabPanel panel) {
    final ListView<FlatColor> colorList = new ListView<FlatColor>();
    colorList.setModel(manager.colorManager.getSwatchModel());
    colorList.setColumnWidth(20);
    colorList.setRowHeight(20);
    colorList.setOrientation(ListView.Orientation.HorizontalWrap);
    colorList.setRenderer(
        new ListView.ItemRenderer<FlatColor>() {
          public void draw(
              GFX gfx,
              ListView listView,
              FlatColor flatColor,
              int i,
              double x,
              double y,
              double w,
              double h) {
            gfx.setPaint(flatColor);
            gfx.fillRect(x, y, w, h);
          }
        });
    EventBus.getSystem()
        .addListener(
            colorList,
            SelectionEvent.Changed,
            new Callback<SelectionEvent>() {
              public void call(SelectionEvent e) throws Exception {
                int n = e.getView().getSelectedIndex();
                setSelectedFill(colorList.getModel().get(n));
                popup.setVisible(false);
              }
            });
    final PopupMenuButton switcher = new PopupMenuButton();
    final ArrayListModel<Palette> palettes = manager.colorManager.getPalettes();
    switcher.setModel(palettes);

    Button addButton = new Button("+");
    addButton.onClicked(
        new Callback<ActionEvent>() {
          public void call(ActionEvent actionEvent) throws Exception {
            if (!palettes.get(switcher.getSelectedIndex()).isEditable()) {
              return;
            }
            final Stage dialog = Stage.createStage();
            dialog.setTitle("Color");

            final ColorPickerPanel picker = new ColorPickerPanel();

            Callback<ActionEvent> okay =
                new Callback<ActionEvent>() {
                  public void call(ActionEvent event) {
                    FlatColor color = picker.getColor();
                    manager.colorManager.addSwatch(color);
                    dialog.hide();
                  }
                };
            Callback<ActionEvent> canceled =
                new Callback<ActionEvent>() {
                  public void call(ActionEvent event) {
                    dialog.hide();
                  }
                };
            dialog.setContent(
                new VFlexBox()
                    .add(picker)
                    .add(
                        new HFlexBox()
                            .add(new Button("okay").onClicked(okay))
                            .add(new Button("cancel").onClicked(canceled))));
            dialog.setWidth(400);
            dialog.setHeight(370);
            dialog.centerOnScreen();
          }
        });

    switcher.setTextRenderer(
        new ListView.TextRenderer() {
          public String toString(SelectableControl selectableControl, Object palette, int i) {
            if (palette instanceof Palette) {
              return ((Palette) palette).getName();
            } else {
              return "foo";
            }
          }
        });

    EventBus.getSystem()
        .addListener(
            switcher,
            SelectionEvent.Changed,
            new Callback<SelectionEvent>() {
              public void call(SelectionEvent selectionEvent) throws Exception {
                int n = selectionEvent.getView().getSelectedIndex();
                manager.colorManager.setCurrentPalette(palettes.get(n));
                colorList.setModel(manager.colorManager.getSwatchModel());
              }
            });

    VFlexBox vbox = new VFlexBox();
    vbox.setFill(FlatColor.GRAY);
    vbox.add(colorList, 1);
    vbox.add(new HFlexBox().add(addButton).add(switcher));
    vbox.setBoxAlign(FlexBox.Align.Stretch);
    panel.add("Swatches", vbox);
  }
  private void setupPatternTab(TabPanel panel) throws IOException {
    double size = 40;

    final ListView<Paint> patternList =
        new ListView<Paint>()
            .setModel(manager.patternManager.getModel())
            .setColumnWidth(size)
            .setRowHeight(size)
            .setOrientation(ListView.Orientation.HorizontalWrap)
            .setRenderer(paintItemRenderer);
    EventBus.getSystem()
        .addListener(
            patternList,
            SelectionEvent.Changed,
            new Callback<SelectionEvent>() {
              public void call(SelectionEvent e) throws Exception {
                int n = e.getView().getSelectedIndex();
                setSelectedFill(patternList.getModel().get(n));
                popup.setVisible(false);
              }
            });
    Button addButton = new Button("add image");
    addButton.onClicked(
        new Callback<ActionEvent>() {
          public void call(ActionEvent actionEvent) throws Exception {
            FileDialog fd = new FileDialog((Frame) null);
            fd.setMode(FileDialog.LOAD);
            fd.setTitle("Open Pattern Image");
            fd.setVisible(true);
            if (fd.getFile() != null) {
              File file = new File(fd.getDirectory(), fd.getFile());
              u.p("opening a file" + file);
              try {
                PatternPaint pat = PatternPaint.create(file);
                manager.patternManager.addPattern(pat);
              } catch (IOException ex) {
                ex.printStackTrace();
              }
            }
          }
        });
    Button createButton = new Button("create new");
    createButton.onClicked(
        new Callback<ActionEvent>() {
          public void call(ActionEvent event) throws Exception {
            final PatternBuilder builder = new PatternBuilder();
            final Stage stage = Stage.createStage();
            Callback<ActionEvent> closeAction =
                new Callback<ActionEvent>() {
                  public void call(ActionEvent event) throws Exception {
                    PatternPaint pattern = builder.getPattern();
                    manager.patternManager.addPattern(pattern);
                    stage.hide();
                  }
                };
            Callback<ActionEvent> cancelAction =
                new Callback<ActionEvent>() {
                  public void call(ActionEvent event) throws Exception {
                    stage.hide();
                  }
                };
            stage.setContent(
                new VFlexBox()
                    .add(builder, 1)
                    .add(
                        new HFlexBox()
                            .add(new Button("cancel").onClicked(cancelAction), 0)
                            .add(new Button("save").onClicked(closeAction), 0),
                        0));
            stage.setWidth(600);
            stage.setHeight(350);
            stage.centerOnScreen();
          }
        });
    VFlexBox vbox = new VFlexBox();
    vbox.setBoxAlign(FlexBox.Align.Stretch);
    vbox.setFill(FlatColor.GRAY);
    vbox.add(patternList, 1);
    vbox.add(new HFlexBox().add(addButton).add(createButton));
    panel.add("Patterns", vbox);
  }