Re: Delete Not working still

Hello!

I figured out my null pointer, I think...I am not using Object Scene 
correctly. I do see in my test case that the key event is still firing 
with the layer approach.... I still can't figure out why its not 
happening in my class....which is attached....

Chris

public class CanvasModel extends AbstractCanvasModel<DesignerHandle, 
Object> {
 private WidgetAction designSelect = 
ActionFactory.createSelectAction(new SelectionProviderImpl());
 private WidgetAction designDeselect = 
ActionFactory.createSelectAction(new DeselectionImpl());
 private WidgetAction designAccept = 
ActionFactory.createAcceptAction(new AcceptProviderImpl());
 private WidgetAction designMove;
 private WidgetAction designResize;
 private WidgetAction designDeleteAction = new KeyEventLoggerAction();
 private LayerWidget backgroundLayer;
 private LayerWidget componentLayer;
 private LayerWidget interactionLayer;

 /** Creates a new instance of CanvasModel */
 public CanvasModel() {
   init();
 }

 private void init() {
   // Furthest back
   backgroundLayer = new LayerWidget(this);
   // components sit there.
   componentLayer = new LayerWidget(this);
   // moves occur here
   interactionLayer = new LayerWidget(this);
  
//    setMaximumBounds(new Rectangle(0, 0, Integer.MAX_VALUE, 
Integer.MAX_VALUE));
//
   setKeyEventProcessingType 
(EventProcessingType.FOCUSED_WIDGET_AND_ITS_PARENTS);
  
   addChild(backgroundLayer);
   addChild(componentLayer);
   addChild(interactionLayer);
 
   getActions().addAction(designAccept);
//    getActions().addAction(designDeselect);
//    
getActions().addAction(ActionFactory.createPopupMenuAction(createPopupMenuProvider()));
  
   designResize = ActionFactory.createAlignWithResizeAction 
