Java 类javax.swing.JLayeredPane 实例源码

void start(PaletteItem item, Point pt) {
    // clean up prev is necessary
    if(dragComponent != null) {
        menuEditLayer.layers.remove(dragComponent);
        dragComponent = null;
    }

    if(!menuEditLayer.doesFormContainMenuBar()) {
        //op = Op.NO_MENUBAR;
        menuEditLayer.showMenubarWarning = true;
        FormEditor.getAssistantModel(menuEditLayer.formDesigner.getFormModel()).setContext("missingMenubar"); // NOI18N
        menuEditLayer.repaint();
    }

    op = Op.PICK_AND_PLOP_FROM_PALETTE;
    started = true;
    dragComponent = createDragFeedbackComponent(null, item.getComponentClass());
    dragComponent.setSize(dragComponent.getPreferredSize());
    dragComponent.setLocation(pt);
    menuEditLayer.layers.add(dragComponent, JLayeredPane.DRAG_LAYER);
    menuEditLayer.repaint();
    currentItem = item;
    menuEditLayer.glassLayer.requestFocusInWindow();
}

private int[] computeVisibleSpan() {
    Component parent = pane.getParent();

    if (parent instanceof JLayeredPane) {
        parent = parent.getParent();
    }

    if (parent instanceof JViewport) {
        JViewport vp = (JViewport) parent;

        Point start = vp.getViewPosition();
        Dimension size = vp.getExtentSize();
        Point end = new Point((int) (start.getX() + size.getWidth()), (int) (start.getY() + size.getHeight()));

        int startPosition = pane.viewToModel(start);
        int endPosition = pane.viewToModel(end);

        if (parentWithListener != vp) {
            vp.addChangeListener(WeakListeners.change(this, vp));
            parentWithListener = vp;
        }
        return new int[] {startPosition, endPosition};
    }

    return new int[] {0, pane.getDocument().getLength()};
}

double getUsableHeight() {
    //fix for issue #54080:
    //find the scrollpane which contains the pane:
    Component scrollPaneCandidade = pane.getParent();

    if (scrollPaneCandidade instanceof JLayeredPane) {
        scrollPaneCandidade = scrollPaneCandidade.getParent();
    }

    if (scrollPaneCandidade != null && !(scrollPaneCandidade instanceof JScrollPane)) {
        scrollPaneCandidade = scrollPaneCandidade.getParent();
    }

    if (scrollPaneCandidade == null || !(scrollPaneCandidade instanceof JScrollPane) || scrollBar == null) {
        //no help for #54080:
        return getHeight() - HEIGHT_OFFSET;
    }

    JScrollPane scrollPane = (JScrollPane) scrollPaneCandidade;
    int visibleHeight = scrollPane.getViewport().getExtentSize().height;

    int topButton = topOffset();
    int bottomButton = scrollBar.bottom;

    return visibleHeight - topButton - bottomButton;
}

private void performOperation(JLayeredPane pane, Integer layer) {
    // XXX - TBD
    switch (type) {
        case SLIDE_IN:
            component.setBounds(finishBounds);
            pane.add(component, layer);
            if( isHeavyWeightShowing() ) {
                repaintLayeredPane();
            }
            break;
        case SLIDE_OUT:
            pane.remove(component);
            break;
        case SLIDE_RESIZE:
            component.setBounds(finishBounds);
            ((JComponent)component).revalidate();
            if( isHeavyWeightShowing() ) {
                repaintLayeredPane();
            }
            break;
    }
}

