private void initToolWindow() {
  myToolWindowPanel = new MyToolWindowPanel();
  myComponentTree = new ComponentTree(myProject);
  for (TreeSelectionListener listener : myPendingListeners) {
    myComponentTree.addTreeSelectionListener(listener);
  }
  myPendingListeners.clear();
  final JScrollPane scrollPane = ScrollPaneFactory.createScrollPane(myComponentTree);
  scrollPane.setBorder(IdeBorderFactory.createBorder(SideBorder.BottOM));
  scrollPane.setPreferredSize(new Dimension(250,-1));
  myComponentTree.initQuickFixManager(scrollPane.getViewport());
  myPropertyInspector= new PropertyInspector(myProject,myComponentTree);
  myToolWindowPanel.setFirstComponent(scrollPane);
  myToolWindowPanel.setSecondComponent(myPropertyInspector);
  myToolWindow = ToolWindowManager.getInstance(myProject).registerToolWindow(UIDesignerBundle.message("toolwindow.ui.designer"),myToolWindowPanel,ToolWindowAnchor.LEFT,myProject,true);
  myToolWindow.setIcon(UIDesignerIcons.ToolWindowUIDesigner);
  myToolWindow.setAvailable(false,null);
}

public TopBottomComponentWrapper(JComponent component,boolean top) {
  super(new BorderLayout());
  myWrappee = component;
  setopaque(false);

  setBorder(new SideBorder(null,top ? SideBorder.BottOM : SideBorder.TOP) {
    @Override
    public Color getLineColor() {
      Color result = EditorColorsManager.getInstance().getGlobalScheme().getColor(EditorColors.TEARLINE_COLOR);
      return result == null ? JBColor.BLACK : result;
    }
  });

  add(component);
}

@Override
public String setupUIComponentPresentation(String text,int highlightStartOffset,int highlightEndOffset,boolean isdisabled,boolean strikeout,boolean isdisabledBeforeHighlight,Color background) {
  final String resultedText =
    myPanels[i].setup(text,myEscapeFunction,highlightStartOffset,highlightEndOffset,isdisabled,strikeout,isdisabledBeforeHighlight,background);
  myPanels[i].setBorder(isLastParameterOwner() ? BACKGROUND_BORDER : new SideBorder(new JBColor(JBColor.LIGHT_GRAY,Gray._90),SideBorder.BottOM));
  return resultedText;
}

private void initConsoleUI(Process process) {
  // Init console view
  myConsoleView = createConsoleView();
  if (myConsoleView instanceof JComponent) {
    ((JComponent)myConsoleView).setBorder(new SideBorder(JBColor.border(),SideBorder.LEFT));
  }
  myProcessHandler = createProcessHandler(process);

  myConsoleExecuteActionHandler = createExecuteActionHandler();

  ProcessterminatedListener.attach(myProcessHandler);

  myProcessHandler.addProcessListener(new ProcessAdapter() {
    @Override
    public void processterminated(ProcessEvent event) {
      finishConsole();
    }
  });

  // Attach to process
  myConsoleView.attachToProcess(myProcessHandler);

  // Runner creating
  createContentDescriptorAndActions();

  // Run
  myProcessHandler.startNotify();
}

@Override
protected JComponent createCenterPanel() {
  JComponent mainPanel = myEditor.createComponent();
  mainPanel.setPreferredSize(new Dimension(600,400));
  mainPanel.setBorder(IdeBorderFactory.createBorder(SideBorder.ALL));

  return mainPanel;
}

@Override
protected JComponent createtoolbar() {
  JPanel panel = new JPanel(new BorderLayout());
  panel.setBorder(IdeBorderFactory.createBorder(SideBorder.BottOM));

  // Create a layout where there are three toolbars:
  // +----------------------------------------------------------------------------+
  // | normal toolbar,minus dynamic actions                                      |
  // +---------------------------------------------+------------------------------+
  // | Dynamic layout actions                      | Zoom actions and file status |
  // +---------------------------------------------+------------------------------+

  ActionManager actionManager = ActionManager.getInstance();
  ActionToolbar actionToolbar = actionManager.createActionToolbar(TOOLBAR,getActionGroup(),true);
  actionToolbar.setLayoutPolicy(ActionToolbar.WRAP_LAYOUT_POLICY);
  panel.add(actionToolbar.getComponent(),BorderLayout.norTH);

  ActionToolbar layoutToolBar = actionManager.createActionToolbar(TOOLBAR,getDynamicActionGroup(),true);
  layoutToolBar.setLayoutPolicy(ActionToolbar.WRAP_LAYOUT_POLICY);

  // The default toolbar layout adds too much spacing between the buttons. Switch to mini mode,// but also set a minimum size which will add *some* padding for our 16x16 icons.
  layoutToolBar.setMiniMode(true);
  layoutToolBar.setMinimumButtonSize(new Dimension(22,24));

  ActionToolbar zoomToolBar = actionManager.createActionToolbar(TOOLBAR,getRhsActions(),true);
  JPanel bottom = new JPanel(new BorderLayout());
  bottom.add(layoutToolBar.getComponent(),BorderLayout.WEST);
  RenderContext context = (AndroidDesignerEditorPanel)myDesigner;
  RenderOptionsMenuBuilder optionsMenuBuilder = RenderOptionsMenuBuilder.create(context);
  ActionToolbar optionsToolBar = optionsMenuBuilder.addPreferXmlOption().addDeviceFrameOption().addRetinaOption().build();
  JPanel combined = new JPanel(new BorderLayout());
  combined.add(zoomToolBar.getComponent(),BorderLayout.WEST);
  combined.add(optionsToolBar.getComponent(),BorderLayout.EAST);
  bottom.add(combined,BorderLayout.EAST);

  panel.add(bottom,BorderLayout.soUTH);

  return panel;
}

public void initContent() {
  final ActionManager actionManager = ActionManager.getInstance();
  final ActionGroup actionGroup = (ActionGroup)actionManager.getAction(TOOL_WINDOW_TOOLBAR_ID);
  ActionToolbar actionToolbar = actionManager.createActionToolbar(myPlace,actionGroup,true);
  JPanel toolbarControl = new JPanel(new GridBagLayout());
  GridBagConstraints constraints = new GridBagConstraints();
  constraints.gridwidth = GridBagConstraints.REMAINDER;
  constraints.weightx = 1;
  constraints.fill = GridBagConstraints.HORIZONTAL;
  constraints.anchor = GridBagConstraints.WEST;
  toolbarControl.add(actionToolbar.getComponent(),constraints);
  for (JComponent component : getToolbarControls()) {
    component.setBorder(IdeBorderFactory.createBorder(SideBorder.TOP));
    toolbarControl.add(component,constraints);
  }
  setToolbar(toolbarControl);

  final JComponent payloadControl = buildContent();
  JScrollPane scrollPane = ScrollPaneFactory.createScrollPane(payloadControl);
  JScrollBar scrollBar = scrollPane.getVerticalScrollBar();
  scrollBar.setUnitIncrement(scrollBar.getUnitIncrement() * 7);
  myContent.add(scrollPane,CONTENT_CARD_NAME);
  RichTextControlBuilder builder = new RichTextControlBuilder();
  builder.setBackgroundColor(payloadControl.getBackground());
  builder.setForegroundColor(UIUtil.getInactiveTextColor());
  builder.setFont(payloadControl.getFont());
  builder.setText(GradleBundle.message("gradle.toolwindow.text.no.linked.project"));
  final JComponent noLinkedProjectControl = builder.build();
  myContent.add(noLinkedProjectControl,NON_LINKED_CARD_NAME);
  update();
}