(componentLayer, interactionLayer, null);
   designMove = createMoveAction();
 
 }

 protected WidgetAction createMoveAction() {
   return ActionFactory.createAlignWithMoveAction (componentLayer, 
interactionLayer, null);
 }

 protected void selectObject(Object object, boolean invertSelection) {
     if (getFocusedObject() != null) {
         findWidget(getFocusedObject()).setBorder(createDesignBorder());
     }
     
findWidget(object).setBorder(createDesignResizeBorder((DesignerHandle)object));

     setFocusedObject(object);
     if (object != null) {
         if (getSelectedObjects().contains(object))
             return;
         userSelectionSuggested(Collections.singleton(object), 
invertSelection);
     } else
         userSelectionSuggested(Collections.emptySet(), invertSelection);

 }

 protected Widget attachNodeWidget(DesignerHandle handle) {
   final ComponentWidget des = new 
ComponentWidget(this,handle.getRuntimeComponent().getViewDelegate().getComponent());
   componentLayer.addChild(des);
   des.setBorder(createDesignBorder());
   des.getActions().addAction(designDeleteAction);
   des.getActions().addAction(designSelect);
//    des.getActions().addAction(designResize);
//    des.getActions().addAction(designMove);
//    attachDesignActions(des, handle);
   return des;
 }

 protected Widget attachEdgeWidget(Object edge) {
     return null;
 }

 protected void attachEdgeSourceAnchor(Object edge, DesignerHandle 
source, DesignerHandle target) {
 }

 protected void attachEdgeTargetAnchor(Object edge, DesignerHandle 
source, DesignerHandle target) {
 }

 public static final int BORDER_SIZE = 5;

 public Border createDesignResizeBorder(DesignerHandle dh) {
   return BorderFactory.createResizeBorder(BORDER_SIZE);
 }

 public Border createDesignBorder() {
     return CanvasBorderFactory.BORDER_SHADOW_NORMAL;
 }

 private class SelectionProviderImpl implements SelectProvider {

   public boolean isAimingAllowed(Widget widget, Point localLocation, 
boolean invertSelection) {
       return false;
   }

   public boolean isSelectionAllowed(Widget widget, Point 
localLocation, boolean invertSelection) {
//        Object object = findObject(widget);
//        return object != null  &&  (invertSelection  ||  ! 
getSelectedObjects().contains(object));
     return true;
   }

   public void select(Widget widget, Point localLocation, boolean 
invertSelection) {
//        Object object = findObject(widget);
//        selectObject(object, invertSelection);
//
       setFocusedWidget(widget);
   }

 }

 private class AcceptProviderImpl implements AcceptProvider {
   public ConnectorState isAcceptable(Widget widget, Point point, 
Transferable transferable) {
     if ( 
transferable.isDataFlavorSupported(PaletteTransferable.FLAVOUR)) {
       return ConnectorState.ACCEPT;
     }
     else
       return ConnectorState.REJECT;
   }

   public void accept(Widget widget, Point point, Transferable 
transferable) {
     try {
       final DesignerHandle handle = 
(DesignerHandle)transferable.getTransferData(PaletteTransferable.FLAVOUR);
       Widget wid = addNode(handle);
       wid.setPreferredLocation(point);

       Dimension dim = handle.getComponentDataBean().getPreferredSize();
       if ( dim == null ) {
         dim = 
handle.getRuntimeComponent().getViewDelegate().getComponent().getPreferredSize();
       }
       //TODO P3 - 10 is magic number, based on the border around the 
widget.
       wid.setPreferredSize(new Dimension(dim.width + 10, dim.height + 
10));
       onAccept(handle);
     } catch (UnsupportedFlavorException ex) {
       ex.printStackTrace();
     } catch (IOException ex) {
       ex.printStackTrace();
     }
   }
  
 }

 private class CPResolver implements ResizeControlPointResolver {
   private ResizeControlPointResolver original = 
ActionFactory.createDefaultResizeControlPointResolver();

   public ResizeProvider.ControlPoint resolveControlPoint(Widget 
widget, Point point) {
     ResizeProvider.ControlPoint ret = 
original.resolveControlPoint(widget, point);
     if (ret == null) {
         return ret;
     }
     Object obj = CanvasModel.this.findObject(widget);
     if (obj != null) {
         DesignerHandle wr = (DesignerHandle)obj;
         int dirs = 
wr.getComponentDataBean().getResizeDirections();               
         if ((dirs & ComponentDataBean.RESIZE_HORIZONTAL) == 0) {
             if (ret == ResizeProvider.ControlPoint.CENTER_LEFT ||
                 ret == ResizeProvider.ControlPoint.CENTER_RIGHT) {
                 return null;
             }
             if (ret == ResizeProvider.ControlPoint.TOP_LEFT || ret == 
ResizeProvider.ControlPoint.TOP_RIGHT) {
                 ret =  ResizeProvider.ControlPoint.TOP_CENTER;
             }
             if (ret == ResizeProvider.ControlPoint.BOTTOM_RIGHT || ret 
== ResizeProvider.ControlPoint.BOTTOM_LEFT) {
                 ret = ResizeProvider.ControlPoint.BOTTOM_CENTER;
             }
         }
         if ((dirs & ComponentDataBean.RESIZE_VERTICAL) == 0) {
             if (ret == ResizeProvider.ControlPoint.TOP_CENTER ||
                 ret == ResizeProvider.ControlPoint.BOTTOM_CENTER) {
                 return null;
             }
             if (ret == ResizeProvider.ControlPoint.TOP_LEFT || ret == 
ResizeProvider.ControlPoint.BOTTOM_LEFT) {
                 ret = ResizeProvider.ControlPoint.CENTER_LEFT;
             }
             if (ret == ResizeProvider.ControlPoint.TOP_RIGHT || ret == 
ResizeProvider.ControlPoint.BOTTOM_RIGHT) {
                 ret = ResizeProvider.ControlPoint.CENTER_RIGHT;
             }
         }
     }
     return ret;
   }
 }
 private class AlignCollector implements AlignWithWidgetCollector {
   private boolean resize;
   public AlignCollector(boolean res) {
       resize = res;
   }

   public Collection<Rectangle> getRegions(Widget widget) {
       Collection<Rectangle> toRet = new ArrayList<Rectangle>();
       for (DesignerHandle dh : CanvasModel.this.getNodes()) {
           Widget wid = findWidget(dh);
           if (wid != widget) {
               toRet.add(wid.convertLocalToScene(wid.getBounds()));
           } else if (resize) {
               Point loc = wid.getLocation();
               Dimension size = 
dh.getComponentDataBean().getPreferredSize();
               if (size == null) {
                   size = wid.getPreferredSize();
               }
               //magic because of borders..
               Rectangle r = new Rectangle (loc.x - BORDER_SIZE, loc.y 
- BORDER_SIZE, size.width + BORDER_SIZE * 2, size.height + BORDER_SIZE * 2);
               toRet.add(r);
           }
       }
       //somewhat hack, would be more happy with Integer.MAX_VALUE but 
that one freaks out the view.
       toRet.add(new Rectangle(0, 0, 0, 10000));
       toRet.add(new Rectangle(0, 0, 10000, 0));
       return toRet;
   }
 }
 private class KeyEventLoggerAction extends WidgetAction.Adapter {

   public State keyPressed(Widget widget, WidgetKeyEvent event) {
     return State.REJECTED;
   }

   public State keyTyped(Widget widget, WidgetKeyEvent event) {
     return State.REJECTED;
   }

   public State keyReleased(Widget widget, WidgetKeyEvent event) {
     if (event.getKeyCode() == KeyEvent.VK_DELETE) {
         DesignerHandle handle = 
(DesignerHandle)CanvasModel.this.findObject(widget);
         if (handle == null) {
             return State.REJECTED;
         }
         if ( JOptionPane.OK_OPTION == 
JOptionPane.showConfirmDialog(null,"Are you sure you want to remove the 
widget?")) {
           CanvasModel.this.removeNode(handle);
         }
         return State.CONSUMED;
     };
     return State.REJECTED;
   }

 }

 private class DeselectionImpl implements SelectProvider {

   public boolean isAimingAllowed(Widget widget, Point localLocation, 
boolean invertSelection) {
     return false;
   }

   public boolean isSelectionAllowed(Widget widget, Point 
localLocation, boolean invertSelection) {
     if (widget == CanvasModel.this) {
       return true;
     }
     return false;
   }

   public void select(Widget widget, Point localLocation, boolean 
invertSelection) {
     if (widget == CanvasModel.this) {
       if (getFocusedObject() != null) {
           findWidget(getFocusedObject()).setBorder(createDesignBorder());
       }
       setFocusedObject(null);
       userSelectionSuggested(Collections.emptySet(), false);
     }
   }

 }
}