static ComponentBuilder getBuilder(Instance instance, Heap heap) {
    if (DetailsUtils.isSubclassOf(instance, JRootPane.class.getName())) {
        return new JRootPaneBuilder(instance, heap);
    } else if (DetailsUtils.isSubclassOf(instance, JDesktopPane.class.getName())) {
        return new JDesktopPaneBuilder(instance, heap);
    } else if (DetailsUtils.isSubclassOf(instance, JLayeredPane.class.getName())) {
        return new JLayeredPaneBuilder(instance, heap);
    } else if (DetailsUtils.isSubclassOf(instance, Frame.class.getName())) {
        return new FrameBuilder(instance, heap);
    } else if (DetailsUtils.isSubclassOf(instance, Dialog.class.getName())) {
        return new DialogBuilder(instance, heap);
    } else if (DetailsUtils.isSubclassOf(instance, JInternalFrame.class.getName())) {
        return new JInternalFrameBuilder(instance, heap);
    }
    return null;
}

private void computePopupBounds (Rectangle result, JLayeredPane lPane, int modelSize) {
    Dimension cSize = comboBar.getSize();
    int width = getPopupWidth();
    Point location = new Point(cSize.width - width - 1, comboBar.getBottomLineY() - 1);
    if (SwingUtilities.getWindowAncestor(comboBar) != null) {
        location = SwingUtilities.convertPoint(comboBar, location, lPane);
    }
    result.setLocation(location);

    // hack to make jList.getpreferredSize work correctly
    // JList is listening on ResultsModel same as us and order of listeners
    // is undefined, so we have to force update of JList's layout data
    jList1.setFixedCellHeight(15);
    jList1.setFixedCellHeight(-1);
    // end of hack

    jList1.setVisibleRowCount(modelSize);
    Dimension preferredSize = jList1.getPreferredSize();

    preferredSize.width = width;
    preferredSize.height += statusPanel.getPreferredSize().height + 3;

    result.setSize(preferredSize);
}

private void computePopupBounds (Rectangle result, JLayeredPane lPane, int modelSize) {
    Point location =
            new Point(
                comboBar.getIssueComponent().getX(),
                comboBar.getIssueComponent().getY() + comboBar.getIssueComponent().getHeight() - 1);
    location = SwingUtilities.convertPoint(comboBar, location, lPane); // XXX terrible hack! fix this
    result.setLocation(location);

    // hack to make jList.getpreferredSize work correctly
    // JList is listening on ResultsModel same as us and order of listeners
    // is undefined, so we have to force update of JList's layout data
    jList1.setFixedCellHeight(15);
    jList1.setFixedCellHeight(-1);
    // end of hack

    jList1.setVisibleRowCount(modelSize);
    Dimension preferredSize = jList1.getPreferredSize();

    preferredSize.width = comboBar.getIssueComponent().getWidth();
    preferredSize.height += statusPanel.getPreferredSize().height + 3;
    if(preferredSize.height > 150) {
        preferredSize.height = 150;
    }

    result.setSize(preferredSize);
}

/**
 * Return true if the given component is likely to be a container such the each
 * component within the container should be be considered as a user input.
 * 
 * @param c
 * @return true if the component children should have this listener added.
 */
protected boolean isProbablyAContainer (Component c) {
    boolean result = extListener != null ? extListener.isContainer(c) : false;
    if (!result) {
        boolean isSwing = isSwingClass(c);
        if (isSwing) {
           result = c instanceof JPanel || c instanceof JSplitPane || c instanceof
                   JToolBar || c instanceof JViewport || c instanceof JScrollPane ||
                   c instanceof JFrame || c instanceof JRootPane || c instanceof
                   Window || c instanceof Frame || c instanceof Dialog ||
                   c instanceof JTabbedPane || c instanceof JInternalFrame ||
                   c instanceof JDesktopPane || c instanceof JLayeredPane;
        } else {
            result = c instanceof Container;
        }
    }
    return result;
}