public DesignerToolWindow(Project project) {
  myComponentTree = new ComponentTree(project);

  JScrollPane scrollPane = ScrollPaneFactory.createScrollPane(myComponentTree);
  scrollPane.setBorder(IdeBorderFactory.createBorder(SideBorder.BottOM));
  scrollPane.setPreferredSize(new Dimension(250,-1));
  myComponentTree.initQuickFixManager(scrollPane.getViewport());

  myPropertyInspector = new PropertyInspector(project,myComponentTree);

  myToolWindowPanel.setFirstComponent(scrollPane);
  myToolWindowPanel.setSecondComponent(myPropertyInspector);
}

protected JComponent createtoolbar() {
  ActionManager actionManager = ActionManager.getInstance();
  ActionToolbar actionToolbar = actionManager.createActionToolbar(TOOLBAR,myActionGroup,true);
  actionToolbar.setLayoutPolicy(ActionToolbar.WRAP_LAYOUT_POLICY);

  JComponent toolbar = actionToolbar.getComponent();
  toolbar.setBorder(IdeBorderFactory.createBorder(SideBorder.BottOM));
  toolbar.setVisible(false);

  return toolbar;
}

public TopBottomComponentWrapper(JComponent component,boolean top) {
  super(new BorderLayout());
  setopaque(false);

  setBorder(new SideBorder(null,top ? SideBorder.BottOM : SideBorder.TOP,true) {
    @Override
    public Color getLineColor() {
      Color result = EditorColorsManager.getInstance().getGlobalScheme().getColor(EditorColors.TEARLINE_COLOR);
      return result == null ? Color.black : result;
    }
  });

  add(component);
}

@Override
public void setupUIComponentPresentation(String text,Color background) {
  myPanels[i].setup(text,SideBorder.BottOM));
}

public void initContent() {
  final ActionManager actionManager = ActionManager.getInstance();
  final ActionGroup actionGroup = (ActionGroup)actionManager.getAction(TOOL_WINDOW_TOOLBAR_ID);
  ActionToolbar actionToolbar = actionManager.createActionToolbar(myPlace,NON_LINKED_CARD_NAME);
  update();
}

public DesignerToolWindow(Project project,boolean updateOrientation) {
  myComponentTree = new ComponentTree();
  JScrollPane treeScrollPane = ScrollPaneFactory.createScrollPane(myComponentTree);
  treeScrollPane.setBorder(IdeBorderFactory.createBorder(SideBorder.BottOM));
  treeScrollPane.setPreferredSize(new Dimension(250,-1));
  myComponentTree.initQuickFixManager(treeScrollPane.getViewport());

  myPropertyTablePanel = new PropertyTablePanel(project);

  myToolWindowPanel = new Splitter(true,0.42f);
  myToolWindowPanel.setDividerWidth(3);
  myToolWindowPanel.setShowDividerControls(false);
  myToolWindowPanel.setShowDividerIcon(false);
  myToolWindowPanel.setFirstComponent(treeScrollPane);
  myToolWindowPanel.setSecondComponent(myPropertyTablePanel);

  if (updateOrientation) {
    myToolWindowPanel.addComponentListener(new ComponentAdapter() {
      @Override
      public void componentResized(ComponentEvent e) {
        Dimension size = myToolWindowPanel.getSize();
        boolean newVertical = size.width < size.height;
        if (myToolWindowPanel.getorientation() != newVertical) {
          myToolWindowPanel.setorientation(newVertical);
        }
      }
    });
  }
}

protected JComponent createtoolbar() {
  ActionManager actionManager = ActionManager.getInstance();
  ActionToolbar actionToolbar = actionManager.createActionToolbar(TOOLBAR,true);
  actionToolbar.setLayoutPolicy(ActionToolbar.WRAP_LAYOUT_POLICY);

  JComponent toolbar = actionToolbar.getComponent();
  toolbar.setBorder(IdeBorderFactory.createBorder(SideBorder.BottOM));
  toolbar.setVisible(false);

  return toolbar;
}

protected JComponent createtoolbar() {
  ActionManager actionManager = ActionManager.getInstance();
  ActionToolbar actionToolbar = actionManager.createActionToolbar(TOOLBAR,true);
  actionToolbar.setLayoutPolicy(ActionToolbar.WRAP_LAYOUT_POLICY);

  JComponent toolbar = actionToolbar.getComponent();
  toolbar.setBorder(IdeBorderFactory.createBorder(SideBorder.BottOM));
  toolbar.setVisible(false);

  return toolbar;
}

protected JComponent createtoolbar() {
    ActionManager actionManager = ActionManager.getInstance();
    ActionToolbar actionToolbar = actionManager.createActionToolbar(TOOLBAR,true);
    actionToolbar.setLayoutPolicy(ActionToolbar.WRAP_LAYOUT_POLICY);

    JComponent toolbar = actionToolbar.getComponent();
    toolbar.setBorder(IdeBorderFactory.createBorder(SideBorder.BottOM));
    toolbar.setVisible(false);

    return toolbar;
}

public CordovaDesignerToolWindow(Project project,0.42f);
  myToolWindowPanel.setDividerWidth(3);
  myToolWindowPanel.setShowDividerControls(false);
  myToolWindowPanel.setShowDividerIcon(false);
  myToolWindowPanel.setFirstComponent(treeScrollPane);
  myToolWindowPanel.setSecondComponent(myPropertyTablePanel);

  if (updateOrientation) {
    myToolWindowPanel.addComponentListener(new ComponentAdapter() {
      @Override
      public void componentResized(ComponentEvent e) {
        Dimension size = myToolWindowPanel.getSize();
        boolean newVertical = size.width < size.height;
        if (myToolWindowPanel.getorientation() != newVertical) {
          myToolWindowPanel.setorientation(newVertical);
        }
      }
    });
  }
}

public DesignerToolWindow(Project project)
{
    myComponentTree = new ComponentTree(project);

    JScrollPane scrollPane = ScrollPaneFactory.createScrollPane(myComponentTree);
    scrollPane.setBorder(IdeBorderFactory.createBorder(SideBorder.BottOM));
    scrollPane.setPreferredSize(new Dimension(250,-1));
    myComponentTree.initQuickFixManager(scrollPane.getViewport());

    myPropertyInspector = new PropertyInspector(project,myComponentTree);

    myToolWindowPanel.setFirstComponent(scrollPane);
    myToolWindowPanel.setSecondComponent(myPropertyInspector);
}

@Nonnull
private static SideBorder createtopBottomSideBorder(boolean top) {
  return new SideBorder(null,top ? SideBorder.BottOM : SideBorder.TOP) {
    @Override
    public Color getLineColor() {
      Color result = EditorColorsManager.getInstance().getGlobalScheme().getColor(EditorColors.TEARLINE_COLOR);
      return result == null ? JBColor.BLACK : result;
    }
  };
}

/**
 * Launch process,setup history,actions etc.
 *
 * @throws ExecutionException
 */
public void initAndRun() throws ExecutionException {
  // Create Server process
  final Process process = createProcess();
  UIUtil.invokelaterIfNeeded(() -> {
    // Init console view
    myConsoleView = createConsoleView();
    if (myConsoleView instanceof JComponent) {
      ((JComponent)myConsoleView).setBorder(new SideBorder(JBColor.border(),SideBorder.LEFT));
    }
    myProcessHandler = createProcessHandler(process);

    myConsoleExecuteActionHandler = createExecuteActionHandler();

    ProcessterminatedListener.attach(myProcessHandler);

    myProcessHandler.addProcessListener(new ProcessAdapter() {
      @Override
      public void processterminated(ProcessEvent event) {
        finishConsole();
      }
    });

    // Attach to process
    myConsoleView.attachToProcess(myProcessHandler);

    // Runner creating
    createContentDescriptorAndActions();

    // Run
    myProcessHandler.startNotify();
  });
}

