private boolean hasBlankLineAbove() {
    if (mOut.length() < 2 * mLineSeparator.length()) {
      return false;
    }

    return SdkUtils.endsWith(mOut, mLineSeparator)
        && SdkUtils.endsWith(mOut, mOut.length() - mLineSeparator.length(), mLineSeparator);
  }
  private void addLayoutFileChanges(IProject project, CompositeChange result) {
    try {
      // Update references in XML resource files
      IFolder resFolder = project.getFolder(SdkConstants.FD_RESOURCES);

      IResource[] folders = resFolder.members();
      for (IResource folder : folders) {
        String folderName = folder.getName();
        ResourceFolderType folderType = ResourceFolderType.getFolderType(folderName);
        if (folderType != ResourceFolderType.LAYOUT) {
          continue;
        }
        if (!(folder instanceof IFolder)) {
          continue;
        }
        IResource[] files = ((IFolder) folder).members();
        for (int i = 0; i < files.length; i++) {
          IResource member = files[i];
          if ((member instanceof IFile) && member.exists()) {
            IFile file = (IFile) member;
            String fileName = member.getName();

            if (SdkUtils.endsWith(fileName, DOT_XML)) {
              addXmlFileChanges(file, result, false);
            }
          }
        }
      }
    } catch (CoreException e) {
      RefactoringUtil.log(e);
    }
  }
 /**
  * Creates a new {@link XmlPrettyPrinter}
  *
  * @param prefs the preferences to format with
  * @param style the style to format with
  * @param lineSeparator the line separator to use, such as "\n" (can be null, in which case the
  *     system default is looked up via the line.separator property)
  */
 public XmlPrettyPrinter(XmlFormatPreferences prefs, XmlFormatStyle style, String lineSeparator) {
   mPrefs = prefs;
   mStyle = style;
   if (lineSeparator == null) {
     lineSeparator = SdkUtils.getLineSeparator();
   }
   mLineSeparator = lineSeparator;
 }
 /**
  * Pretty prints the given node using default styles
  *
  * @param node the node, usually a document, to be printed
  * @param endWithNewline if true, ensure that the printed output ends with a newline
  * @return the resulting formatted string
  */
 @NonNull
 public static String prettyPrint(@NonNull Node node, boolean endWithNewline) {
   return prettyPrint(
       node,
       XmlFormatPreferences.defaults(),
       XmlFormatStyle.get(node),
       SdkUtils.getLineSeparator(),
       endWithNewline);
 }
  private static void formatFile(@NonNull XmlFormatPreferences prefs, File file, boolean stdout) {
    if (file.isDirectory()) {
      File[] files = file.listFiles();
      if (files != null) {
        for (File child : files) {
          formatFile(prefs, child, stdout);
        }
      }
    } else if (file.isFile() && SdkUtils.endsWithIgnoreCase(file.getName(), DOT_XML)) {
      XmlFormatStyle style = null;
      if (file.getName().equals(SdkConstants.ANDROID_MANIFEST_XML)) {
        style = XmlFormatStyle.MANIFEST;
      } else {
        File parent = file.getParentFile();
        if (parent != null) {
          String parentName = parent.getName();
          ResourceFolderType folderType = ResourceFolderType.getFolderType(parentName);
          if (folderType == ResourceFolderType.LAYOUT) {
            style = XmlFormatStyle.LAYOUT;
          } else if (folderType == ResourceFolderType.VALUES) {
            style = XmlFormatStyle.RESOURCE;
          }
        }
      }

      try {
        String xml = Files.toString(file, Charsets.UTF_8);
        Document document = XmlUtils.parseDocumentSilently(xml, true);
        if (document == null) {
          System.err.println("Could not parse " + file);
          System.exit(1);
          return;
        }

        if (style == null) {
          style = XmlFormatStyle.get(document);
        }
        boolean endWithNewline = xml.endsWith("\n");
        int firstNewLine = xml.indexOf('\n');
        String lineSeparator =
            firstNewLine > 0 && xml.charAt(firstNewLine - 1) == '\r' ? "\r\n" : "\n";
        String formatted =
            XmlPrettyPrinter.prettyPrint(document, prefs, style, lineSeparator, endWithNewline);
        if (stdout) {
          System.out.println(formatted);
        } else {
          Files.write(formatted, file, Charsets.UTF_8);
        }
      } catch (IOException e) {
        System.err.println("Could not read " + file);
        System.exit(1);
      }
    }
  }
 public String toCamelCase() {
   return SdkUtils.constantNameToCamelCase(name());
 }
  /**
   * Called by {@link NewXmlFileWizard} to initialize the page with the selection received by the
   * wizard -- typically the current user workbench selection.
   *
   * <p>Things we expect to find out from the selection:
   *
   * <ul>
   *   <li>The project name, valid if it's an android nature.
   *   <li>The current folder, valid if it's a folder under /res
   *   <li>An existing filename, in which case the user will be asked whether to override it.
   * </ul>
   *
   * <p>The selection can also be set to a {@link Pair} of {@link IProject} and a workspace resource
   * path (where the resource path does not have to exist yet, such as res/anim/).
   *
   * @param selection The selection when the wizard was initiated.
   */
  private boolean initializeFromSelection(IStructuredSelection selection) {
    if (selection == null) {
      return false;
    }

    // Find the best match in the element list. In case there are multiple selected elements
    // select the one that provides the most information and assign them a score,
    // e.g. project=1 + folder=2 + file=4.
    IProject targetProject = null;
    String targetWsFolderPath = null;
    String targetFileName = null;
    int targetScore = 0;
    for (Object element : selection.toList()) {
      if (element instanceof IAdaptable) {
        IResource res = (IResource) ((IAdaptable) element).getAdapter(IResource.class);
        IProject project = res != null ? res.getProject() : null;

        // Is this an Android project?
        try {
          if (project == null || !project.hasNature(AdtConstants.NATURE_DEFAULT)) {
            continue;
          }
        } catch (CoreException e) {
          // checking the nature failed, ignore this resource
          continue;
        }

        int score = 1; // we have a valid project at least

        IPath wsFolderPath = null;
        String fileName = null;
        assert res != null; // Eclipse incorrectly thinks res could be null, so tell it no
        if (res.getType() == IResource.FOLDER) {
          wsFolderPath = res.getProjectRelativePath();
        } else if (res.getType() == IResource.FILE) {
          if (SdkUtils.endsWithIgnoreCase(res.getName(), DOT_XML)) {
            fileName = res.getName();
          }
          wsFolderPath = res.getParent().getProjectRelativePath();
        }

        // Disregard this folder selection if it doesn't point to /res/something
        if (wsFolderPath != null
            && wsFolderPath.segmentCount() > 1
            && SdkConstants.FD_RESOURCES.equals(wsFolderPath.segment(0))) {
          score += 2;
        } else {
          wsFolderPath = null;
          fileName = null;
        }

        score += fileName != null ? 4 : 0;

        if (score > targetScore) {
          targetScore = score;
          targetProject = project;
          targetWsFolderPath = wsFolderPath != null ? wsFolderPath.toString() : null;
          targetFileName = fileName;
        }
      } else if (element instanceof Pair<?, ?>) {
        // Pair of Project/String
        @SuppressWarnings("unchecked")
        Pair<IProject, String> pair = (Pair<IProject, String>) element;
        targetScore = 1;
        targetProject = pair.getFirst();
        targetWsFolderPath = pair.getSecond();
        targetFileName = "";
      }
    }

    if (targetProject == null) {
      // Try to figure out the project from the active editor
      IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
      if (window != null) {
        IWorkbenchPage page = window.getActivePage();
        if (page != null) {
          IEditorPart activeEditor = page.getActiveEditor();
          if (activeEditor instanceof AndroidXmlEditor) {
            Object input = ((AndroidXmlEditor) activeEditor).getEditorInput();
            if (input instanceof FileEditorInput) {
              FileEditorInput fileInput = (FileEditorInput) input;
              targetScore = 1;
              IFile file = fileInput.getFile();
              targetProject = file.getProject();
              IPath path = file.getParent().getProjectRelativePath();
              targetWsFolderPath = path != null ? path.toString() : null;
            }
          }
        }
      }
    }

    if (targetProject == null) {
      // If we didn't find a default project based on the selection, check how many
      // open Android projects we can find in the current workspace. If there's only
      // one, we'll just select it by default.
      IJavaProject[] projects = AdtUtils.getOpenAndroidProjects();
      if (projects != null && projects.length == 1) {
        targetScore = 1;
        targetProject = projects[0].getProject();
      }
    }

    // Now set the UI accordingly
    if (targetScore > 0) {
      mValues.project = targetProject;
      mValues.folderPath = targetWsFolderPath;
      mProjectButton.setSelectedProject(targetProject);
      mFileNameTextField.setText(targetFileName != null ? targetFileName : ""); // $NON-NLS-1$

      // If the current selection context corresponds to a specific file type,
      // select it.
      if (targetWsFolderPath != null) {
        int pos = targetWsFolderPath.lastIndexOf(WS_SEP_CHAR);
        if (pos >= 0) {
          targetWsFolderPath = targetWsFolderPath.substring(pos + 1);
        }
        String[] folderSegments = targetWsFolderPath.split(RES_QUALIFIER_SEP);
        if (folderSegments.length > 0) {
          mValues.configuration = FolderConfiguration.getConfig(folderSegments);
          String folderName = folderSegments[0];
          selectTypeFromFolder(folderName);
        }
      }
    }

    return true;
  }