public JComponent getView() {
  if (theMap == null) {
    theMap = new View(this);
    scroll = new AdjustableSpeedScrollPane(
          theMap,
          JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
          JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
    scroll.unregisterKeyboardAction(KeyStroke.getKeyStroke(
          KeyEvent.VK_PAGE_DOWN, 0));
    scroll.unregisterKeyboardAction(KeyStroke.getKeyStroke(
          KeyEvent.VK_PAGE_UP, 0));

    layeredPane.setLayout(new InsetLayout(layeredPane, scroll));
    layeredPane.add(scroll, JLayeredPane.DEFAULT_LAYER);
  }
  return theMap;
}

/**
 * Expects to be added to a {@link Map}. Adds itself as a {@link
 * GameComponent} and a {@link Drawable}component
 */
public void addTo(Buildable b) {
  map = (Map) b;

  mouseOverViewer = new CounterViewer();

  GameModule.getGameModule().getGameState().addGameComponent(this);

  GameModule.getGameModule().addKeyStrokeSource(
    new KeyStrokeSource(view, JComponent.WHEN_FOCUSED));

  map.addDrawComponent(this);
  map.getToolBar().add(launch);

  if (b instanceof Translatable) {
    getI18nData().setOwningComponent((Translatable) b);
  }

  map.getLayeredPane().add(scroll, JLayeredPane.PALETTE_LAYER);
}

/**
 * creates or moves cursor object to given JLayeredPane. Usually called by setDrawWinToOwnerOf()
 */
private void setDrawWin(JLayeredPane newDrawWin) {
  if (newDrawWin != drawWin) {
    // remove cursor from old window
    if (dragCursor.getParent() != null) {
      dragCursor.getParent().remove(dragCursor);
    }
    if (drawWin != null) {
      drawWin.repaint(dragCursor.getBounds());
    }
    drawWin = newDrawWin;
    calcDrawOffset();
    dragCursor.setVisible(false);
    drawWin.add(dragCursor, JLayeredPane.DRAG_LAYER);
  }
}

/** @return the Swing component representing the map */
public JComponent getView() {
  if (theMap == null) {
    theMap = new View(this);

    scroll = new AdjustableSpeedScrollPane(
      theMap,
      JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
      JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
    scroll.unregisterKeyboardAction(
      KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_DOWN, 0));
    scroll.unregisterKeyboardAction(
      KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_UP, 0));
    scroll.setAlignmentX(0.0f);
    scroll.setAlignmentY(0.0f);

    layeredPane.setLayout(new InsetLayout(layeredPane, scroll));
    layeredPane.add(scroll, JLayeredPane.DEFAULT_LAYER);
  }
  return theMap;
}

@Override
public Component add(Component comp) {
    setsize(comp.getPreferredSize());
    Component[] comps = getComponents();
    if (comps.length > 0) {
        oldComponent = comps[0];
    }
    if (comp.equals(oldComponent)) {
        return super.add(comp);
    }
    if (oldComponent != null) {
        putLayer((JComponent) oldComponent, JLayeredPane.DEFAULT_LAYER);
    }
    Component returnResult = super.add(comp);
    putLayer((JComponent) comp, JLayeredPane.DRAG_LAYER);
    comp.setSize(getPreferredSize());
    comp.setVisible(true);
    comp.setLocation(0, 0 - getPreferredSize().height);
    slideFromTop(comp, oldComponent);
    return returnResult;
}

private void slideFromTop(final Component comp,
        final Component oldComponent2) {
    new Timer(DELAY, new ActionListener() {

        @Override
        public void actionPerformed(ActionEvent aEvt) {
            int y = comp.getY();
            if (y >= -2) {
                comp.setLocation(0, 0);
                putLayer((JComponent) comp, JLayeredPane.DEFAULT_LAYER);
                if (oldComponent2 != null) {
                    remove(oldComponent2);
                }
                ((Timer) aEvt.getSource()).stop();
            } else {
                y += DY;
                comp.setLocation(0, y);
            }
            repaint();
        }
    }).start();
}

@Override
public void dragStarted(MouseEvent e) {
    if (e.getButton() == MouseEvent.BUTTON1 && e.getSource() instanceof JLayeredPane) {
        selectionContainer = new JNodeContainerSelection(e.getPoint());
        add(selectionContainer, JLayeredPane.POPUP_LAYER);
    }
}