public ThreadDumpPanel(Project project,final ConsoleView consoleView,final DefaultActionGroup toolbaractions,final List<ThreadState> threadDump) {
  super(new BorderLayout());
  final ThreadState[] data = threadDump.toArray(new ThreadState[threadDump.size()]);
  DefaultListModel model = new DefaultListModel();
  for (ThreadState threadState : data) {
    model.addElement(threadState);
  }
  myThreadList = new JBList(model);
  myThreadList.setCellRenderer(new ThreadListCellRenderer());
  myThreadList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
  myThreadList.addListSelectionListener(new ListSelectionListener() {
    public void valueChanged(final ListSelectionEvent e) {
      int index = myThreadList.getSelectedindex();
      if (index >= 0) {
        ThreadState selection = (ThreadState)myThreadList.getModel().getElementAt(index);
        AnalyzeStacktraceUtil.printstacktrace(consoleView,selection.getStackTrace());
      }
      else {
        AnalyzeStacktraceUtil.printstacktrace(consoleView,"");
      }
      myThreadList.repaint();
    }
  });
  toolbaractions.add(new copyToClipboardAction(threadDump,project));
  toolbaractions.add(new SortThreadsAction());
  //toolbaractions.add(new ShowRecentlyChanged());
  add(ActionManager.getInstance().createActionToolbar(ActionPlaces.UNKNowN,toolbaractions,false).getComponent(),BorderLayout.WEST);

  final Splitter splitter = new Splitter(false,0.3f);
  splitter.setFirstComponent(ScrollPaneFactory.createScrollPane(myThreadList,SideBorder.LEFT | SideBorder.RIGHT));
  splitter.setSecondComponent(consoleView.getComponent());

  add(splitter,BorderLayout.CENTER);

  new ListSpeedSearch(myThreadList).setComparator(new SpeedSearchComparator(false,true));
}

public NewErrorTreeViewPanel(Project project,String helpId,boolean createExitaction,boolean createtoolbar,@Nullable Runnable rerunAction) {
  myProject = project;
  myHelpId = helpId;
  myCreateExitaction = createExitaction;
  myConfiguration = ErrorTreeViewConfiguration.getInstance(project);
  setLayout(new BorderLayout());

  myAutoScrollToSourceHandler = new AutoScrollToSourceHandler() {
    @Override
    protected boolean isAutoScrollMode() {
      return myConfiguration.isAutoscrollToSource();
    }

    @Override
    protected void setAutoScrollMode(boolean state) {
      myConfiguration.setAutoscrollToSource(state);
    }
  };

  myMessagePanel = new JPanel(new BorderLayout());

  myErrorViewStructure = new ErrorViewStructure(project,canHideWarnings());
  DefaultMutableTreeNode root = new DefaultMutableTreeNode();
  root.setUserObject(myErrorViewStructure.createDescriptor(myErrorViewStructure.getRootElement(),null));
  final DefaultTreeModel treeModel = new DefaultTreeModel(root);
  myTree = new Tree(treeModel) {
    @Override
    public void setRowHeight(int i) {
      super.setRowHeight(0);
      // this is needed in order to make UI calculate the height for each particular row
    }
  };
  myBuilder = new ErrorViewTreeBuilder(myTree,treeModel,myErrorViewStructure);

  myExporterToTextFile = new ErrorViewTextExporter(myErrorViewStructure);
  myOccurrenceNavigatorSupport = new MyOccurrenceNavigatorSupport(myTree);

  myAutoScrollToSourceHandler.install(myTree);
  TreeUtil.installActions(myTree);
  UIUtil.setLinestyleAngled(myTree);
  myTree.setRootVisible(false);
  myTree.setShowsRootHandles(true);
  myTree.setLargeModel(true);

  JScrollPane scrollPane = NewErrorTreeRenderer.install(myTree);
  scrollPane.setBorder(IdeBorderFactory.createBorder(SideBorder.LEFT));
  myMessagePanel.add(scrollPane,BorderLayout.CENTER);

  if (createtoolbar) {
    add(createtoolbarPanel(rerunAction),BorderLayout.WEST);
  }

  add(myMessagePanel,BorderLayout.CENTER);

  myTree.addKeyListener(new KeyAdapter() {
    @Override
    public void keypressed(KeyEvent e) {
      if (e.getKeyCode() == KeyEvent.VK_ENTER) {
        navigatetoSource(false);
      }
    }
  });

  myTree.addMouseListener(new PopupHandler() {
    @Override
    public void invokePopup(Component comp,int x,int y) {
      popupInvoked(comp,x,y);
    }
  });

  EditSourceondoubleclickHandler.install(myTree);
}

private void setChangeDetailsPanel(@Nullable final JComponent component) {
  mySplitter.setSecondComponent(component);
  mySplitter.getFirstComponent().setBorder(component == null ? null : IdeBorderFactory.createBorder(SideBorder.RIGHT));
  mySplitter.revalidate();
  mySplitter.repaint();
}

@Override
public String setupUIComponentPresentation(final String[] texts,final EnumSet<Flag>[] flags,final Color background) {
  final String resultedText = myPanels[i].setup(texts,flags,SideBorder.BottOM));
  return resultedText;
}

@Override
public void navigateInPreviewEditor(PreviewEditorState editorState) {
  final VirtualFile file = editorState.getFile();
  final LogicalPosition positionToNavigate = editorState.getNavigate();
  final TextAttributes lineAttributes = editorState.getAttributes();
  Document document = FileDocumentManager.getInstance().getDocument(file);
  Project project = myProject;

  clearEditor();
  myEditorState = editorState;
  remove(myLabel);
  if (document != null) {
    if (getEditor() == null || getEditor().getDocument() != document) {
      setEditor(EditorFactory.getInstance().createViewer(document,project));

      final EditorColoRSScheme scheme = EditorColorsManager.getInstance().getGlobalScheme();

      EditorHighlighter Highlighter = EditorHighlighterFactory.getInstance().createEditorHighlighter(file,scheme,project);

      ((EditorEx)getEditor()).setFile(file);
      ((EditorEx)getEditor()).setHighlighter(Highlighter);

      getEditor().getSettings().setAnimatedScrolling(false);
      getEditor().getSettings().setRefrainFromScrolling(false);
      getEditor().getSettings().setLineNumbeRSShown(true);
      getEditor().getSettings().setFoldingOutlineshown(false);
      ((EditorEx)getEditor()).getFoldingModel().setFoldingEnabled(false);

      add(getEditor().getComponent(),BorderLayout.CENTER);
    }

    if (positionToNavigate != null) {
      getEditor().getCaretModel().movetoLogicalPosition(positionToNavigate);
      validate();
      getEditor().getScrollingModel().scrollToCaret(ScrollType.CENTER);
    }

    getEditor().setBorder(IdeBorderFactory.createBorder(SideBorder.TOP));

    clearHighlighting();
    if (lineAttributes != null && positionToNavigate != null && positionToNavigate.line < getEditor().getDocument().getLineCount()) {
      myHighlighter = getEditor().getMarkupModel().addLineHighlighter(positionToNavigate.line,HighlighterLayer.SELECTION - 1,lineAttributes);
    }
  }
  else {
    myLabel.setText("Navigate to selected " + (file.isDirectory() ? "directory " : "file ") + "in Project View");
    add(myLabel,BorderLayout.CENTER);
    validate();
  }
}

public static JScrollPane install(JTree tree) {
  JScrollPane scrollPane = MultilineTreeCellRenderer.installrenderer(tree,new MessageTreeRenderer());
  scrollPane.setBorder(IdeBorderFactory.createBorder(SideBorder.LEFT));
  return scrollPane;
}

