home *** CD-ROM | disk | FTP | other *** search
/ S283 Planetary Science &… the Search for Life CD 3 / 0_CD-ROM.iso / install / jre1_3 / lib / rt.jar / sun / awt / windows / WDropTargetContextPeer.class (.txt) < prev    next >
Encoding:
Java Class File  |  1979-12-31  |  13.9 KB  |  930 lines
  1. package sun.awt.windows;
  2.  
  3. import java.awt.AWTPermission;
  4. import java.awt.Component;
  5. import java.awt.Container;
  6. import java.awt.Insets;
  7. import java.awt.Point;
  8. import java.awt.datatransfer.DataFlavor;
  9. import java.awt.datatransfer.Transferable;
  10. import java.awt.datatransfer.UnsupportedFlavorException;
  11. import java.awt.dnd.DropTarget;
  12. import java.awt.dnd.DropTargetContext;
  13. import java.awt.dnd.DropTargetDragEvent;
  14. import java.awt.dnd.DropTargetDropEvent;
  15. import java.awt.dnd.DropTargetEvent;
  16. import java.awt.dnd.InvalidDnDOperationException;
  17. import java.awt.dnd.peer.DropTargetContextPeer;
  18. import java.io.ByteArrayInputStream;
  19. import java.io.ByteArrayOutputStream;
  20. import java.io.FileInputStream;
  21. import java.io.IOException;
  22. import java.io.InputStream;
  23. import java.io.ObjectInputStream;
  24. import java.lang.reflect.Constructor;
  25. import java.lang.reflect.Modifier;
  26. import java.rmi.MarshalledObject;
  27. import java.security.AccessControlContext;
  28. import java.security.AccessController;
  29. import java.util.Arrays;
  30. import java.util.List;
  31. import java.util.Map;
  32. import sun.awt.Mutex;
  33. import sun.awt.SunToolkit;
  34.  
  35. final class WDropTargetContextPeer implements DropTargetContextPeer, Transferable, Runnable {
  36.    private static final int DISPATCH_NONE = 0;
  37.    private static final int DISPATCH_ENTER = 1;
  38.    private static final int DISPATCH_MOTION = 2;
  39.    private static final int DISPATCH_CHANGED = 3;
  40.    private static final int DISPATCH_EXIT = 4;
  41.    private static final int DISPATCH_DROP = 5;
  42.    private static final Object _globalLock = new Object();
  43.    private static Transferable currentJVMLocalSourceTransferable = null;
  44.    private static AccessControlContext currentJVMLocalSourceACtxt = null;
  45.    static final int STATUS_NONE = 0;
  46.    static final int STATUS_WAIT = 1;
  47.    static final int STATUS_ACCEPT = 2;
  48.    static final int STATUS_REJECT = -1;
  49.    private static WDropTargetContextPeer dropTargetContextPeer;
  50.    private Component currentC;
  51.    private DropTarget currentDT;
  52.    private DropTargetContext currentDTC;
  53.    private String[] currentT;
  54.    private int currentA;
  55.    private int currentDA;
  56.    private int nativeDragContext;
  57.    private Transferable local;
  58.    private int messagePending = 0;
  59.    private Component currentNC;
  60.    private int currentX;
  61.    private int currentY;
  62.    private int currentSA;
  63.    int dropStatus = 0;
  64.    boolean dropComplete = false;
  65.    Object lock = new Object();
  66.    Mutex syncLock = new Mutex();
  67.    // $FF: synthetic field
  68.    static Class class$java$io$InputStream;
  69.    // $FF: synthetic field
  70.    static Class class$java$lang$String;
  71.  
  72.    static void setCurrentJVMLocalSourceTransferable(Transferable var0) throws InvalidDnDOperationException {
  73.       Object var1 = _globalLock;
  74.       synchronized(var1) {
  75.          if (var0 != null && currentJVMLocalSourceTransferable != null) {
  76.             throw new InvalidDnDOperationException();
  77.          } else {
  78.             currentJVMLocalSourceTransferable = var0;
  79.             currentJVMLocalSourceACtxt = var0 != null ? AccessController.getContext() : null;
  80.          }
  81.       }
  82.    }
  83.  
  84.    static Transferable getJVMLocalSourceTransferable() {
  85.       Object var0 = null;
  86.       Object var1 = _globalLock;
  87.       synchronized(var1) {
  88.          if (currentJVMLocalSourceTransferable != null && !currentJVMLocalSourceACtxt.equals(AccessController.getContext())) {
  89.             AccessController.checkPermission(new AWTPermission("acceptDropBetweenAccessControllerContexts"));
  90.          }
  91.  
  92.          Transferable var4 = currentJVMLocalSourceTransferable;
  93.          return var4;
  94.       }
  95.    }
  96.  
  97.    static WDropTargetContextPeer getWDropTargetContextPeer() {
  98.       Object var0 = _globalLock;
  99.       synchronized(var0) {
  100.          dropTargetContextPeer = new WDropTargetContextPeer();
  101.       }
  102.  
  103.       return dropTargetContextPeer;
  104.    }
  105.  
  106.    private static ByteArrayInputStream getMemoryStream(byte[] var0, String var1) {
  107.       return new ByteArrayInputStream(var0);
  108.    }
  109.  
  110.    private static FileInputStream getFileStream(String var0, String var1, int var2) throws IOException {
  111.       return new WDropTargetContextPeerFileStream(var0, var1, var2);
  112.    }
  113.  
  114.    private static Object getIStream(int var0, String var1) throws IOException {
  115.       return new WDropTargetContextPeerIStream(var0, var1);
  116.    }
  117.  
  118.    private static List getList(Object[] var0) {
  119.       return Arrays.asList(var0);
  120.    }
  121.  
  122.    public DropTarget getDropTarget() {
  123.       Object var1 = this.lock;
  124.       synchronized(var1) {
  125.          DropTarget var2 = this.currentDT;
  126.          return var2;
  127.       }
  128.    }
  129.  
  130.    public void setTargetActions(int var1) {
  131.       Object var2 = this.lock;
  132.       synchronized(var2) {
  133.          this.currentA = var1 & 1073741827;
  134.       }
  135.    }
  136.  
  137.    public int getTargetActions() {
  138.       Object var1 = this.lock;
  139.       synchronized(var1) {
  140.          int var2 = this.currentA;
  141.          return var2;
  142.       }
  143.    }
  144.  
  145.    public void setAutoscrollInsets(Insets var1) {
  146.    }
  147.  
  148.    public void setAutoscrollDelay(int var1) {
  149.    }
  150.  
  151.    public boolean doesPlatformImplementAutoscrolling() {
  152.       return false;
  153.    }
  154.  
  155.    public Transferable getTransferable() {
  156.       return this;
  157.    }
  158.  
  159.    public DataFlavor[] getTransferDataFlavors() {
  160.       DataFlavor[] var1;
  161.       if (this.local != null) {
  162.          var1 = this.local.getTransferDataFlavors();
  163.       } else {
  164.          Object var2 = this.lock;
  165.          synchronized(var2) {
  166.             Object[] var3 = this.currentDT.getFlavorMap().getFlavorsForNatives(this.currentT).values().toArray();
  167.             var1 = new DataFlavor[var3.length];
  168.             System.arraycopy(var3, 0, var1, 0, var3.length);
  169.          }
  170.       }
  171.  
  172.       return var1;
  173.    }
  174.  
  175.    public boolean isDataFlavorSupported(DataFlavor var1) {
  176.       if (this.local != null) {
  177.          return this.local.isDataFlavorSupported(var1);
  178.       } else {
  179.          DataFlavor[] var2 = this.getTransferDataFlavors();
  180.  
  181.          for(int var3 = 0; var3 < var2.length; ++var3) {
  182.             if (var2[var3].equals(var1)) {
  183.                return true;
  184.             }
  185.          }
  186.  
  187.          return false;
  188.       }
  189.    }
  190.  
  191.    public Object getTransferData(DataFlavor var1) throws UnsupportedFlavorException, IOException, InvalidDnDOperationException {
  192.       if (this.local != null) {
  193.          return this.local.getTransferData(var1);
  194.       } else {
  195.          Object var2 = null;
  196.          Object var3 = this.lock;
  197.          String var16;
  198.          synchronized(var3) {
  199.             if (this.dropStatus != 2 || this.dropComplete) {
  200.                throw new InvalidDnDOperationException("No drop current");
  201.             }
  202.  
  203.             Map var4 = this.currentDT.getFlavorMap().getNativesForFlavors(new DataFlavor[]{var1});
  204.             if ((var16 = (String)var4.get(var1)) == null) {
  205.                throw new UnsupportedFlavorException(var1);
  206.             }
  207.  
  208.             int var5;
  209.             for(var5 = 0; var5 < this.currentT.length && !this.currentT[var5].equals(var16); ++var5) {
  210.             }
  211.  
  212.             if (var5 == this.currentT.length) {
  213.                throw new UnsupportedFlavorException(var1);
  214.             }
  215.          }
  216.  
  217.          Object var17 = this.getData(this.nativeDragContext, var16);
  218.          if (var17 == null) {
  219.             throw new IOException("no native data was transferred");
  220.          } else if (var17 instanceof List) {
  221.             return var17;
  222.          } else if (var1.isRepresentationClassInputStream()) {
  223.             Class var21 = var1.getRepresentationClass();
  224.             if ((class$java$io$InputStream == null ? (class$java$io$InputStream = class$("java.io.InputStream")) : class$java$io$InputStream).equals(var21)) {
  225.                return (InputStream)var17;
  226.             } else {
  227.                Object var24 = null;
  228.  
  229.                try {
  230.                   var25 = (Constructor[])AccessController.doPrivileged(new 1(this, var21));
  231.                } catch (SecurityException var11) {
  232.                   ((Throwable)var11).printStackTrace();
  233.                   throw new IOException(((Throwable)var11).getMessage());
  234.                }
  235.  
  236.                Constructor var27 = null;
  237.  
  238.                for(int var28 = 0; var28 < var25.length; ++var28) {
  239.                   if (Modifier.isPublic(var25[var28].getModifiers())) {
  240.                      Class[] var9 = var25[var28].getParameterTypes();
  241.                      if (var9 != null && var9.length == 1 && (class$java$io$InputStream == null ? (class$java$io$InputStream = class$("java.io.InputStream")) : class$java$io$InputStream).equals(var9[0])) {
  242.                         var27 = var25[var28];
  243.                         break;
  244.                      }
  245.                   }
  246.                }
  247.  
  248.                if (var27 == null) {
  249.                   throw new InvalidDnDOperationException("cant find <init>(Ljava/io/InputStream;)V for class: " + var21.getName());
  250.                } else {
  251.                   try {
  252.                      return var27.newInstance((InputStream)var17);
  253.                   } catch (Exception var10) {
  254.                      ((Throwable)var10).printStackTrace();
  255.                      throw new InvalidDnDOperationException(((Throwable)var10).getMessage());
  256.                   }
  257.                }
  258.             }
  259.          } else if (var1.isRepresentationClassRemote()) {
  260.             if (this.currentDA != 1073741824) {
  261.                throw new InvalidDnDOperationException("only ACTION_LINK is permissable for transfer java.rmi.Remote objects");
  262.             } else {
  263.                try {
  264.                   InputStream var20 = (InputStream)var17;
  265.                   Object var23 = ((MarshalledObject)(new ObjectInputStream(var20)).readObject()).get();
  266.                   var20.close();
  267.                   return var23;
  268.                } catch (Exception var12) {
  269.                   ((Throwable)var12).printStackTrace();
  270.                   throw new InvalidDnDOperationException(((Throwable)var12).getMessage());
  271.                }
  272.             }
  273.          } else if (var1.isRepresentationClassSerializable()) {
  274.             try {
  275.                InputStream var19 = (InputStream)var17;
  276.                Object var22 = (new ObjectInputStream(var19)).readObject();
  277.                var19.close();
  278.                return var22;
  279.             } catch (Exception var13) {
  280.                ((Throwable)var13).printStackTrace();
  281.                throw new InvalidDnDOperationException(((Throwable)var13).getMessage());
  282.             }
  283.          } else if ((class$java$lang$String == null ? (class$java$lang$String = class$("java.lang.String")) : class$java$lang$String).equals(var1.getRepresentationClass())) {
  284.             try {
  285.                InputStream var18 = (InputStream)var17;
  286.                ByteArrayOutputStream var6 = new ByteArrayOutputStream();
  287.                int var7 = 0;
  288.                byte[] var8 = new byte[64];
  289.  
  290.                while((var7 = var18.read(var8)) != -1) {
  291.                   var6.write(var8, 0, var7);
  292.                }
  293.  
  294.                return new String(var6.toByteArray());
  295.             } catch (Exception var14) {
  296.                ((Throwable)var14).printStackTrace();
  297.                throw new InvalidDnDOperationException(((Throwable)var14).getMessage());
  298.             }
  299.          } else {
  300.             throw new IOException("getTransferData() failed");
  301.          }
  302.       }
  303.    }
  304.  
  305.    public boolean isTransferableJVMLocal() {
  306.       return this.local != null || getJVMLocalSourceTransferable() != null;
  307.    }
  308.  
  309.    public void run() {
  310.       this.syncLock.lock();
  311.       int var1 = this.messagePending;
  312.       this.syncLock.unlock();
  313.       switch (var1) {
  314.          case 1:
  315.             this.processEnterMessage();
  316.             break;
  317.          case 2:
  318.          case 3:
  319.             this.processMotionMessage(var1);
  320.             break;
  321.          case 4:
  322.             this.processExitMessage();
  323.             break;
  324.          case 5:
  325.             this.processDropMessage();
  326.             return;
  327.       }
  328.  
  329.       this.syncLock.lock();
  330.       if (this.messagePending != 0) {
  331.          this.messagePending = 0;
  332.          WToolkit.quitSecondaryEventLoop();
  333.       }
  334.  
  335.       this.syncLock.unlock();
  336.    }
  337.  
  338.    private int handleEnterMessage(Component var1, int var2, int var3, int var4, int var5, String[] var6, int var7) {
  339.       this.syncLock.lock();
  340.  
  341.       while(this.messagePending != 0) {
  342.          this.syncLock.unlock();
  343.          WToolkit.startSecondaryEventLoop();
  344.          this.syncLock.lock();
  345.       }
  346.  
  347.       this.nativeDragContext = var7;
  348.       this.currentNC = var1;
  349.       this.currentT = var6;
  350.       this.currentX = var2;
  351.       this.currentY = var3;
  352.       this.currentSA = var5;
  353.       this.currentDA = var4;
  354.       this.messagePending = 1;
  355.       SunToolkit.executeOnEventHandlerThread(var1, this);
  356.  
  357.       while(this.messagePending != 0) {
  358.          this.syncLock.unlock();
  359.          WToolkit.startSecondaryEventLoop();
  360.          this.syncLock.lock();
  361.       }
  362.  
  363.       int var8 = this.currentA;
  364.       this.syncLock.unlock();
  365.       return var8;
  366.    }
  367.  
  368.    private void processEnterMessage() {
  369.       DropTarget var2 = null;
  370.       Point var4 = null;
  371.       this.local = getJVMLocalSourceTransferable();
  372.       Object var5 = this.currentNC.getTreeLock();
  373.       Component var1;
  374.       boolean var3;
  375.       synchronized(var5) {
  376.          try {
  377.             var1 = this.findComponentAt((Container)this.currentNC, this.currentX, this.currentY);
  378.          } catch (ClassCastException var17) {
  379.             var1 = this.currentNC.locate(this.currentX, this.currentY);
  380.          }
  381.  
  382.          var3 = var1 != null && var1.isShowing() && (var2 = var1.getDropTarget()) != null && var2.isActive();
  383.          if (var3) {
  384.             var4 = this.translate(this.currentNC, this.currentX, this.currentY, var1);
  385.          }
  386.       }
  387.  
  388.       Object var6 = this.lock;
  389.       synchronized(var6) {
  390.          if (this.currentDTC != null) {
  391.             this.currentDTC.removeNotify();
  392.             this.currentDTC = null;
  393.          }
  394.       }
  395.  
  396.       if (var3) {
  397.          Object var8 = this.lock;
  398.          synchronized(var8) {
  399.             this.currentC = var1;
  400.             this.currentDT = var2;
  401.             this.currentDTC = this.currentDT.getDropTargetContext();
  402.             this.currentDTC.addNotify(this);
  403.             this.currentA = var2.getDefaultActions();
  404.          }
  405.  
  406.          try {
  407.             var2.dragEnter(new DropTargetDragEvent(this.currentDTC, var4, this.currentDA, this.currentSA));
  408.          } catch (Exception var15) {
  409.             ((Throwable)var15).printStackTrace();
  410.             Object var10 = this.lock;
  411.             synchronized(var10) {
  412.                this.currentA = 0;
  413.             }
  414.          }
  415.       } else {
  416.          Object var20 = this.lock;
  417.          synchronized(var20) {
  418.             this.currentDT = null;
  419.             this.currentDTC = null;
  420.             this.currentA = 0;
  421.          }
  422.       }
  423.  
  424.    }
  425.  
  426.    private void handleExitMessage(Component var1, int var2) {
  427.       this.syncLock.lock();
  428.  
  429.       while(this.messagePending != 0) {
  430.          this.syncLock.unlock();
  431.          WToolkit.startSecondaryEventLoop();
  432.          this.syncLock.lock();
  433.       }
  434.  
  435.       this.nativeDragContext = var2;
  436.       this.messagePending = 4;
  437.       SunToolkit.executeOnEventHandlerThread(var1, this);
  438.  
  439.       while(this.messagePending != 0) {
  440.          this.syncLock.unlock();
  441.          WToolkit.startSecondaryEventLoop();
  442.          this.syncLock.lock();
  443.       }
  444.  
  445.       this.syncLock.unlock();
  446.    }
  447.  
  448.    private void processExitMessage() {
  449.       DropTarget var1 = null;
  450.       DropTargetContext var2 = null;
  451.       Object var3 = this.lock;
  452.       synchronized(var3) {
  453.          if (this.currentC != null) {
  454.             DropTarget var4 = this.currentC.getDropTarget();
  455.             if (var4 == null) {
  456.                this.currentC = null;
  457.                this.currentDT = null;
  458.                this.currentT = null;
  459.                if (this.currentDTC != null) {
  460.                   this.currentDTC.removeNotify();
  461.                }
  462.  
  463.                this.currentDTC = null;
  464.                return;
  465.             }
  466.  
  467.             if (var4 != this.currentDT) {
  468.                if (this.currentDTC != null) {
  469.                   this.currentDTC.removeNotify();
  470.                }
  471.  
  472.                var1 = this.currentDT = var4;
  473.                var2 = this.currentDTC = var4.getDropTargetContext();
  474.                this.currentDTC.addNotify(this);
  475.             } else {
  476.                var1 = this.currentDT;
  477.                var2 = this.currentDTC;
  478.             }
  479.          }
  480.       }
  481.  
  482.       if (var1 != null && var1.isActive()) {
  483.          try {
  484.             var1.dragExit(new DropTargetEvent(var2));
  485.          } catch (Exception var17) {
  486.             ((Throwable)var17).printStackTrace();
  487.          } finally {
  488.             Object var8 = this.lock;
  489.             synchronized(var8) {
  490.                this.currentA = 0;
  491.                this.currentSA = 0;
  492.                this.currentDA = 0;
  493.                this.currentC = null;
  494.                this.currentDT = null;
  495.                this.currentT = null;
  496.                this.currentDTC.removeNotify();
  497.                this.currentDTC = null;
  498.                this.local = null;
  499.             }
  500.          }
  501.       }
  502.  
  503.    }
  504.  
  505.    private int handleMotionMessage(Component var1, int var2, int var3, int var4, int var5, String[] var6, int var7) {
  506.       this.syncLock.lock();
  507.  
  508.       while(this.messagePending != 0) {
  509.          this.syncLock.unlock();
  510.          WToolkit.startSecondaryEventLoop();
  511.          this.syncLock.lock();
  512.       }
  513.  
  514.       this.nativeDragContext = var7;
  515.       this.currentNC = var1;
  516.       this.currentT = var6;
  517.       this.currentX = var2;
  518.       this.currentY = var3;
  519.       this.currentSA = var5;
  520.       int var8 = this.currentDA;
  521.       this.currentDA = var4;
  522.       this.messagePending = var8 == this.currentDA ? 2 : 3;
  523.       SunToolkit.executeOnEventHandlerThread(var1, this);
  524.  
  525.       while(this.messagePending != 0) {
  526.          this.syncLock.unlock();
  527.          WToolkit.startSecondaryEventLoop();
  528.          this.syncLock.lock();
  529.       }
  530.  
  531.       int var9 = this.currentA;
  532.       this.syncLock.unlock();
  533.       return var9;
  534.    }
  535.  
  536.    private void processMotionMessage(int var1) {
  537.       Component var2 = null;
  538.       Object var3 = null;
  539.       Point var4 = null;
  540.       boolean var5 = false;
  541.       boolean var6 = false;
  542.       Object var7 = null;
  543.       DropTargetContext var8 = null;
  544.       DropTarget var9 = null;
  545.       if (this.currentC != null) {
  546.          boolean var10 = false;
  547.          Object var11 = this.currentNC.getTreeLock();
  548.          Point var78;
  549.          DropTarget var79;
  550.          synchronized(var11) {
  551.             try {
  552.                var2 = this.findComponentAt((Container)this.currentNC, this.currentX, this.currentY);
  553.             } catch (ClassCastException var73) {
  554.                var2 = this.currentNC.locate(this.currentX, this.currentY);
  555.             }
  556.  
  557.             var78 = this.translate(this.currentNC, this.currentX, this.currentY, this.currentC);
  558.             var10 = this.currentC.equals(var2);
  559.             if (!var10 && var2 != null) {
  560.                var4 = this.translate(this.currentNC, this.currentX, this.currentY, var2);
  561.                var6 = var2.isShowing() && (var9 = var2.getDropTarget()) != null && var9.isActive();
  562.             }
  563.  
  564.             Object var12 = this.lock;
  565.             synchronized(var12) {
  566.                if ((var79 = this.currentC.getDropTarget()) == null) {
  567.                   this.currentDTC.removeNotify();
  568.                   this.currentC = null;
  569.                   this.currentDTC = null;
  570.                   this.currentT = null;
  571.                } else {
  572.                   if (this.currentDT != var79) {
  573.                      if (this.currentDTC != null) {
  574.                         this.currentDTC.removeNotify();
  575.                      }
  576.  
  577.                      this.currentDT = var79;
  578.                      this.currentDTC = null;
  579.                   }
  580.  
  581.                   var8 = this.currentDT.getDropTargetContext();
  582.                   if (var8 != this.currentDTC) {
  583.                      if (this.currentDTC != null) {
  584.                         this.currentDTC.removeNotify();
  585.                      }
  586.  
  587.                      (this.currentDTC = var8).addNotify(this);
  588.                   }
  589.  
  590.                   var5 = this.currentC.isShowing() && var79.isActive();
  591.                }
  592.             }
  593.          }
  594.  
  595.          if (var5) {
  596.             if (var10) {
  597.                try {
  598.                   if (var1 == 2) {
  599.                      var79.dragOver(new DropTargetDragEvent(var8, var78, this.currentDA, this.currentSA));
  600.                   } else {
  601.                      var79.dropActionChanged(new DropTargetDragEvent(var8, var78, this.currentDA, this.currentSA));
  602.                   }
  603.                } catch (Exception var64) {
  604.                   ((Throwable)var64).printStackTrace();
  605.                   Object var13 = this.lock;
  606.                   synchronized(var13) {
  607.                      this.currentA = 0;
  608.                   }
  609.                } finally {
  610.                   return;
  611.                }
  612.  
  613.                return;
  614.             }
  615.  
  616.             try {
  617.                var79.dragExit(new DropTargetEvent(var8));
  618.             } catch (Exception var71) {
  619.                ((Throwable)var71).printStackTrace();
  620.             } finally {
  621.                Object var17 = this.lock;
  622.                synchronized(var17) {
  623.                   this.currentDTC.removeNotify();
  624.                   this.currentDTC = null;
  625.                   this.currentC = null;
  626.                   this.currentT = null;
  627.                   this.currentA = 0;
  628.                }
  629.             }
  630.          } else {
  631.             Object var86 = this.lock;
  632.             synchronized(var86) {
  633.                this.currentA = 0;
  634.             }
  635.          }
  636.       }
  637.  
  638.       if (var2 == null) {
  639.          Object var83 = this.currentNC.getTreeLock();
  640.          synchronized(var83) {
  641.             try {
  642.                var2 = this.findComponentAt((Container)this.currentNC, this.currentX, this.currentY);
  643.             } catch (ClassCastException var69) {
  644.                var2 = this.currentNC.locate(this.currentX, this.currentY);
  645.             }
  646.  
  647.             var6 = var2 != null && var2.isShowing() && (var9 = var2.getDropTarget()) != null && var9.isActive();
  648.             if (var6) {
  649.                var4 = this.translate(this.currentNC, this.currentX, this.currentY, var2);
  650.             }
  651.          }
  652.       }
  653.  
  654.       if (var6) {
  655.          Object var84 = this.lock;
  656.          DropTarget var80;
  657.          synchronized(var84) {
  658.             this.currentC = var2;
  659.             var80 = this.currentDT = var9;
  660.             var8 = this.currentDTC = var9.getDropTargetContext();
  661.             this.currentDTC.addNotify(this);
  662.             this.currentA = var9.getDefaultActions();
  663.          }
  664.  
  665.          try {
  666.             var80.dragEnter(new DropTargetDragEvent(var8, var4, this.currentDA, this.currentSA));
  667.          } catch (Exception var67) {
  668.             ((Throwable)var67).printStackTrace();
  669.             Object var25 = this.lock;
  670.             synchronized(var25) {
  671.                this.currentA = 0;
  672.             }
  673.          }
  674.       } else {
  675.          Object var85 = this.lock;
  676.          synchronized(var85) {
  677.             this.currentC = null;
  678.             this.currentDT = null;
  679.             this.currentDTC = null;
  680.             this.currentA = 0;
  681.          }
  682.       }
  683.  
  684.    }
  685.  
  686.    private void handleDropMessage(Component var1, int var2, int var3, int var4, int var5, String[] var6, int var7) {
  687.       this.syncLock.lock();
  688.  
  689.       while(this.messagePending != 0) {
  690.          this.syncLock.unlock();
  691.          WToolkit.startSecondaryEventLoop();
  692.          this.syncLock.lock();
  693.       }
  694.  
  695.       this.nativeDragContext = var7;
  696.       this.currentNC = var1;
  697.       this.currentT = var6;
  698.       this.currentX = var2;
  699.       this.currentY = var3;
  700.       this.currentSA = var5;
  701.       this.currentDA = var4;
  702.       this.messagePending = 5;
  703.       SunToolkit.executeOnEventHandlerThread(var1, this);
  704.  
  705.       while(this.messagePending != 0) {
  706.          this.syncLock.unlock();
  707.          WToolkit.startSecondaryEventLoop();
  708.          this.syncLock.lock();
  709.       }
  710.  
  711.       this.syncLock.unlock();
  712.    }
  713.  
  714.    private void processDropMessage() {
  715.       Object var1 = null;
  716.       Point var2 = null;
  717.       boolean var3 = false;
  718.       DropTarget var4 = null;
  719.       Object var5 = this.currentNC.getTreeLock();
  720.       Component var35;
  721.       synchronized(var5) {
  722.          try {
  723.             var35 = this.findComponentAt((Container)this.currentNC, this.currentX, this.currentY);
  724.          } catch (ClassCastException var29) {
  725.             var35 = this.currentNC.locate(this.currentX, this.currentY);
  726.          }
  727.  
  728.          var3 = var35 != null && var35.isShowing() && (var4 = var35.getDropTarget()) != null && var4.isActive();
  729.          if (var3) {
  730.             var2 = this.translate(this.currentNC, this.currentX, this.currentY, var35);
  731.          }
  732.       }
  733.  
  734.       Object var6 = this.lock;
  735.       synchronized(var6) {
  736.          this.dropStatus = 1;
  737.          this.dropComplete = false;
  738.       }
  739.  
  740.       if (var3) {
  741.          boolean var9 = false;
  742.          Object var10 = this.lock;
  743.          DropTargetContext var8;
  744.          synchronized(var10) {
  745.             this.currentC = var35;
  746.             this.currentDT = var4;
  747.             var8 = var4.getDropTargetContext();
  748.             if (this.currentDTC != null) {
  749.                this.currentDTC.removeNotify();
  750.             }
  751.  
  752.             (this.currentDTC = var8).addNotify(this);
  753.          }
  754.  
  755.          Object var11 = _globalLock;
  756.          synchronized(var11) {
  757.             if ((this.local = getJVMLocalSourceTransferable()) != null) {
  758.                setCurrentJVMLocalSourceTransferable((Transferable)null);
  759.             }
  760.          }
  761.  
  762.          try {
  763.             var4.dragExit(new DropTargetEvent(var8));
  764.             var4.drop(new DropTargetDropEvent(var8, var2, this.currentDA, this.currentSA, this.local != null));
  765.          } catch (Exception var27) {
  766.             ((Throwable)var27).printStackTrace();
  767.             var9 = true;
  768.          } finally {
  769.             Object var15 = this.lock;
  770.             synchronized(var15) {
  771.                if (this.dropStatus == 1 || var9) {
  772.                   this.rejectDrop();
  773.                }
  774.  
  775.             }
  776.          }
  777.       } else {
  778.          this.rejectDrop();
  779.       }
  780.  
  781.    }
  782.  
  783.    public void acceptDrag(int var1) {
  784.       Object var2 = this.lock;
  785.       synchronized(var2) {
  786.          if (this.currentDT == null) {
  787.             throw new IllegalArgumentException("no drag pending");
  788.          } else {
  789.             this.currentA = this.mapOperation(this.currentDT, var1);
  790.          }
  791.       }
  792.    }
  793.  
  794.    public void rejectDrag() {
  795.       Object var1 = this.lock;
  796.       synchronized(var1) {
  797.          if (this.currentDT == null) {
  798.             throw new IllegalArgumentException("no drag pending");
  799.          } else {
  800.             this.currentA = 0;
  801.          }
  802.       }
  803.    }
  804.  
  805.    public void acceptDrop(int var1) {
  806.       if (var1 == 0) {
  807.          throw new IllegalArgumentException("invalid acceptDrop() action");
  808.       } else {
  809.          Object var2 = this.lock;
  810.          synchronized(var2) {
  811.             if (this.dropStatus != 1) {
  812.                throw new InvalidDnDOperationException("invalid acceptDrop()");
  813.             } else {
  814.                this.currentDA = this.currentA = this.mapOperation(this.currentDT, var1 & this.currentSA);
  815.                this.dropStatus = 2;
  816.                this.dropComplete = false;
  817.                this.dropDispatched();
  818.             }
  819.          }
  820.       }
  821.    }
  822.  
  823.    public void rejectDrop() {
  824.       Object var1 = this.lock;
  825.       synchronized(var1) {
  826.          if (this.dropStatus != 1) {
  827.             throw new InvalidDnDOperationException("invalid rejectDrop()");
  828.          }
  829.  
  830.          this.dropStatus = -1;
  831.       }
  832.  
  833.       this.dropComplete(false);
  834.    }
  835.  
  836.    private int mapOperation(DropTarget var1, int var2) {
  837.       int[] var3 = new int[]{2, 1, 1073741824};
  838.       int var4 = 0;
  839.  
  840.       for(int var5 = 0; var5 < var3.length; ++var5) {
  841.          if ((var2 & var3[var5]) == var3[var5]) {
  842.             var4 = var3[var5];
  843.             break;
  844.          }
  845.       }
  846.  
  847.       return var4;
  848.    }
  849.  
  850.    public void dropComplete(boolean var1) {
  851.       Object var2 = this.lock;
  852.       synchronized(var2) {
  853.          if (this.dropStatus == 0) {
  854.             throw new InvalidDnDOperationException("No Drop pending");
  855.          }
  856.  
  857.          if (this.currentDTC != null) {
  858.             this.currentDTC.removeNotify();
  859.          }
  860.  
  861.          this.currentC = null;
  862.          this.currentDT = null;
  863.          this.currentDTC = null;
  864.          this.currentT = null;
  865.          this.currentA = 0;
  866.          Object var3 = _globalLock;
  867.          synchronized(var3) {
  868.             currentJVMLocalSourceTransferable = null;
  869.          }
  870.  
  871.          this.dropStatus = 0;
  872.          this.dropComplete = true;
  873.       }
  874.  
  875.       this.dropDispatched();
  876.       this.dropDone(this.nativeDragContext, var1 ? this.currentDA : 0);
  877.       this.currentDA = 0;
  878.       this.nativeDragContext = 0;
  879.    }
  880.  
  881.    int getDropStatus() {
  882.       Object var1 = this.lock;
  883.       synchronized(var1) {
  884.          int var2 = this.dropStatus;
  885.          return var2;
  886.       }
  887.    }
  888.  
  889.    private Point translate(Component var1, int var2, int var3, Component var4) {
  890.       Object var5 = var4;
  891.       int var6 = 0;
  892.  
  893.       int var7;
  894.       for(var7 = 0; !var5.equals(var1); var5 = ((Component)var5).getParent()) {
  895.          Point var8 = ((Component)var5).getLocation();
  896.          var6 += var8.x;
  897.          var7 += var8.y;
  898.       }
  899.  
  900.       return new Point(var2 - var6, var3 - var7);
  901.    }
  902.  
  903.    private void dropDispatched() {
  904.       this.syncLock.lock();
  905.       if (this.messagePending == 5) {
  906.          this.messagePending = 0;
  907.          WToolkit.quitSecondaryEventLoop();
  908.       }
  909.  
  910.       this.syncLock.unlock();
  911.    }
  912.  
  913.    private native Object getData(int var1, String var2);
  914.  
  915.    private native void dropDone(int var1, int var2);
  916.  
  917.    private native Component findComponentAt(Container var1, int var2, int var3);
  918.  
  919.    static native void Initialize();
  920.  
  921.    // $FF: synthetic method
  922.    static Class class$(String var0) {
  923.       try {
  924.          return Class.forName(var0);
  925.       } catch (ClassNotFoundException var2) {
  926.          throw new NoClassDefFoundError(((Throwable)var2).getMessage());
  927.       }
  928.    }
  929. }
  930.