private void addViewportListener(JEditorPane pane) {
    Container parent = pane.getParent();

    if (parent instanceof JLayeredPane) {
        parent = parent.getParent();
    }

    if (parent instanceof JViewport) {
        JViewport viewport = (JViewport) parent;

        viewport.addChangeListener(WeakListeners.change(AnnotationHolder.this, viewport));
    }
}

private int getUsableWidth(JTextComponent component) {
    Container parent = component.getParent();
    if (parent instanceof JLayeredPane) {
        parent = parent.getParent();
    }
    return (parent instanceof JViewport)
        ? ((JViewport)parent).getExtentSize().width
        : component.getSize().width;
}

void start(JMenuItem item, Point pt) {
    op = Op.INTER_MENU_DRAG;
    started = true;


    //josh: intial support for dragging multiple items
    //in the future we should use the payloadComponents variable
    //for dragging components instead of the payloadComponent variable.
    List<RADComponent> rads = menuEditLayer.getSelectedRADComponents();

    payloadComponents = new ArrayList<JMenuItem>();
    if(rads.size() > 1) {
        for(RADComponent rad : rads) {
            Object comp = menuEditLayer.formDesigner.getComponent(rad);
            if(comp instanceof JMenuItem) {
                payloadComponents.add((JMenuItem)comp);
            } else {
                fastEnd();
                return;
            }
        }
    } else {
        payloadComponents.add(item);
    }

    dragComponent = (JMenuItem) createDragFeedbackComponent(item, null);
    dragComponent.setSize(dragComponent.getPreferredSize());
    dragComponent.setLocation(pt);
    menuEditLayer.layers.add(dragComponent, JLayeredPane.DRAG_LAYER);
    menuEditLayer.repaint();
    payloadComponent = item;
}

void setTargetVisible(boolean vis) {
    if(!vis) {
        menuEditLayer.layers.remove(dragComponent);
    } else {
        menuEditLayer.layers.add(dragComponent, JLayeredPane.DRAG_LAYER);
    }
    menuEditLayer.repaint();
}

public JComponent getDeepestComponentInPopups(Point pt) {
    Component[] popups = menuEditLayer.layers.getComponentsInLayer(JLayeredPane.DEFAULT_LAYER);
    for(Component popup : popups) {
        if(popup.isVisible()) {
            Point pt2 = SwingUtilities.convertPoint(menuEditLayer, pt, popup);
            JComponent child = (JComponent) javax.swing.SwingUtilities.getDeepestComponentAt(popup, pt2.x, pt2.y);
            if(child != null) return child;
        }
    }
    return null;
}

/**
 * Adds a component to this Canvas.
 *
 * Make sure the status panel is not present unless the component
 * *is* the status panel.
 *
 * @param comp The {@code Component} to add to this canvas.
 * @param i The layer to add the component to (see JLayeredPane).
 */
private void addToCanvas(Component comp, Integer i) {
    if (statusPanel.isVisible()) {
        if (comp == statusPanel) return;
        if (!(comp instanceof JMenuItem)) removeFromCanvas(statusPanel);
    }

    if (i == null) i = JLayeredPane.DEFAULT_LAYER;
    try {
        super.add(comp, i);
    } catch (Exception e) {
        logger.log(Level.WARNING, "addToCanvas(" + comp + ", " + i
            + ") failed.", e);
    }
}

/** Is the parent of some editor component a viewport */
private JViewport getParentViewport() {
    Component pc = component.getParent();
    if (pc instanceof JLayeredPane) {
        pc = pc.getParent();
    }
    return (pc instanceof JViewport) ? (JViewport)pc : null;
}

/** Install popup panel to current textComponent root pane */
private void installToRootPane(JComponent c) {
    JRootPane rp = textComponent.getRootPane();
    if (rp != null) {
        rp.getLayeredPane().add(c, JLayeredPane.POPUP_LAYER, 0);
    }
}