public PropertyInspector(Project project,@NotNull final ComponentTree componentTree) {
  super(new cardlayout());

  myInspectorTable = new PropertyInspectorTable(project,componentTree);
  myComponentTree = componentTree;

  // Card with property inspector
  final JPanel inspectorCard = new JPanel(new GridBagLayout());
  final JScrollPane inspectorScrollPane = ScrollPaneFactory.createScrollPane(myInspectorTable);
  inspectorScrollPane.setBorder(IdeBorderFactory.createBorder(SideBorder.BottOM));
  inspectorCard.add(inspectorScrollPane,new GridBagConstraints(0,1,GridBagConstraints.CENTER,GridBagConstraints.BOTH,new Insets(0,0),0)
  );
  final JCheckBox chkShowExpertProperties = new JCheckBox(UIDesignerBundle.message("chk.show.expert.properties"));
  inspectorCard.add(
    chkShowExpertProperties,GridBagConstraints.WEST,GridBagConstraints.NONE,0)
  );
  chkShowExpertProperties.addActionListener(
    new ActionListener() {
      public void actionPerformed(final ActionEvent e) {
        myInspectorTable.setShowExpertProperties(chkShowExpertProperties.isSelected());
      }
    }
  );
  add(inspectorCard,INSPECTOR_CARD);

  // Empty card
  final MultiLineLabel label = new MultiLineLabel(UIDesignerBundle.message("label.select.single.component.to.edit.its.properties")){
    public void updateUI() {
      super.updateUI();
      setBackground(myInspectorTable.getBackground());
    }
  };
  label.setopaque(true);
  label.setHorizontalAlignment(SwingConstants.CENTER);
  add(label,EMPTY_CARD);
  add(myCustomPropertiesScrollPane,CUSTOM_CARD);

  myComponentSelectionListener = new MyComponentSelectionListener();
  synchWithTree(false);

  // Install light bulb
  myQuickFixManager = new QuickFixManagerImpl(null,myInspectorTable,inspectorScrollPane.getViewport());

  myCustomPropertieschangelistener = new changelistener() {
    public void stateChanged(ChangeEvent e) {
      if (myPropertiesPanelContainer != null) {
        myPropertiesPanelContainer.revalidate();
      }
      if (myEditor.ensureEditable()) {
        myEditor.refreshAndSave(true);
      }
    }
  };
}

public DesignerToolWindow(Project project,0.42f) {
    @Override
    public void doLayout() {
      super.doLayout();

      JComponent firstComponent = getFirstComponent();
      JComponent secondComponent = getSecondComponent();
      if (firstComponent == null || secondComponent == null) {
        return;
      }

      int firstHeight = firstComponent.getHeight();
      int dividerHeight = getDivider().getHeight();
      int height = getSize().height;

      if (firstHeight + dividerHeight + secondComponent.getHeight() != height) {
        Rectangle bounds = secondComponent.getBounds();
        bounds.height = height - firstHeight - dividerHeight;
        secondComponent.setBounds(bounds);
      }
    }
  };

  myToolWindowPanel.setDividerWidth(3);
  myToolWindowPanel.setShowDividerControls(false);
  myToolWindowPanel.setShowDividerIcon(false);
  myToolWindowPanel.setFirstComponent(treeScrollPane);
  myToolWindowPanel.setSecondComponent(myPropertyTablePanel);

  if (updateOrientation) {
    myToolWindowPanel.addComponentListener(new ComponentAdapter() {
      @Override
      public void componentResized(ComponentEvent e) {
        Dimension size = myToolWindowPanel.getSize();
        boolean newVertical = size.width < size.height;
        if (myToolWindowPanel.getorientation() != newVertical) {
          myToolWindowPanel.setorientation(newVertical);
        }
      }
    });
  }
}

public PropertyTablePanel(final Project project) {
  myPropertyTable = new RadPropertyTable(project) {
    @Override
    protected void updateEditactions() {
      updateActions();
    }
  };

  setLayout(new GridBagLayout());

  int gridX = 0;

  myTitleLabel = new JLabel(DesignerBundle.message("designer.properties.title"));
  myTitleLabel.setFont(UIUtil.getLabelFont(UIUtil.FontSize.SMALL));
  add(myTitleLabel,new GridBagConstraints(gridX++,GridBagConstraints.HORIZONTAL,new Insets(2,5,2,10),0)
  );

  ActionManager actionManager = ActionManager.getInstance();
  DefaultActionGroup actionGroup = new DefaultActionGroup();

  ShowJavadoc showJavadoc = new ShowJavadoc(myPropertyTable);
  showJavadoc.registerCustomShortcutSet(actionManager.getAction(IdeActions.ACTION_QUICK_JAVADOC).getShortcutSet(),myPropertyTable);
  actionGroup.add(showJavadoc);

  actionGroup.addSeparator();

  RestoreDefault restoreDefault = new RestoreDefault(myPropertyTable);
  restoreDefault.registerCustomShortcutSet(actionManager.getAction(IdeActions.ACTION_DELETE).getShortcutSet(),myPropertyTable);
  actionGroup.add(restoreDefault);

  actionGroup.add(new ShowExpert(myPropertyTable));

  myTabPanel = new JPanel(new FlowLayout(FlowLayout.CENTER,0));
  add(myTabPanel,GridBagConstraints.LINE_START,0)
  );

  myActionPanel = new JPanel(new FlowLayout(FlowLayout.CENTER,0));
  add(myActionPanel,2),0)
  );

  myActions = actionGroup.getChildren(null);
  for (AnAction action : myActions) {
    if (action instanceof Separator) {
      continue;
    }

    Presentation presentation = action.getTemplatePresentation();
    ActionButton button = new ActionButton(action,presentation,ActionPlaces.UNKNowN,ActionToolbar.DEFAULT_MINIMUM_BUTTON_SIZE);
    myActionPanel.add(button);
    presentation.putClientProperty(BUTTON_KEY,button);
  }

  actionGroup.add(new ShowColumns(myPropertyTable));

  PopupHandler.installPopupHandler(myPropertyTable,ActionPlaces.GUI_DESIGNER_PROPERTY_INSPECTOR_POPUP,actionManager);

  myPropertyTable.getSelectionModel().addListSelectionListener(this);
  valueChanged(null);

  JScrollPane scrollPane = ScrollPaneFactory.createScrollPane(myPropertyTable);
  scrollPane.setBorder(IdeBorderFactory.createBorder(SideBorder.TOP));
  myPropertyTable.initQuickFixManager(scrollPane.getViewport());
  add(scrollPane,gridX,0));

  myPropertyTable.setPropertyTablePanel(this);

  addMouseListener(new MouseAdapter() {
    public void mouseReleased(final MouseEvent e) {
      IdeFocusManager.getInstance(project).requestFocus(myPropertyTable,true);
    }
  });
}

public PantsConsoleViewPanel(Project project) {
  myProject = project;
  myConfiguration = ErrorTreeViewConfiguration.getInstance(project);
  setLayout(new BorderLayout());

  myAutoScrollToSourceHandler = new AutoScrollToSourceHandler() {
    @Override
    protected boolean isAutoScrollMode() {
      return myConfiguration.isAutoscrollToSource();
    }

    @Override
    protected void setAutoScrollMode(boolean state) {
      myConfiguration.setAutoscrollToSource(state);
    }
  };

  JPanel myMessagePanel = new JPanel(new BorderLayout());

  DefaultMutableTreeNode root = new DefaultMutableTreeNode();
  final DefaultTreeModel treeModel = new DefaultTreeModel(root);
  myTree = createTree(treeModel);
  myTree.getEmptyText().setText(IdeBundle.message("errortree.noMessages"));

  myAutoScrollToSourceHandler.install(myTree);
  TreeUtil.installActions(myTree);
  UIUtil.setLinestyleAngled(myTree);
  myTree.setRootVisible(false);
  myTree.setShowsRootHandles(true);
  myTree.setLargeModel(true);

  JScrollPane scrollPane = NewErrorTreeRenderer.install(myTree);
  scrollPane.setBorder(IdeBorderFactory.createBorder(SideBorder.LEFT));
  myMessagePanel.add(PantsConsoleManager.getorMakeNewConsole(myProject).getComponent(),BorderLayout.CENTER);

  add(createtoolbarPanel(),BorderLayout.WEST);

  add(myMessagePanel,BorderLayout.CENTER);

  EditSourceondoubleclickHandler.install(myTree);
}

