コード例 #1
0
  protected void showErrorPage(final ErrorInfo info) {
    storeState();
    hideProgress();
    myRootComponent = null;

    myErrorMessages.removeAll();

    if (info.myShowStack) {
      info.myMessages.add(
          0, new FixableMessageInfo(true, info.myDisplayMessage, "", "", null, null));

      ByteArrayOutputStream stream = new ByteArrayOutputStream();
      info.myThrowable.printStackTrace(new PrintStream(stream));
      myErrorStack.setText(stream.toString());
      myErrorStackLayout.show(myErrorStackPanel, ERROR_STACK_CARD);
    } else {
      myErrorStack.setText(null);
      myErrorStackLayout.show(myErrorStackPanel, ERROR_NO_STACK_CARD);
    }

    for (FixableMessageInfo message : info.myMessages) {
      addErrorMessage(
          message, message.myErrorIcon ? Messages.getErrorIcon() : Messages.getWarningIcon());
    }

    myErrorPanel.revalidate();
    myLayout.show(this, ERROR_CARD);

    DesignerToolWindowManager.getInstance(getProject()).refresh(true);
    repaint();
  }
コード例 #2
0
 protected final void showDesignerCard() {
   myErrorMessages.removeAll();
   myErrorStack.setText(null);
   myLayeredPane.revalidate();
   myHorizontalCaption.update();
   myVerticalCaption.update();
   myLayout.show(this, DESIGNER_CARD);
 }
コード例 #3
0
 protected final void showProgress(String message) {
   myProgressMessage.setText(message);
   if (myProgressPanel.getParent() == null) {
     myGlassLayer.setEnabled(false);
     myProgressIcon.resume();
     myLayeredPane.add(myProgressPanel, LAYER_PROGRESS);
     myLayeredPane.repaint();
   }
 }
コード例 #4
0
  private void createErrorCard() {
    myErrorPanel = new JPanel(new BorderLayout());
    myErrorMessages =
        new JPanel(new VerticalFlowLayout(VerticalFlowLayout.TOP, 10, 5, true, false));
    myErrorPanel.add(myErrorMessages, BorderLayout.PAGE_START);

    myErrorStack = new JTextArea(50, 20);
    myErrorStack.setEditable(false);

    myErrorStackLayout = new CardLayout();
    myErrorStackPanel = new JPanel(myErrorStackLayout);
    myErrorStackPanel.add(new JLabel(), ERROR_NO_STACK_CARD);
    myErrorStackPanel.add(ScrollPaneFactory.createScrollPane(myErrorStack), ERROR_STACK_CARD);

    myErrorPanel.add(myErrorStackPanel, BorderLayout.CENTER);

    add(myErrorPanel, ERROR_CARD);
  }