/** Variation of the method for computing the bounds
 * for the concrete view component. As the component can possibly
 * be placed in a scroll pane it's first necessary
 * to translate the cursor bounds and also translate
 * back the resulting popup bounds.
 * @param popup  popup panel to be displayed
 * @param view component over which the popup is displayed.
 * @param cursorBounds the bounds of the caret or mouse cursor
 *    relative to the upper-left corner of the visible view.
 * @param placement where to place the popup panel according to
 *    the cursor position.
 * @return bounds of popup panel relative to the upper-left corner
 *    of the underlying view component.
 *    <CODE>null</CODE> if there is no place to display popup.
 */
protected static Rectangle computeBounds(JComponent popup,
JComponent view, Rectangle cursorBounds, Placement placement, HorizontalBounds horizontalBounds) {

    if (horizontalBounds == null) horizontalBounds = ViewPortBounds;

    Rectangle ret;
    Component viewParent = view.getParent();

    if (viewParent instanceof JLayeredPane) {
        viewParent = viewParent.getParent();
    }

    if (viewParent instanceof JViewport) {
        Rectangle viewBounds = ((JViewport)viewParent).getViewRect();

        Rectangle translatedCursorBounds = (Rectangle)cursorBounds.clone();
        if (placement != FixedPoint) {
            translatedCursorBounds.translate(-viewBounds.x, -viewBounds.y);
        }

        ret = computeBounds(popup, viewBounds.width, viewBounds.height,
            translatedCursorBounds, placement, horizontalBounds);

        if (ret != null) { // valid bounds
            ret.translate(viewBounds.x, viewBounds.y);
        }

    } else { // not in scroll pane
        ret = computeBounds(popup, view.getWidth(), view.getHeight(),
            cursorBounds, placement);
    }

    return ret;
}

StickyWindowSupport(final JTextComponent jtc) {
    this.jtc = jtc;
    ViewHierarchy.get(jtc).addViewHierarchyListener(new ViewHierarchyListener() {
        @Override
        public void viewHierarchyChanged(ViewHierarchyEvent evt) {
            JTextComponent editor = jtc;
            Container container = editor.getParent();
            if(container instanceof JLayeredPane && evt.isChangeY()) {
                JLayeredPane pane = (JLayeredPane) container;
                double deltaY = evt.deltaY();
                Component[] components = pane.getComponentsInLayer(JLayeredPane.PALETTE_LAYER);
                Rectangle rv = null;
                for (final Component component : components) {
                    rv = component.getBounds(rv);
                    if(rv.getY() > evt.startY() ||
                            rv.contains(new Point(rv.x, (int) evt.startY())) ||
                            rv.contains(new Point(rv.x, (int) evt.endY()))) {
                        final Point p = rv.getLocation();
                        p.translate(0, (int) deltaY);
                        EventQueue.invokeLater(new Runnable() {

                            @Override
                            public void run() {      
                              component.setLocation(p);
                            }
                        });

                    }
                }
            }
        }
    });
}

/**
 * Add a sticky window to the editor.
 * @param window the JComponent to add to the editor
 */
public void addWindow(JComponent window) {
    Container container = jtc.getParent();
    if(container instanceof JLayeredPane) {
        JLayeredPane pane = (JLayeredPane) container;
        pane.add(window, JLayeredPane.PALETTE_LAYER);
        window.setVisible(true);
    }
}

/**
 * Convert a <code>aPoint</code> in root component coordinate system to the
 * editor coordinate system. <code>aPoint</code> is assumed to be in the
 * root component coordinate system of the editor. If conversion is not
 * possible, return <code>aPoint</code> without any conversion.
 *
 * @param aPoint the Point to convert
 * @return aPoint converted to editor coordinate system
 */
public @NonNull Point convertPoint(Point aPoint) {
    Point value = aPoint;
    Container container = jtc.getParent();
    if(container instanceof JLayeredPane) {
        JLayeredPane pane = (JLayeredPane) container;
        value = SwingUtilities.convertPoint(pane.getRootPane(), value, pane);
    }
    return value;
}