private TablessBorder() {
  super(UIUtil.getBorderColor(),SideBorder.ALL);
}

public NewErrorTreeViewPanel(Project project,@Nullable Runnable rerunAction) {
  myProject = project;
  myHelpId = helpId;
  myCreateExitaction = createExitaction;
  myConfiguration = ErrorTreeViewConfiguration.getInstance(project);
  setLayout(new BorderLayout());

  myAutoScrollToSourceHandler = new AutoScrollToSourceHandler() {
    protected boolean isAutoScrollMode() {
      return myConfiguration.isAutoscrollToSource();
    }

    protected void setAutoScrollMode(boolean state) {
      myConfiguration.setAutoscrollToSource(state);
    }
  };

  myMessagePanel = new JPanel(new BorderLayout());

  myErrorViewStructure = new ErrorViewStructure(project,null));
  final DefaultTreeModel treeModel = new DefaultTreeModel(root);
  myTree = new Tree(treeModel) {
    public void setRowHeight(int i) {
      super.setRowHeight(0);
      // this is needed in order to make UI calculate the height for each particular row
    }
  };
  myBuilder = new ErrorViewTreeBuilder(myTree,myErrorViewStructure);

  myExporterToTextFile = new ErrorViewTextExporter(myErrorViewStructure);
  myOccurenceNavigatorSupport = new MyOccurenceNavigatorSupport(myTree);

  myAutoScrollToSourceHandler.install(myTree);
  TreeUtil.installActions(myTree);
  UIUtil.setLinestyleAngled(myTree);
  myTree.setRootVisible(false);
  myTree.setShowsRootHandles(true);
  myTree.setLargeModel(true);

  JScrollPane scrollPane = NewErrorTreeRenderer.install(myTree);
  scrollPane.setBorder(IdeBorderFactory.createBorder(SideBorder.LEFT));
  myMessagePanel.add(scrollPane,BorderLayout.CENTER);

  myTree.addKeyListener(new KeyAdapter() {
    public void keypressed(KeyEvent e) {
      if (e.getKeyCode() == KeyEvent.VK_ENTER) {
        navigatetoSource(false);
      }
    }
  });

  myTree.addMouseListener(new PopupHandler() {
    public void invokePopup(Component comp,y);
    }
  });

  EditSourceondoubleclickHandler.install(myTree);
}

private void setChangeDetailsPanel(@Nullable final JComponent component) {
  mySplitter.setSecondComponent(component);
  mySplitter.getFirstComponent().setBorder(component == null ? null : IdeBorderFactory.createBorder(SideBorder.RIGHT));
  mySplitter.revalidate();
  mySplitter.repaint();
}

@Override
public void setupUIComponentPresentation(final String[] texts,final Color background) {
  myPanels[i].setup(texts,SideBorder.BottOM));
}

private void initConsoleUI(Process process) {
    // Init console view
    myConsoleView = createConsoleView();
    myConsoleView.setBorder(new SideBorder(UIUtil.getBorderColor(),SideBorder.LEFT));

    myProcessHandler = createProcessHandler(process);

    myConsoleExecuteActionHandler = createConsoleExecuteActionHandler();

    ProcessterminatedListener.attach(myProcessHandler);

    myProcessHandler.addProcessListener(new ProcessAdapter() {
      @Override
      public void processterminated(ProcessEvent event) {
        finishConsole();
      }
    });

// Attach to process
    myConsoleView.attachToProcess(myProcessHandler);

// Runner creating
    final Executor defaultExecutor = DefaultRunExecutor.getRunExecutorInstance();
    final DefaultActionGroup toolbaractions = new DefaultActionGroup();
    final ActionToolbar actionToolbar = ActionManager.getInstance().createActionToolbar(ActionPlaces.UNKNowN,false);

// Runner creating
    final JPanel panel = new JPanel(new BorderLayout());
    panel.add(actionToolbar.getComponent(),BorderLayout.WEST);
    panel.add(myConsoleView.getComponent(),BorderLayout.CENTER);

    actionToolbar.setTargetComponent(panel);

    final runcontentDescriptor contentDescriptor =
      new runcontentDescriptor(myConsoleView,myProcessHandler,panel,constructConsoleTitle(myConsoleTitle));

    contentDescriptor.setFocusComputable(new Computable<JComponent>() {
      @Override
      public JComponent compute() {
        final EditorEx editor = getLanguageConsole().getConsoleEditor();
        return editor != null ? editor.getContentComponent() : null;
      }
    });
    contentDescriptor.setAutoFocusContent(isAutoFocusContent());


// tool bar actions
    final List<AnAction> actions = fillToolBaractions(toolbaractions,defaultExecutor,contentDescriptor);
    registeractionShortcuts(actions,getLanguageConsole().getConsoleEditor().getComponent());
    registeractionShortcuts(actions,panel);
    panel.updateUI();
    showConsole(defaultExecutor,contentDescriptor);

// Run
    myProcessHandler.startNotify();
  }