コード例 #5
0
  private void addErrorMessage(final FixableMessageInfo message, Icon icon) {
    if (message.myLinkText.length() > 0 || message.myAfterLinkText.length() > 0) {
      HyperlinkLabel warnLabel = new HyperlinkLabel();
      warnLabel.setOpaque(false);
      warnLabel.setHyperlinkText(
          message.myBeforeLinkText, message.myLinkText, message.myAfterLinkText);
      warnLabel.setIcon(icon);

      if (message.myQuickFix != null) {
        warnLabel.addHyperlinkListener(
            new HyperlinkListener() {
              public void hyperlinkUpdate(final HyperlinkEvent e) {
                if (e.getEventType() == HyperlinkEvent.EventType.ACTIVATED) {
                  message.myQuickFix.run();
                }
              }
            });
      }
      myErrorMessages.add(warnLabel);
    } else {
      JBLabel warnLabel = new JBLabel();
      warnLabel.setOpaque(false);
      warnLabel.setText(
          "<html><body>" + message.myBeforeLinkText.replace("\n", "<br>") + "</body></html>");
      warnLabel.setIcon(icon);
      myErrorMessages.add(warnLabel);
    }
    if (message.myAdditionalFixes != null && message.myAdditionalFixes.size() > 0) {
      JPanel fixesPanel = new JPanel(new FlowLayout(FlowLayout.LEFT, 5, 0));
      fixesPanel.setBorder(IdeBorderFactory.createEmptyBorder(3, 0, 10, 0));
      fixesPanel.setOpaque(false);
      fixesPanel.add(Box.createHorizontalStrut(icon.getIconWidth()));

      for (Pair<String, Runnable> pair : message.myAdditionalFixes) {
        HyperlinkLabel fixLabel = new HyperlinkLabel();
        fixLabel.setOpaque(false);
        fixLabel.setHyperlinkText(pair.getFirst());
        final Runnable fix = pair.getSecond();

        fixLabel.addHyperlinkListener(
            new HyperlinkListener() {
              @Override
              public void hyperlinkUpdate(HyperlinkEvent e) {
                if (e.getEventType() == HyperlinkEvent.EventType.ACTIVATED) {
                  fix.run();
                }
              }
            });
        fixesPanel.add(fixLabel);
      }
      myErrorMessages.add(fixesPanel);
    }
  }
コード例 #6
0
  private void createProgressPanel() {
    myProgressIcon = new AsyncProcessIcon("Designer progress");
    myProgressMessage = new JLabel();

    JPanel progressBlock = new JPanel();
    progressBlock.add(myProgressIcon);
    progressBlock.add(myProgressMessage);
    progressBlock.setBorder(IdeBorderFactory.createRoundedBorder());

    myProgressPanel = new JPanel(new GridBagLayout());
    myProgressPanel.add(
        progressBlock,
        new GridBagConstraints(
            0,
            0,
            1,
            1,
            0,
            0,
            GridBagConstraints.CENTER,
            GridBagConstraints.BOTH,
            new Insets(0, 0, 0, 0),
            0,
            0));
    myProgressPanel.setOpaque(false);
  }
コード例 #7
0
 public JComponent getPreferredFocusedComponent() {
   return myDesignerCard.isVisible() ? myGlassLayer : myErrorPanel;
 }