/**
 * Remove a sticky window from the editor.
 * @param window the JComponent to remove
 */
public void removeWindow(JComponent window) {
    Container container = jtc.getParent();
    if(container instanceof JLayeredPane) {
        JLayeredPane pane = (JLayeredPane) container;
        pane.remove(window);
        pane.repaint(window.getBounds());
    }
}

@SuppressWarnings("LeakingThisInConstructor")
public BraceMatchingSidebarComponent(JTextComponent editor) {
    this.editor = editor;
    this.mimeType = DocumentUtilities.getMimeType(editor);
    this.prefs = MimeLookup.getLookup(MimePath.EMPTY).lookup(Preferences.class);

    final Lookup.Result r = MimeLookup.getLookup(org.netbeans.lib.editor.util.swing.DocumentUtilities.getMimeType(editor)).lookupResult(
            FontColorSettings.class);
    prefListenerGC = new PrefListener();
    this.colorResult = r;
    r.addLookupListener(WeakListeners.create(LookupListener.class, this , r));
    prefs.addPreferenceChangeListener(WeakListeners.create(PreferenceChangeListener.class, prefListenerGC, prefs));
    loadPreferences();

    editorPane = findEditorPane(editor);
    Component parent = editor.getParent();
    if (parent instanceof JLayeredPane) {
        parent = parent.getParent();
    }
    if (parent instanceof JViewport) {
        this.viewport = (JViewport)parent;
        // see #219015; need to listen on viewport change to show/hide the tooltip
        viewport.addChangeListener(WeakListeners.change(this, viewport));
    }
    TextUI ui = editor.getUI();
    if (ui instanceof BaseTextUI) {
        baseUI = (BaseTextUI)ui;
        MasterMatcher.get(editor).addMatchListener(this);
    } else {
        baseUI = null;
    }
    setMaximumSize(new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE));
    updatePreferredSize();
}

/** Creates a new instance of DesktopImpl */
public DesktopImpl () {
    // layered pane with absolute positioning, to enable overlapping
    layeredPane = new JLayeredPane();
    layeredPane.setLayout(new LayeredLayout());
    // desktop represents regular layer of layeredPane
    desktop = new JPanel() {
        @Override
        public boolean isOpaque() {
            if( UIManager.getBoolean( "NbMainWindow.showCustomBackground" ) ) //NOI18N
                return false;
            return super.isOpaque();
        }

        @Override
        public void updateUI() {
            Mutex.EVENT.readAccess( new Runnable() {
                @Override
                public void run() {
                    superUpdateUI();
                }
            });
        }

        private void superUpdateUI() {
            super.updateUI();
        }
    };
    desktop.setLayout(new GridBagLayout());
    Color bkColor = UIManager.getColor("NbSplitPane.background"); //NOI18N
    if( null != bkColor ) {
        desktop.setBackground(bkColor);
        desktop.setOpaque(true);
    }
    layeredPane.add(desktop);
}

public void showEffect(JLayeredPane pane, Integer layer, SlideOperation operation) {
//        Component comp = operation.getComponent();
//        Graphics2D gr2d = (Graphics2D)pane.getGraphics();
//        Color original = gr2d.getColor();
//        gr2d.setColor(Color.BLUE.darker().darker());
//        Rectangle start = operation.getStartBounds();
//        Rectangle finish = operation.getFinishBounds();
//        Rectangle current = start;
//        for (int i = 0; i < 6 /** magic constant **/; i++) {
//            Rectangle newRect;
//            if (i > 0) {
//                // wipe out old
//            } 
//            newRect = new Rectangle();
//            newRect.x = Math.abs((current.x + finish.x) / 2);
//            newRect.y = Math.abs((current.y + finish.y) / 2);
//            newRect.height = Math.abs((current.height + finish.height) / 2);
//            newRect.width = Math.abs((current.width + finish.width) / 2);
//            gr2d.drawRect(newRect.x, newRect.y, newRect.width, newRect.height);
//            gr2d.setColor(gr2d.getColor().brighter());
//            current = newRect;
//        }
//        gr2d.setColor(original);
////        try {
////            Thread.sleep(5000);
////        } catch (Throwable th) {
////            
////        }

    }