@Override
public void navigateInPreviewEditor(PreviewEditorState editorState) {
  myEditorState = editorState;

  final VirtualFile file = editorState.getFile();
  final LogicalPosition positionToNavigate = editorState.getNavigate();
  final TextAttributes lineAttributes = editorState.getAttributes();
  Document document = FileDocumentManager.getInstance().getDocument(file);
  Project project = myProject;

  clearEditor();
  remove(myLabel);
  if (document != null) {
    if (getEditor() == null || getEditor().getDocument() != document) {
      setEditor(EditorFactory.getInstance().createViewer(document,project);

      ((EditorEx)getEditor()).setFile(file);
      ((EditorEx)getEditor()).setHighlighter(Highlighter);

      getEditor().getSettings().setAnimatedScrolling(false);
      getEditor().getSettings().setRefrainFromScrolling(false);
      getEditor().getSettings().setLineNumbeRSShown(true);
      getEditor().getSettings().setFoldingOutlineshown(false);

      add(getEditor().getComponent(),BorderLayout.CENTER);
    }

    getEditor().getCaretModel().movetoLogicalPosition(positionToNavigate);
    validate();
    getEditor().getScrollingModel().scrollToCaret(ScrollType.CENTER);

    getEditor().setBorder(IdeBorderFactory.createBorder(SideBorder.TOP));

    clearHightlighting();
    if (lineAttributes != null) {
      myHighlighter = getEditor().getMarkupModel().addLineHighlighter(positionToNavigate.line,BorderLayout.CENTER);
    validate();
  }
}

private void createUI() {
    if (cellRenderer == null || list == null) {
        cellRenderer = new ThumbnailListCellRenderer();
        ImageComponent imageComponent = cellRenderer.getimageComponent();

        VirtualFileManager.getInstance().addVirtualFileListener(vfsListener);

        Options options = OptionsManager.getInstance().getoptions();
        EditorOptions editorOptions = options.getEditorOptions();
        // Set options
        TransparencyChessboardOptions chessboardOptions = editorOptions.getTransparencyChessboardOptions();
        imageComponent.setTransparencyChessboardVisible(chessboardOptions.isShowDefault());
        imageComponent.setTransparencyChessboardCellSize(chessboardOptions.getCellSize());
        imageComponent.setTransparencyChessboardWhiteColor(chessboardOptions.getWhiteColor());
        imageComponent.setTransparencyChessboardBlankColor(chessboardOptions.getBlackColor());

        options.addPropertychangelistener(optionsListener);

        list = new JBList();
        list.setModel(new DefaultListModel());
        list.setLayoutOrientation(JList.HORIZONTAL_WRAP);
        list.setVisibleRowCount(-1);
        list.setCellRenderer(cellRenderer);
        list.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);

        ThumbnailsMouseAdapter mouseListener = new ThumbnailsMouseAdapter();
        list.addMouseListener(mouseListener);
        list.addMouseMotionListener(mouseListener);

        ThumbnailComponentUI componentUI = (ThumbnailComponentUI) UIManager.getUI(cellRenderer);
        Dimension preferredSize = componentUI.getPreferredSize(cellRenderer);

        list.setFixedCellWidth(preferredSize.width);
        list.setFixedCellHeight(preferredSize.height);


      JScrollPane scrollPane =
        ScrollPaneFactory.createScrollPane(list,ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED,ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
      scrollPane.setBorder(IdeBorderFactory.createBorder(SideBorder.TOP));

        ActionManager actionManager = ActionManager.getInstance();
        ActionGroup actionGroup = (ActionGroup) actionManager.getAction(ThumbnailViewActions.GROUP_TOOLBAR);
        ActionToolbar actionToolbar = actionManager.createActionToolbar(
                ThumbnailViewActions.ACTION_PLACE,true
        );
        actionToolbar.setTargetComponent(this);

        JComponent toolbar = actionToolbar.getComponent();

        FocusRequester focusRequester = new FocusRequester();
        toolbar.addMouseListener(focusRequester);
        scrollPane.addMouseListener(focusRequester);

        add(toolbar,BorderLayout.norTH);
        add(scrollPane,BorderLayout.CENTER);
    }
}

public static JScrollPane install(JTree tree) {
  JScrollPane scrollPane = MultilineTreeCellRenderer.installrenderer(tree,new MessageTreeRenderer());
  scrollPane.setBorder(IdeBorderFactory.createBorder(SideBorder.LEFT));
  return scrollPane;
}

public PropertyInspector(Project project,inspectorScrollPane.getViewport());

  myCustomPropertieschangelistener = new changelistener() {
    public void stateChanged(ChangeEvent e) {
      if (myPropertiesPanelContainer != null) {
        myPropertiesPanelContainer.revalidate();
      }
      if (myEditor.ensureEditable()) {
        myEditor.refreshAndSave(true);
      }
    }
  };
}

public PropertyTablePanel(final Project project) {
  myPropertyTable = new RadPropertyTable(project);

  setLayout(new GridBagLayout());

  int gridX = 0;

  myTitleLabel = new JLabel(DesignerBundle.message("designer.properties.title"));
  myTitleLabel.setFont(UIUtil.getLabelFont(UIUtil.FontSize.SMALL));
  add(myTitleLabel,0));

  ActionManager actionManager = ActionManager.getInstance();
  DefaultActionGroup actionGroup = new DefaultActionGroup();

  ShowJavadoc showJavadoc = new ShowJavadoc(myPropertyTable);
  showJavadoc.registerCustomShortcutSet(actionManager.getAction(IdeActions.ACTION_QUICK_JAVADOC).getShortcutSet(),null);
  actionGroup.add(restoreDefault);

  actionGroup.add(new ShowExpert(myPropertyTable));

  myTabPanel = new JPanel(new FlowLayout(FlowLayout.CENTER,0));

  myActionPanel = new JPanel(new FlowLayout(FlowLayout.CENTER,0));

  myActions = actionGroup.getChildren(null);
  for (int i = 0; i < myActions.length; i++) {
    AnAction action = myActions[i];
    if (!(action instanceof Separator)) {
      Presentation presentation = action.getTemplatePresentation();
      ActionButton button = new ActionButton(action,ActionToolbar.DEFAULT_MINIMUM_BUTTON_SIZE);
      myActionPanel.add(button);
      presentation.putClientProperty(BUTTON_KEY,button);
    }
  }

  actionGroup.add(new ShowColumns(myPropertyTable));

  PopupHandler.installPopupHandler(myPropertyTable,true);
    }
  });
}

@Nullable
@Override
public WordsScanner getWordsScanner()
{
  return new SimpleWordsScanner();
}

@Override
@Nullable
public WordsScanner getWordsScanner() {
    return new SimpleWordsScanner();
}

@Nullable
public WordsScanner getWordsScanner() {
    return new SimpleWordsScanner();
}

@Override
public void parseLight(IElementType elementType,PsiBuilder builder) {
    builder = adapt_builder_(elementType,builder,this,null);
    PsiBuilder.Marker m = enter_section_(builder,_COLLAPSE_,null);


    ParserState parserState = new ParserState(new ParserScope(file,m_types.FILE_MODULE,null));
    parseFile(builder,parserState);

    // if we have a scope at last position in file,without SEMI,we need to handle it here
    if (!parserState.scopes.empty()) {
        ParserScope scope = parserState.scopes.pop();
        while (scope != null) {
            scope.end();
            scope = parserState.scopes.empty() ? null : parserState.scopes.pop();
        }
    }

    new ParserScope(file,null).end();

    exit_section_(builder,m,elementType,true,TRUE_CONDITION);
}

public static boolean withTimeoutStatement(PsiBuilder b,int l) {
  if (!recursion_guard_(b,l,"withTimeoutStatement")) return false;
  if (!nextTokenIs(b,WITH)) return false;
  boolean r,p;
  Marker m = enter_section_(b,_NONE_,WITH_TIMEOUT_STATEMENT,null);
  r = consumetokens(b,2,WITH,TIMEOUT);
  p = r; // pin = 2
  r = r && report_error_(b,withTimeoutStatement_2(b,l + 1));
  r = p && report_error_(b,timeoutIntegerExpression(b,l + 1)) && r;
  r = p && report_error_(b,withTimeoutStatement_4(b,sep(b,withTimeoutStatement_6(b,consumetoken(b,END)) && r;
  r = p && withTimeoutStatement_8(b,l + 1) && r;
  exit_section_(b,r,p,null);
  return r || p;
}

public static boolean consideringStatement(PsiBuilder b,"consideringStatement")) return false;
  if (!nextTokenIs(b,CONSIDERING)) return false;
  boolean r,CONSIDERING_STATEMENT,null);
  r = consumetoken(b,CONSIDERING);
  r = r && considerOrIgnoreAttr(b,l + 1);
  p = r; // pin = 2
  r = r && report_error_(b,consideringStatement_2(b,consideringStatement_3(b,consideringStatement_5(b,consumetokens(b,-1,END,CONSIDERING)) && r;
  exit_section_(b,null);
  return r || p;
}

private void parseRParen(PsiBuilder builder,ParserState parserState) {
    ParserScope scope = parserState.endUntilScopeExpression(m_types.LPAREN);

    builder.advanceLexer();
    parserState.dontMove = true;

    if (scope != null) {
        scope.complete = true;
        parserState.scopes.pop().end();
        scope = parserState.getLatestScope();
        if (scope != null && scope.resolution == letNamedEq) {
            scope.resolution = letNamedEqParameters;
        }
    }

    parserState.updateCurrentScope();
}

public void parseLight(IElementType t,PsiBuilder b) {
  boolean r;
  b = adapt_builder_(t,b,null);
  Marker m = enter_section_(b,null);
  if (t == COMMENT) {
    r = comment(b,0);
  }
  else if (t == EMPTY_LINE) {
    r = empty_line(b,0);
  }
  else if (t == PROPERTY) {
    r = property(b,0);
  }
  else {
    r = parse_root_(t,0);
  }
  exit_section_(b,t,TRUE_CONDITION);
}

private static boolean boolean_test_1_0(PsiBuilder b,"boolean_test_1_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumetoken(b,IS);
  r = r && boolean_test_1_0_1(b,l + 1);
  r = r && truth_value(b,l + 1);
  exit_section_(b,null,r);
  return r;
}

private static boolean goalQuery_0(PsiBuilder b,"goalQuery_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumetoken(b,GOAL);
  if (!r) r = consumetoken(b,AGOAL);
  if (!r) r = consumetoken(b,GOALA);
  exit_section_(b,r);
  return r;
}

private static boolean nakedTerm_0_1(PsiBuilder b,"nakedTerm_0_1")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = nakedTerm_0_1_0(b,l + 1);
  int c = current_position_(b);
  while (r) {
    if (!nakedTerm_0_1_0(b,l + 1)) break;
    if (!empty_element_parsed_guard_(b,"nakedTerm_0_1",c)) break;
    c = current_position_(b);
  }
  exit_section_(b,r);
  return r;
}

private static boolean ACTION_ParaMS_B_1(PsiBuilder b,"ACTION_ParaMS_B_1")) return false;
  int c = current_position_(b);
  while (true) {
    if (!ACTION_ParaMS_B_1_0(b,"ACTION_ParaMS_B_1",c)) break;
    c = current_position_(b);
  }
  return true;
}