Пример #8
0
  /**
   * Paints the preview at the given x/y position
   *
   * @param gc the graphics context to paint it into
   * @param x the x coordinate to paint the preview at
   * @param y the y coordinate to paint the preview at
   */
  void paint(GC gc, int x, int y) {
    mTitleHeight = paintTitle(gc, x, y, true /*showFile*/);
    y += mTitleHeight;
    y += 2;

    int width = getWidth();
    int height = getHeight();
    if (mThumbnail != null && mError == null) {
      gc.drawImage(mThumbnail, x, y);

      if (mActive) {
        int oldWidth = gc.getLineWidth();
        gc.setLineWidth(3);
        gc.setForeground(gc.getDevice().getSystemColor(SWT.COLOR_LIST_SELECTION));
        gc.drawRectangle(x - 1, y - 1, width + 2, height + 2);
        gc.setLineWidth(oldWidth);
      }
    } else if (mError != null) {
      if (mThumbnail != null) {
        gc.drawImage(mThumbnail, x, y);
      } else {
        gc.setBackground(gc.getDevice().getSystemColor(SWT.COLOR_WIDGET_BORDER));
        gc.drawRectangle(x, y, width, height);
      }

      gc.setClipping(x, y, width, height);
      Image icon = IconFactory.getInstance().getIcon("renderError"); // $NON-NLS-1$
      ImageData data = icon.getImageData();
      int prevAlpha = gc.getAlpha();
      int alpha = 96;
      if (mThumbnail != null) {
        alpha -= 32;
      }
      gc.setAlpha(alpha);
      gc.drawImage(icon, x + (width - data.width) / 2, y + (height - data.height) / 2);

      String msg = mError;
      Density density = mConfiguration.getDensity();
      if (density == Density.TV || density == Density.LOW) {
        msg =
            "Broken rendering library; unsupported DPI. Try using the SDK manager "
                + "to get updated layout libraries.";
      }
      int charWidth = gc.getFontMetrics().getAverageCharWidth();
      int charsPerLine = (width - 10) / charWidth;
      msg = SdkUtils.wrap(msg, charsPerLine, null);
      gc.setAlpha(255);
      gc.setForeground(gc.getDevice().getSystemColor(SWT.COLOR_BLACK));
      gc.drawText(msg, x + 5, y + HEADER_HEIGHT, true);
      gc.setAlpha(prevAlpha);
      gc.setClipping((Region) null);
    } else {
      gc.setBackground(gc.getDevice().getSystemColor(SWT.COLOR_WIDGET_BORDER));
      gc.drawRectangle(x, y, width, height);

      Image icon = IconFactory.getInstance().getIcon("refreshPreview"); // $NON-NLS-1$
      ImageData data = icon.getImageData();
      int prevAlpha = gc.getAlpha();
      gc.setAlpha(96);
      gc.drawImage(icon, x + (width - data.width) / 2, y + (height - data.height) / 2);
      gc.setAlpha(prevAlpha);
    }

    if (mActive) {
      int left = x;
      int prevAlpha = gc.getAlpha();
      gc.setAlpha(208);
      Color bg = mCanvas.getDisplay().getSystemColor(SWT.COLOR_WHITE);
      gc.setBackground(bg);
      gc.fillRectangle(left, y, x + width - left, HEADER_HEIGHT);
      gc.setAlpha(prevAlpha);

      y += 2;

      // Paint icons
      gc.drawImage(CLOSE_ICON, left, y);
      left += CLOSE_ICON_WIDTH;

      gc.drawImage(ZOOM_IN_ICON, left, y);
      left += ZOOM_IN_ICON_WIDTH;

      gc.drawImage(ZOOM_OUT_ICON, left, y);
      left += ZOOM_OUT_ICON_WIDTH;

      gc.drawImage(EDIT_ICON, left, y);
      left += EDIT_ICON_WIDTH;
    }
  }