public void showEffect(JLayeredPane pane, Integer layer, SlideOperation operation) {
    this.pane = pane;
    this.operation = operation;
    Component comp = operation.getComponent();
    Graphics2D gr2d = (Graphics2D)pane.getGraphics();
    Rectangle start = operation.getStartBounds();
    Rectangle finish = operation.getFinishBounds();
    Dimension finishSize = finish.getSize();
    Dimension startSize = start.getSize();
    Rectangle current = start;
    Image compImage = preparedImage;

   /* if (compImage == null) {
        if (finishSize.width * finishSize.height > startSize.width * startSize.height) {
            compImage = renderCompIntoImage(comp, finishSize, pane);
        } else {
            compImage = renderCompIntoImage(comp, startSize, pane);
        }
    }*/
    pane.add(stretchedImage, layer);

    path = computePath(start, finish);

    curIter = 1;
    if (compImage != null) {
        stretchedImage.setOrigImage(compImage);
    } else {
        if (finishSize.width * finishSize.height > startSize.width * startSize.height) {
            stretchedImage.setComp(comp, finishSize);
        } else {
            stretchedImage.setComp(comp, startSize);
        }
    }
    stretchedImage.setBoundsAndAlpha(start, initialAlpha);

    getTimer().start();
}

public void run(JLayeredPane pane, Integer layer) {
    if (effect != null && effect.shouldOperationWait()) {
        // OK, effect is asynchronous and we should wait for effect finish,
        // so register and wait for stateChanged notification
        this.pane = pane;
        this.layer = layer;
        effect.setFinishListener(this);
        effect.showEffect(pane, layer, this);
    } else {
        if (effect != null) {
            effect.showEffect(pane, layer, this);
        }
        performOperation(pane, layer);
    }
}

private void repaintLayeredPane() {
    SwingUtilities.invokeLater(new Runnable() {
        public void run() {
            Frame f = WindowManagerImpl.getInstance().getMainWindow();
            if( f instanceof JFrame ) {
                JLayeredPane lp = ((JFrame)f).getLayeredPane();
                if( null != lp ) {
                    lp.invalidate();
                    lp.revalidate();
                    lp.repaint();
                }
            }
        }
    });
}

private void removeProgressIndicator() {
    if (lastLayeredPane == null || progressIndicator == null) {
        return;
    }
    progressIndicator.setVisible(false);
    JLayeredPane lp = lastLayeredPane;
    lp.remove(progressIndicator);
    lp.repaint();
    progressIndicator = null;

}

/**
 * Updates size and visibility of this panel according to model content
 */
public void updatePopup () {
    int modelSize = rModel.getSize();

    // plug this popup into layered pane if needed
    JLayeredPane lPane = JLayeredPane.getLayeredPaneAbove(comboBar);
    // lPane can be null when the corresponding dialog is closed already
    // for example, when the user didn't want to wait until the search finishes
    if (!isDisplayable() && (lPane != null)) {
        lPane.add(this, new Integer(JLayeredPane.POPUP_LAYER + 1) );
    }

    boolean statusVisible = updateStatusPanel();

    if(lPane != null) {
        computePopupBounds(popupBounds, lPane, modelSize);
        setBounds(popupBounds);
    }

    // popup visibility constraints
    if ((modelSize > 0 || statusVisible) && comboBar.isTextFieldFocusOwner()) {
        if (jList1.getSelectedIndex() >= modelSize) {
            jList1.setSelectedIndex(modelSize - 1);
        }
        setVisible(true);
    } else {
        setVisible(false);
    }

    // needed on JDK 1.5.x to repaint correctly
    revalidate();
}