Chris Palmer wrote:

> Hello!
>
> I reworked the EnterKeyProcessingTest to try and match a similiar 
> implementation that I have.  I got a null pointer.
>
> Thats besides the fact. With a basic scene and no layer widgets I was 
> able to get the a delete to work. I used EnterKeyProcessingTest a 
> base. But then I realized that the EnterKeyProcessingTest wasn't using 
> layer widgets.
> So this is my attempt at reproducing my impl.
>
>
> Chris
>
>
> package test.keyboard;
>
> import java.awt.Point;
> import java.awt.event.KeyEvent;
> import org.netbeans.api.visual.action.ActionFactory;
> import org.netbeans.api.visual.action.SelectProvider;
> import org.netbeans.api.visual.action.TextFieldInplaceEditor;
> import org.netbeans.api.visual.action.WidgetAction;
> import org.netbeans.api.visual.action.WidgetAction.State;
> import org.netbeans.api.visual.layout.LayoutFactory;
> import org.netbeans.api.visual.model.ObjectScene;
> import org.netbeans.api.visual.widget.EventProcessingType;
> import org.netbeans.api.visual.widget.LabelWidget;
> import org.netbeans.api.visual.widget.LayerWidget;
> import org.netbeans.api.visual.widget.Scene;
> import org.netbeans.api.visual.widget.Widget;
> import test.SceneSupport;
>
> /**
> * @author David Kaspar
> */
> public class EnterKeyProcessingTest {
>    private static WidgetAction deleteAction = new KeyEventLoggerAction();
>    public static void main(String[] args) {
>        ObjectScene scene = new ObjectScene();
>              LayerWidget main = new LayerWidget(scene);
>        LayerWidget interaction = new LayerWidget(scene);
>        scene.addChild(main);
>        scene.addChild(interaction);
>        main.setLayout(LayoutFactory.createVerticalFlowLayout());
> //        scene.setLayout(LayoutFactory.createVerticalFlowLayout ());
>              LabelWidget label1 = new LabelWidget(scene, "First 
> non-editable label. Should not receive any key event.");
>        label1.getActions().addAction(deleteAction);
>        
> label1.getActions().addAction(ActionFactory.createSelectAction(new 
> KeySelectProvider()));
>        main.addChild(label1);
>              LabelWidget label2 = new LabelWidget(scene, "Second 
> editable label.");
>        label2.getActions().addAction(deleteAction);
>        
> label2.getActions().addAction(ActionFactory.createSelectAction(new 
> KeySelectProvider()));
>        main.addChild(label2);
>              LabelWidget label3 = new LabelWidget(scene, "Third 
> non-editable label. Should not receive any key event.");
>        label3.getActions().addAction(deleteAction);
>        
> label3.getActions().addAction(ActionFactory.createSelectAction(new 
> KeySelectProvider()));
>        main.addChild(label3);
>              
> scene.setKeyEventProcessingType(EventProcessingType.FOCUSED_WIDGET_AND_ITS_CHILDREN); 
>
> //        scene.setFocusedWidget (label2);
>              SceneSupport.show(scene);
>    }
>      private static class KeySelectProvider implements SelectProvider {
>          public boolean isAimingAllowed(Widget widget, Point 
> localLocation, boolean invertSelection) {
>        return false;
>      }
>
>      public boolean isSelectionAllowed(Widget widget, Point 
> localLocation, boolean invertSelection) {
>        return true;
>      }
>
>      public void select(Widget widget, Point localLocation, boolean 
> invertSelection) {
>        Scene scene = widget.getScene();
>        scene.setFocusedWidget(widget);
>      }
>        }
>    private static class KeyEventLoggerAction extends 
> WidgetAction.Adapter {
>              public State keyPressed(Widget widget, WidgetKeyEvent 
> event) {
>            System.out.println("KeyPressed at " + ((LabelWidget) 
> widget).getLabel());
>            return State.REJECTED;
>        }
>              public State keyReleased(Widget widget, WidgetKeyEvent 
> event) {
>          if (event.getKeyCode() == KeyEvent.VK_DELETE) {
>            System.out.println("KeyReleased at " + ((LabelWidget) 
> widget).getLabel());
>            final Scene scene = widget.getScene();
>            scene.removeChild(widget);
>            return State.CONSUMED;
>          }
>          return State.REJECTED;
>        }
>              public State keyTyped(Widget widget, WidgetKeyEvent event) {
>            System.out.println("KeyTyped at " + ((LabelWidget) 
> widget).getLabel());
>            return State.REJECTED;
>        }
>          }
>      private static class LabelEditor implements TextFieldInplaceEditor {
>              public boolean isEnabled(Widget widget) {
>            return true;
>        }
>
>        public String getText(Widget widget) {
>            return ((LabelWidget) widget).getLabel();
>        }
>              public void setText(Widget widget, String text) {
>            ((LabelWidget) widget).setLabel(text);
>        }
>          }
>   }
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: 
> users-unsubscribe-Hi7mZnf3vbIkiw2pgZvNdR2eb7JE58TQ@xxxxxxxxxxxxxxxx
> For additional commands, e-mail: 
> users-help-Hi7mZnf3vbIkiw2pgZvNdR2eb7JE58TQ@xxxxxxxxxxxxxxxx