コード例 #8
0
  private void createDesignerCard() {
    myLayeredPane = new MyLayeredPane();

    mySurfaceArea =
        new ComponentEditableArea(myLayeredPane) {
          @Override
          protected void fireSelectionChanged() {
            super.fireSelectionChanged();
            myLayeredPane.revalidate();
            myLayeredPane.repaint();
          }

          @Override
          public RadComponent findTarget(int x, int y, @Nullable ComponentTargetFilter filter) {
            if (myRootComponent != null) {
              FindComponentVisitor visitor = new FindComponentVisitor(myLayeredPane, filter, x, y);
              myRootComponent.accept(visitor, false);
              return visitor.getResult();
            }
            return null;
          }

          @Override
          public InputTool findTargetTool(int x, int y) {
            return myDecorationLayer.findTargetTool(x, y);
          }

          @Override
          public void showSelection(boolean value) {
            myDecorationLayer.showSelection(value);
          }

          @Override
          public ComponentDecorator getRootSelectionDecorator() {
            return DesignerEditorPanel.this.getRootSelectionDecorator();
          }

          @Nullable
          public EditOperation processRootOperation(OperationContext context) {
            return DesignerEditorPanel.this.processRootOperation(context);
          }

          @Override
          public FeedbackLayer getFeedbackLayer() {
            return myFeedbackLayer;
          }

          @Override
          public RadComponent getRootComponent() {
            return myRootComponent;
          }
        };

    myPaletteListener =
        new ListSelectionListener() {
          @Override
          public void valueChanged(ListSelectionEvent e) {
            if (DesignerToolWindowManager.getInstance(getProject()).getActiveDesigner()
                == DesignerEditorPanel.this) {
              Item paletteItem = (Item) PaletteManager.getInstance(getProject()).getActiveItem();
              if (paletteItem != null) {
                myToolProvider.setActiveTool(
                    new CreationTool(true, createCreationFactory(paletteItem)));
              } else if (myToolProvider.getActiveTool() instanceof CreationTool) {
                myToolProvider.loadDefaultTool();
              }
            }
          }
        };

    myToolProvider =
        new ToolProvider() {
          @Override
          public void loadDefaultTool() {
            setActiveTool(new SelectionTool());
          }

          @Override
          public void setActiveTool(InputTool tool) {
            if (getActiveTool() instanceof CreationTool && !(tool instanceof CreationTool)) {
              PaletteManager.getInstance(getProject()).clearActiveItem();
            }
            super.setActiveTool(tool);
          }

          @Override
          public boolean execute(
              final ThrowableRunnable<Exception> operation,
              String command,
              final boolean updateProperties) {
            final boolean[] is = {true};
            CommandProcessor.getInstance()
                .executeCommand(
                    getProject(),
                    new Runnable() {
                      public void run() {
                        is[0] = DesignerEditorPanel.this.execute(operation, updateProperties);
                      }
                    },
                    command,
                    null);
            return is[0];
          }

          @Override
          public void execute(final List<EditOperation> operations, String command) {
            CommandProcessor.getInstance()
                .executeCommand(
                    getProject(),
                    new Runnable() {
                      public void run() {
                        DesignerEditorPanel.this.execute(operations);
                      }
                    },
                    command,
                    null);
          }

          @Override
          public void showError(@NonNls String message, Throwable e) {
            DesignerEditorPanel.this.showError(message, e);
          }
        };

    myGlassLayer = new GlassLayer(myToolProvider, mySurfaceArea);
    myLayeredPane.add(myGlassLayer, LAYER_GLASS);

    myDecorationLayer = new DecorationLayer(mySurfaceArea);
    myLayeredPane.add(myDecorationLayer, LAYER_DECORATION);

    myFeedbackLayer = new FeedbackLayer();
    myLayeredPane.add(myFeedbackLayer, LAYER_FEEDBACK);

    JPanel content = new JPanel(new GridBagLayout());

    GridBagConstraints gbc = new GridBagConstraints();

    gbc.gridx = 0;
    gbc.gridy = 1;
    gbc.fill = GridBagConstraints.VERTICAL;

    myVerticalCaption = new CaptionPanel(this, false);
    content.add(myVerticalCaption, gbc);

    gbc.gridx = 1;
    gbc.gridy = 0;
    gbc.fill = GridBagConstraints.HORIZONTAL;

    myHorizontalCaption = new CaptionPanel(this, true);
    content.add(myHorizontalCaption, gbc);

    gbc.gridx = 1;
    gbc.gridy = 1;
    gbc.weightx = 1;
    gbc.weighty = 1;
    gbc.fill = GridBagConstraints.BOTH;

    myScrollPane = ScrollPaneFactory.createScrollPane(myLayeredPane);
    myScrollPane.setBackground(Color.WHITE);
    content.add(myScrollPane, gbc);

    myHorizontalCaption.attachToScrollPane(myScrollPane);
    myVerticalCaption.attachToScrollPane(myScrollPane);

    myActionPanel = new DesignerActionPanel(this, myGlassLayer);

    myDesignerCard = new JPanel(new FillLayout());
    myDesignerCard.add(myActionPanel.getToolbarComponent());
    myDesignerCard.add(content);
    add(myDesignerCard, DESIGNER_CARD);

    PaletteManager.getInstance(getProject()).addSelectionListener(myPaletteListener);

    mySourceSelectionListener =
        new ComponentSelectionListener() {
          @Override
          public void selectionChanged(EditableArea area) {
            storeSourceSelectionState();
          }
        };
    mySurfaceArea.addSelectionListener(mySourceSelectionListener);
  }