/**
  * Returns the BasicGraphGuiJDesktopPane
  * @return the BasicGraphGuiJDesktopPane
  */
 public BasicGraphGuiJDesktopPane getBasicGraphGuiJDesktopPane() {
    if (basicGraphGuiJDesktopPane==null) {
        basicGraphGuiJDesktopPane = new BasicGraphGuiJDesktopPane((GraphEnvironmentController) this.environmentController);
        basicGraphGuiJDesktopPane.add(this.getBasicGraphGuiRootJSplitPane(), JLayeredPane.DEFAULT_LAYER);
        try {
    this.getBasicGraphGuiRootJSplitPane().setMaximum(true);
} catch (PropertyVetoException pvex) {
    pvex.printStackTrace();
}
    }
    return basicGraphGuiJDesktopPane;
 }

/**
 * Fills the tablePane with content.
 */
private JComponent makePreviewTable() {
    previewTable = new ExtendedJTable(false, false, false);
    // ensure same background as JPanels in case of only few rows
    previewTable.setBackground(Colors.PANEL_BACKGROUND);
    previewTable.setColoredTableCellRenderer(new ColoredTableCellRenderer() {

        private final Font boldFont = getFont().deriveFont(Font.BOLD);

        @Override
        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,
                int row, int column) {
            JLabel label = (JLabel) super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
            adjustCell(row, label, boldFont);
            return label;
        }

    });

    loadingContentPane = new LoadingContentPane("loading_data", previewTable);

    tablePane = new JScrollPane(loadingContentPane);
    tablePane.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);
    tablePane.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED);
    tablePane.setBorder(null);

    // add PREVIEW label in front of scrollpane
    JLayeredPane layeredPane = new JLayeredPane();
    layeredPane.setLayout(new OverlayLayout(layeredPane));
    layeredPane.add(tablePane, JLayeredPane.DEFAULT_LAYER);

    JPanel overlayPanel = new JPanel(new BorderLayout());
    overlayPanel.setOpaque(false);
    overlayLabel = new JLabel("", SwingConstants.CENTER);
    showPreviewLettering();
    overlayPanel.add(overlayLabel, BorderLayout.CENTER);

    layeredPane.add(overlayPanel, JLayeredPane.PALETTE_LAYER);
    return layeredPane;
}

protected void setDragCursor() {
  final JRootPane rootWin = SwingUtilities.getRootPane(this);
  if (rootWin != null) {
    // remove cursor from old window
    if (dragCursor.getParent() != null) {
      dragCursor.getParent().remove(dragCursor);
    }
    drawWin = rootWin.getLayeredPane();

    dragCursor.setVisible(true);
    drawWin.add(dragCursor, JLayeredPane.DRAG_LAYER);
  }
}

/**
 * This method is called from within the constructor to initialize the form.
 * WARNING: Do NOT modify this code. The content of this method is always
 * regenerated by the Form Editor.
 */
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
private void initComponents() {

    cardsPane = new javax.swing.JLayeredPane();

    cardsPane.setMaximumSize(new java.awt.Dimension(1000, 300));
    cardsPane.setMinimumSize(new java.awt.Dimension(1000, 300));

    javax.swing.GroupLayout cardsPaneLayout = new javax.swing.GroupLayout(cardsPane);
    cardsPane.setLayout(cardsPaneLayout);
    cardsPaneLayout.setHorizontalGroup(
        cardsPaneLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
        .addGap(0, 1000, Short.MAX_VALUE)
    );
    cardsPaneLayout.setVerticalGroup(
        cardsPaneLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
        .addGap(0, 300, Short.MAX_VALUE)
    );

    javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
    this.setLayout(layout);
    layout.setHorizontalGroup(
        layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
        .addGroup(layout.createSequentialGroup()
            .addComponent(cardsPane, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
            .addGap(0, 312, Short.MAX_VALUE))
    );
    layout.setVerticalGroup(
        layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
        .addComponent(cardsPane, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
    );
}