public static boolean select_sublist(PsiBuilder b,"select_sublist")) return false;
  boolean r;
  Marker m = enter_section_(b,SELECT_SUBLIST,"<select sublist>");
  r = derived_column(b,l + 1);
  if (!r) r = select_sublist_1(b,false,null);
  return r;
}

public static boolean rawClassExpression(PsiBuilder b,"rawClassExpression")) return false;
  if (!nextTokenIsFast(b,RAW_LBR)) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumetokens(b,RAW_LBR,CLASS);
  r = r && identifier(b,l + 1);
  r = r && consumetoken(b,RAW_RBR);
  exit_section_(b,RAW_CLASS_EXPRESSION,r);
  return r;
}

static boolean orderProperty(PsiBuilder b,"orderProperty")) return false;
  if (!nextTokenIs(b,ORDER)) return false;
  boolean r,_NONE_);
  r = consumetokens(b,1,ORDER,EQ,ORDER_VAL,DOT);
  p = r; // pin = 1
  exit_section_(b,null);
  return r || p;
}

/**
 * @param b PsiBuilder
 * @return Returns application name inside targeted to application blocks of
 * code: "tell"/"using terms from" statements. <br> If nothing found - returns available to all scripting
 * application CocoaStandard library name
 */
@NotNull
private static String getTargetApplicationName(PsiBuilder b) {
  String toldApplicationName = peekTargetApplicationName(b);
  // CocoaStandard library is always available for the scriptable application
  return toldApplicationName != null ? toldApplicationName : ApplicationDictionary.COCOA_STANDARD_LIBRARY;
}

private static boolean identifier_chain_1_0_0_1(PsiBuilder b,"identifier_chain_1_0_0_1")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumetoken(b,IDENTIFIER);
  if (!r) r = consumetoken(b,COLUMN_REFERENCE_IDENTIFIER);
  exit_section_(b,r);
  return r;
}

public static boolean builtInClassIdentifierPlural(PsiBuilder b,"builtInClassIdentifierPlural")) return false;
  if (!nextTokenIs(b,"<built in class identifier plural>",BUILT_IN_TYPE_S,SCRIPTS)) return false;
  boolean r;
  Marker m = enter_section_(b,BUILT_IN_CLASS_IDENTIFIER_PLURAL,"<built in class identifier plural>");
  r = consumetoken(b,BUILT_IN_TYPE_S);
  if (!r) r = consumetoken(b,SCRIPTS);
  exit_section_(b,null);
  return r;
}

public static boolean parseAssignmentStatementInner(PsiBuilder b,"parseAssignmentStatementInner")) return false;
  boolean r;
  b.putUserData(PARSING_COMMAND_ASSIGNMENT_STATEMENT,true);
  r = AppleScriptParser.assignmentStatement(b,l + 1);
  b.putUserData(PARSING_COMMAND_ASSIGNMENT_STATEMENT,false);
  return r;
}

static boolean simpleQuery(PsiBuilder b,"simpleQuery")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = selectorQuery(b,l + 1);
  if (!r) r = predicate(b,r);
  return r;
}

public static boolean predicate(PsiBuilder b,"predicate")) return false;
  if (!nextTokenIs(b,ATOM)) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumetoken(b,ATOM);
  r = r && predicate_1(b,PREDICATE,r);
  return r;
}

public static boolean sort_specification_list(PsiBuilder b,"sort_specification_list")) return false;
  boolean r;
  Marker m = enter_section_(b,SORT_SPECIFICATION_LIST,"<sort specification list>");
  r = sort_specification(b,l + 1);
  r = r && sort_specification_list_1(b,null);
  return r;
}

static boolean objectPointer(PsiBuilder b,"objectPointer")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumetoken(b,OF);
  if (!r) r = consumetoken(b,IN);
  if (!r) r = consumetoken(b,APS);
  if (!r) r = isPossessivePpronoun(b,r);
  return r;
}

private static boolean countCommandExpression_0_1_0_2(PsiBuilder b,"countCommandExpression_0_1_0_2")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumetokenFast(b,IN);
  if (!r) r = consumetokenFast(b,OF);
  exit_section_(b,r);
  return r;
}

private static boolean handlerLabeledParametersCallExpression_0_2_1_0_1_2_0(PsiBuilder b,"handlerLabeledParametersCallExpression_0_2_1_0_1_2_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumetokenFast(b,COMMA);
  r = r && labelForFalseParam(b,r);
  return r;
}

static boolean offendingObject(PsiBuilder b,"offendingObject")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = offendingObject_0(b,l + 1);
  if (!r) r = expression(b,r);
  return r;
}

private static boolean stopValue_0_1(PsiBuilder b,"stopValue_0_1")) return false;
  boolean r;
  Marker m = enter_section_(b,_AND_);
  r = consumetoken(b,BY);
  exit_section_(b,null);
  return r;
}

public static boolean table_expression(PsiBuilder b,"table_expression")) return false;
  if (!nextTokenIs(b,FROM)) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = from_clause(b,l + 1);
  r = r && table_expression_1(b,l + 1);
  r = r && table_expression_2(b,l + 1);
  r = r && table_expression_3(b,TABLE_EXPRESSION,r);
  return r;
}

public static boolean ACTION_DECLaraTION(PsiBuilder b,"ACTION_DECLaraTION")) return false;
  if (!nextTokenIs(b,IDENT)) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumetoken(b,IDENT);
  r = r && ACTION_DECLaraTION_1(b,ACTION_DECLaraTION,r);
  return r;
}

private static boolean termlist_1_0(PsiBuilder b,"termlist_1_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumetoken(b,COMMA);
  r = r && term(b,r);
  return r;
}

private static boolean ignoringStatement_3_0_3_0_1_0(PsiBuilder b,"ignoringStatement_3_0_3_0_1_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumetoken(b,LAND);
  r = r && considerOrIgnoreAttr(b,r);
  return r;
}

static boolean column_reference_recover(PsiBuilder b,"column_reference_recover")) return false;
  boolean r;
  Marker m = enter_section_(b,_NOT_);
  r = !column_reference_recover_0(b,null);
  return r;
}

private static boolean launchRule_0_0(PsiBuilder b,"launchRule_0_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumetoken(b,WHEN);
  r = r && entity(b,r);
  return r;
}

public static boolean basicTerm(PsiBuilder b,"basicTerm")) return false;
  boolean r;
  Marker m = enter_section_(b,BASIC_TERM,"<term>");
  r = predicate(b,l + 1);
  if (!r) r = consumetoken(b,VARIABLE);
  if (!r) r = number(b,l + 1);
  if (!r) r = string(b,l + 1);
  if (!r) r = basicTerm_4(b,l + 1);
  if (!r) r = list(b,null);
  return r;
}

private static boolean entity_2(PsiBuilder b,"entity_2")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumetokens(b,NAME,EQ);
  r = r && simpleIdentifier(b,r);
  return r;
}

private static boolean modifiers_1_1_0(PsiBuilder b,"modifiers_1_1_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumetoken(b,ATTRIBUTE_SEParaTOR);
  r = r && modifiers_1_1_0_1(b,r);
  return r;
}

private static boolean countCommandExpression_1(PsiBuilder b,"countCommandExpression_1")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumetokens(b,NUMBER,OF);
  r = r && countCommandExpression_1_2(b,l + 1);
  r = r && composite_value(b,r);
  return r;
}

private static boolean instruction_1_0(PsiBuilder b,"instruction_1_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumetoken(b,WITH);
  r = r && constraintList(b,r);
  return r;
}

private static boolean any_attribute_value_0(PsiBuilder b,"any_attribute_value_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumetoken(b,ATTRIBUTE_VALUE);
  if (!r) r = consumetoken(b,BOOLEAN);
  if (!r) r = consumetoken(b,DIGIT);
  if (!r) r = string(b,l + 1);
  if (!r) r = macro_usage_dec(b,r);
  return r;
}

public static boolean useClause(PsiBuilder b,"useClause")) return false;
  if (!nextTokenIs(b,USE)) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumetoken(b,USE);
  r = r && moduleId(b,AS);
  r = r && useCase(b,DOT);
  exit_section_(b,USE_CLAUSE,r);
  return r;
}

public static boolean rule(PsiBuilder b,"rule")) return false;
  boolean r;
  Marker m = enter_section_(b,RULE,"<rule>");
  r = leadstoRule(b,l + 1);
  if (!r) r = eventuallyRule(b,null);
  return r;
}

private static boolean NTUPLE_VALUE_2_0(PsiBuilder b,"NTUPLE_VALUE_2_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumetoken(b,COMMA);
  r = r && NTUPLE_VALUE_2_0_1(b,r);
  return r;
}

private static boolean consideringStatement_2_0_1_0(PsiBuilder b,"consideringStatement_2_0_1_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumetoken(b,r);
  return r;
}

@Override
protected Divider createDivider() {
  return new DividerImpl() {
    @Override
    protected void paintComponent(Graphics g) {
      super.paintComponent(g);
      if (myPainter != null) myPainter.paint(g,this);
    }
  };
}

private boolean canProcessCursorFor(Component target) {
  if (target instanceof JMenu ||
      target instanceof JMenuItem ||
      target instanceof Divider ||
      target instanceof JSeparator ||
      (target instanceof JEditorPane && ((JEditorPane)target).getEditorKit() instanceof HTMLEditorKit)) {
    return false;
  }
  return true;
}

protected Divider createDivider() {
  return new DividerImpl(){
    public void paint(Graphics g) {
      super.paint(g);
      myPaint.paint(g,this);
      myData.drawOnDivider(g,this);
    }
  };
}

@Override
protected Divider createDivider() {
  return new DividerImpl() {
    @Override
    public void setorientation(boolean isverticalSplit) {
      if (!isvertical()) LOG.warn("unsupported state: splitter should be vertical");

      removeAll();

      setCursor(Cursor.getPredefinedCursor(Cursor.N_RESIZE_CURSOR));

      JLabel label = new JLabel(myLabelText);
      label.setFont(UIUtil.getoptionPaneMessageFont());
      label.setForeground(UIUtil.getLabelForeground());
      add(label,new GridBagConstraints(0,1,GridBagConstraints.CENTER,GridBagConstraints.NONE,JBUI.insets(2),0));
      setDividerWidth(label.getPreferredSize().height + JBUI.scale(4));

      revalidate();
      repaint();
    }

    @Override
    protected void paintComponent(Graphics g) {
      super.paintComponent(g);
      g.setColor(JBColor.border());
      UIUtil.drawLine(g,getWidth(),0);
    }
  };
}

@Override
protected Divider createDivider() {
  return new DividerImpl() {
    @Override
    public void setorientation(boolean isverticalSplit) {
      removeAll();
      setCursor(Cursor.getPredefinedCursor(Cursor.W_RESIZE_CURSOR));

      List<JComponent> actionComponents = ContainerUtil.list(createActionComponent(myTopAction),createActionComponent(myBottomAction));
      List<JComponent> syncComponents = DiffUtil.createSyncHeightComponents(actionComponents);


      GridBag bag = new GridBag();

      if (syncComponents.get(0) != null) {
        add(syncComponents.get(0),bag.nextLine());
        add(Box.createVerticalStrut(JBUI.scale(20)),bag.nextLine());
      }

      add(new JLabel(AllIcons.General.SplitglueH),bag.nextLine());

      if (syncComponents.get(1) != null) {
        add(Box.createVerticalStrut(JBUI.scale(20)),bag.nextLine());
        add(syncComponents.get(1),bag.nextLine());
      }


      revalidate();
      repaint();
    }

    @Override
    protected void paintComponent(Graphics g) {
      super.paintComponent(g);
      if (myPainter != null) myPainter.paint(g,this);
    }
  };
}

private boolean canProcessCursorFor(Component target) {
  if (target instanceof JMenu ||
      target instanceof JMenuItem ||
      target instanceof Divider ||
      target instanceof JSeparator ||
      (target instanceof JEditorPane && ((JEditorPane)target).getEditorKit() instanceof HTMLEditorKit)) {
    return false;
  }
  return true;
}

@Override
protected Divider createDivider() {
  return new DividerImpl(){
    @Override
    public void paint(Graphics g) {
      super.paint(g);
      myPaint.paint(g,this);
    }
  };
}

@Override
protected Divider createDivider() {
  return new OnePixelDivider(isvertical(),this);
}

@Override
protected Divider createDivider() {
  return new OnePixelDivider(isvertical(),this);
}

@Override
protected Divider createDivider() {
  return new OnePixelDivider(isvertical(),this);
}

@Override
protected void paintComponent(final Graphics g) {
  super.paintComponent(g);

  final Graphics2D g2d = (Graphics2D)g;

  Point pointTarget = SwingUtilities.convertPoint(mylayeredPane,myBalloon.myTargetPoint,this);

  Rectangle shapeBounds = myContent.getBounds();

  final int shadowSize = myBalloon.getShadowBorderSize();
  if (shadowSize > 0) {
    if (myShadow == null) {
      initComponentimage(pointTarget,shapeBounds);
      myShadow = ShadowBorderPainter.createShadow(myImage,false,shadowSize / 2);
    }
  }

  if (myImage == null && myAlpha != -1) {
    initComponentimage(pointTarget,shapeBounds);
  }

  if (myImage != null && myAlpha != -1) {
    g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,myAlpha));
    paintShadow(g);
    UIUtil.drawImage(g2d,myImage,null);
  }
  else {
    paintShadow(g);
    myBalloon.myPosition.paintComponent(myBalloon,shapeBounds,(Graphics2D)g,pointTarget);
  }
}

@Override
protected void paintComponent(final Graphics g) {
  super.paintComponent(g);

  final Graphics2D g2d = (Graphics2D)g;

  Point pointTarget = SwingUtilities.convertPoint(mylayeredPane,myAlpha));

    UIUtil.drawImage(g2d,null);
  }
  else {
    if (myShadow != null) {
      UIUtil.drawImage(g,myShadow.getimage(),myShadow.getX(),myShadow.getY(),null);
    }
    myBalloon.myPosition.paintComponent(myBalloon,pointTarget);
  }
}

@Override
protected void paintComponent(final Graphics g) {
  super.paintComponent(g);

  final Graphics2D g2d = (Graphics2D)g;

  Point pointTarget = SwingUtilities.convertPoint(mylayeredPane,this);
  Rectangle shapeBounds = myContent.getBounds();
  int shadowSize = myBalloon.getShadowBorderSize();

  if (shadowSize > 0 && myShadow == null && myShadowBorderProvider == null) {
    initComponentimage(pointTarget,shapeBounds);
    myShadow = ShadowBorderPainter.createShadow(myImage,shadowSize / 2);
  }

  if (myImage == null && myAlpha != -1) {
    initComponentimage(pointTarget,myAlpha));
  }

  if (myShadowBorderProvider != null) {
    myShadowBorderProvider.paintShadow(this,g);
  }

  if (myImage != null && myAlpha != -1) {
    paintShadow(g);
    UIUtil.drawImage(g2d,pointTarget);
  }
}