NetBeans Manifest File Syntax Highlighting 模块教程

创建标记

执行以下操作：

1. 创建文件。 右键单击 ManifestSupport 项目节点，选择 New > Java Class，并在 Class Name 中键入 ManifestTokenContext。单击 Finish。新 Java 类将在 Source Editor 中打开。用以下内容替换默认代码：

   package org.netbeans.modules.manifestsupport;
   
   import org.netbeans.editor.BaseTokenID;
   import org.netbeans.editor.TokenContext;
   import org.netbeans.editor.TokenContextPath;
   import org.netbeans.editor.Utilities;
   
   public class ManifestTokenContext extends TokenContext {
         
         // Numeric-ids for token categories
       public static final int NAME_ID = 1;
       public static final int COLON_ID = 2;
       public static final int VALUE_ID = 3;
       public static final int END_OF_LINE_ID = 4;
      
       // Token-ids
       public static final BaseTokenID NAME = new BaseTokenID("name", NAME_ID);
       public static final BaseTokenID COLON = new BaseTokenID("colon", COLON_ID);
       public static final BaseTokenID VALUE = new BaseTokenID("value", VALUE_ID);
       public static final BaseTokenID END_OF_LINE = new BaseTokenID("end-of-line", END_OF_LINE_ID);
     
       // Context instance declaration
       public static final ManifestTokenContext context = new ManifestTokenContext();
       public static final TokenContextPath contextPath = context.getContextPath();
      
       /**
        * Construct a new ManifestTokenContext
        */
       public ManifestTokenContext() {
           super("mf-");
          
           try {
               addDeclaredTokenIDs();
           } catch (Exception e) {
               Utilities.annotateLoggable(e);
           }
       }
   }

2. 理解文件。 该 Java 类为我们想使用的每个 Manifest 文件中的每个项指定一个标记。Manifest 文件中的每个区分项目是一个标记：“name”、“colon”和“value”。此外，还有一个行结束标记，因为我们需要使用行的结束来确定值的结束位置和下一个名称的开始位置。以上构造方法指定前缀为“mf-”的所有标记。因此，我们现在创建名为“mf-name”、“mf-colon”、“mf-value”和“mf-end-of-line”的标记。

创建语法

执行以下操作：

1. 创建文件。 右键单击 ManifestSupport 项目节点，选择 New > Java Class，并在 Class Name 中键入 ManifestSyntax。单击 Finish。新 Java 类将在 Source Editor 中打开。用以下内容替换默认代码：

   package org.netbeans.modules.manifestsupport;
   
   import org.netbeans.editor.Syntax;
   import org.netbeans.editor.TokenID;
   import org.openide.ErrorManager;
   
   public class ManifestSyntax extends Syntax {
   
       private static final int ISI_NAME = 1;
       private static final int ISA_CR = 2;
       private static final int ISA_LF = 3;
       private static final int ISA_CRLF = 4;
       private static final int ISA_AFTER_NAME = 6;
       private static final int ISA_COLON = 7;
       private static final int ISA_AFTER_COLON = 8;
       private static final int ISI_VALUE = 9;
      
       /** Creates a new instance of ManifestSyntax */
       public ManifestSyntax() {
           tokenContextPath = ManifestTokenContext.contextPath;
       }
      
       protected TokenID parseToken() {
           TokenID result = doParseToken();
           return result;
       }
      
       private TokenID doParseToken() {
           char actChar;
          
           while (offset < stopOffset) {
               actChar = buffer[offset];
              
               switch (state) {
                   case INIT:
                       switch (actChar) {
                           case ':':
                               state = ISA_AFTER_COLON;
                               offset++;
                               return ManifestTokenContext.COLON;
                           case '\n':
                               state = INIT;
                               offset++;
                               return ManifestTokenContext.END_OF_LINE;
                           case '\r':
                               state = ISA_CR;
                               break;
                           default:
                               state = ISI_NAME;
                       }
                       break;
                      
                   case ISI_NAME:
                       switch (actChar) {
                           case ':':
                           case '\r':
                           case '\n':
                               state = ISA_AFTER_NAME;
                               return ManifestTokenContext.NAME;
                       }
                       break;
                      
                   case ISA_CR:
                       if (actChar == '\n') {
                           offset++;
                       }
                       state = INIT;
                       return ManifestTokenContext.END_OF_LINE;
                      
                   case ISA_AFTER_NAME:
                       switch (actChar) {
                           case ':':
                               state = ISA_AFTER_COLON;
                               offset++;
                               return ManifestTokenContext.COLON;
                           case '\n':
                               state = INIT;
                               offset++;
                               return ManifestTokenContext.END_OF_LINE;
                           case '\r':
                               state = ISA_CR;
                               break;
                           default:
                               assert false;
                       }
                       break;
                      
                   case ISA_AFTER_COLON:
                       switch (actChar) {
                           case '\n':
                               state = INIT;
                               offset++;
                               return ManifestTokenContext.END_OF_LINE;
                           case '\r':
                               state = ISA_CR;
                               break;
                           default:
                               state = ISI_VALUE;
                       }
                       break;
                      
                   case ISI_VALUE:
                       switch (actChar) {
                           case '\r':
                           case '\n':
                               state = INIT;
                               return ManifestTokenContext.VALUE;
                       }
                       break;
               }
              
               offset++;
           }
          
           switch (state) {
               case ISI_NAME:
                   state = INIT;
                   return ManifestTokenContext.NAME;
               case ISI_VALUE:
                   state = INIT;
                   return ManifestTokenContext.VALUE;
           }
          
           return null;
       }
   }

2. 理解文件。 该 Java 类 IDE 哪部分文本被标记。通过从初始状态开始，顺序查看文本中的每个字符并决定是否处于该状态，然后移动到另一个状态或宣布已经发现了一个标记。

   例如，对于名称，IDE 从初始状态开始，首先它遇到了名称的有效字符，然后又进入 ISI_NAME 状态。它一直保持该状态，直到它遇到了一个 \r、\n 或 :字符，这些字符不属于名称。当它遇到这样一个字符时，IDE 知道它刚刚经过的这个字符由名称标记组成。代码在 while 循环中运行。结尾处有一个中断状态，它增加了文本的偏移量。该代码中的返回状态避免增加偏距，并且确保分析名称之后将以这个字符（它可能是一个冒号，这是自身有意义的标记）开始的下一个标记。另一方面，中断状态确保增加偏移量。当所有靠近冒号的字符都测试过之后，IDE 知道光标是否位于名称内部。

对 IDE 进行读测试

执行以下操作：

1. 创建文件。 右键单击 Unit Test Packages 节点，选择 New > Java Class，在 Class Name 中键入 ManifestSyntaxTest，在 Package 中键入 org.netbeans.modules.manifestsupport。单击 Finish。新 Java 类将在 Source Editor 中打开。用以下内容替换默认代码：

   import java.util.Arrays;
   import java.util.Iterator;
   import java.util.List;
   import junit.framework.TestCase;
   import org.netbeans.editor.Syntax;
   import org.netbeans.editor.TokenID;
   import org.netbeans.modules.manifestsupport.*;
   
   public class ManifestSyntaxTest extends TestCase {
      
       public ManifestSyntaxTest(String testName) {
           super(testName);
       }
      
       public void testNextToken() {
           doParse("Manifest-Version: 1.0", Arrays.asList(new TokenID[] {
               ManifestTokenContext.NAME,
               ManifestTokenContext.COLON,
               ManifestTokenContext.VALUE,
           }));
       }
          
       public void doParse(String m, List expected) {
           Syntax s = new ManifestSyntax();
           s.load(null, m.toCharArray(), 0, m.length(), true, m.length());
          
           TokenID token = null;
           Iterator i = expected.iterator();
           do {
               token = s.nextToken();
               if (token != null) {
                   if (!i.hasNext()) {
                       fail("More tokens returned than expected.");
                   } else {
                       assertSame("Tokens differ", i.next(), token);
                   }
               } else {
                   assertFalse("More tokens expected than returned.", i.hasNext());
               }
               System.out.println(token);
           } while (token != null);
       }
   }

2. 理解文件。 该 Java 类检查 IDE 是否能够将文本正确地转换为标记。要运行测试，请右键单击该项目节点，然后选择 Run Unit Tests。测试应该继续，在 JUnit Test Results 窗口中返回以下结果：

   

   您可以使用 testNextToken() 方法查看当输入的文本与指定的标记不相符时 IDE 执行的操作。例如，通过删除一个标记 ID (ManifestTokenContext.VALUE) 更改方法，于是该方法如下：

   public void testNextToken() {
      doParse("Manifest-Version: 1.0", Arrays.asList(new TokenID[] {
           ManifestTokenContext.NAME,
           ManifestTokenContext.COLON,
      }));
   }

   现在标记比标记 ID 多。（此处有两个标记 ID—ManifestTokenContext.NAME 和 ManifestTokenContext.COLON。）当您运行 JUnit 测试时，返回消息“More tokens returned than expected。”：

   

   现在通过删除 Manifest-Version 和 1.0 之间的冒号更改方法，如下所示：

   public void testNextToken() {
      doParse("Manifest-Version 1.0", Arrays.asList(new TokenID[] {
           ManifestTokenContext.NAME,
           ManifestTokenContext.COLON,
           ManifestTokenContext.VALUE,
      }));
   }

   现在标记太少了。当您运行 JUnit 测试时，返回消息“More tokens expected than returned。”：

   

   最后，让我们测试看看当有过多或太少的标记时 IDE 的理解—它应该也能知道标记是否放错了位置。添加指定行结束的标记。例如，此处在名称之后和冒号之前添加 \n：

   public void testNextToken() {
     doParse("Manifest-Version\n:1.0", Arrays.asList(new TokenID[] {
          ManifestTokenContext.NAME,
          ManifestTokenContext.COLON,
          ManifestTokenContext.VALUE,
     }));
   }

   当您运行测试时，返回以下错误：

   

   现在我们知道了 IDE 将 manifest 条目正确地转换为标记，接下来我们创建一个编辑器来使用 Manifest 文件并使颜色与标记相关联。

创建 EditorKit

执行以下操作：

1. 创建文件。 右键单击 ManifestSupport 项目节点，选择 New > Java Class，并在 Class Name 中键入 ManifestEditorKit。单击 Finish。新 Java 类将在 Source Editor 中打开。用以下内容替换默认代码：

   package org.netbeans.modules.manifestsupport;
   
   import javax.swing.text.Document;
   import org.netbeans.editor.BaseDocument;
   import org.netbeans.editor.Syntax;
   import org.netbeans.editor.SyntaxSupport;
   import org.netbeans.modules.editor.NbEditorKit;
   import org.openide.ErrorManager;
   
   public class ManifestEditorKit extends NbEditorKit {
     
       public static final String MIME_TYPE = "text/x-java-jar-manifest"; // NOI18N
      
       /**
        * Creates a new instance of ManifestEditorKit
        */
       public ManifestEditorKit() {
       }
      
       /**
        * Create a syntax object suitable for highlighting Manifest file syntax
        */
       public Syntax createSyntax(Document doc) { 
           return new ManifestSyntax();
       }
      
       /**
        * Retrieves the content type for this editor kit
        */
       public String getContentType() {
           return MIME_TYPE;
       }
   }

2. 理解文件。 该 Java 类指定专门用于 NetBeans 编辑器的 EditorKit。因此，它扩展 NBEditorKit 类。编辑器套件建立文本组件所需的一组内容，用于正确合理地为某些类型的文本内容运行编辑器。在这种情况下，该编辑器是针对使用 text/x-java-jar-manifest MIME Type 的内容。

创建语法颜色

执行以下操作：

1. 创建文件。 右键单击 ManifestSupport 项目节点，选择 New > Java Class，并在 Class Name 中键入 ManifestSettingsInitializer。单击 Finish。新 Java 类将在 Source Editor 中打开。用以下内容替换默认代码：

   package org.netbeans.modules.manifestsupport;
   
   import java.awt.Color;
   import java.awt.Font;
   import java.util.Map;
   import org.netbeans.editor.BaseKit;
   import org.netbeans.editor.Coloring;
   import org.netbeans.editor.Settings;
   import org.netbeans.editor.SettingsDefaults;
   import org.netbeans.editor.SettingsNames;
   import org.netbeans.editor.SettingsUtil;
   import org.netbeans.editor.TokenCategory;
   import org.netbeans.editor.TokenContext;
   import org.netbeans.editor.TokenContextPath;
   
   public class ManifestSettingsInitializer extends Settings.AbstractInitializer {
      
       public static final String NAME = "manifest-settings-initializer"; // NOI18N
      
       /**
        * Constructor
        */
       public ManifestSettingsInitializer() {
           super(NAME);
       }
      
       /**
        * Update map filled with the settings.
        * @param kitClass kit class for which the settings are being updated.
        *   It is always non-null value.
        * @param settingsMap map holding [setting-name, setting-value] pairs.
        *   The map can be empty if this is the first initializer
        *   that updates it or if no previous initializers updated it.
        */
       public void updateSettingsMap(Class kitClass, Map settingsMap) {
           if (kitClass == BaseKit.class) {
               new ManifestTokenColoringInitializer().updateSettingsMap(kitClass, settingsMap);
           }
          
           if (kitClass == ManifestEditorKit.class) {
               SettingsUtil.updateListSetting(
                       settingsMap,
                       SettingsNames.TOKEN_CONTEXT_LIST,
                       new TokenContext[] { ManifestTokenContext.context }
               );
           }
       }
      
       /**
        * Class for adding syntax coloring to the editor
        */
       /** Properties token coloring initializer. */
       private static class ManifestTokenColoringInitializer extends SettingsUtil.TokenColoringInitializer {
          
           /** Bold font. */
           private static final Font boldFont = SettingsDefaults.defaultFont.deriveFont(Font.BOLD);
           /** Italic font. */
           private static final Font italicFont = SettingsDefaults.defaultFont.deriveFont(Font.ITALIC);
          
           /** Key coloring. */
   private static final Coloring keyColoring
   = new Coloring(boldFont, Coloring.FONT_MODE_APPLY_STYLE, Color.blue, null);
           /** Value coloring. */
           private static final Coloring valueColoring = new Coloring(null, Color.magenta, null);
           /** Colon coloring. */
           private static final Coloring colonColoring = new Coloring(null, Color.DARK_GRAY, null);
           /** Empty coloring. */
           private static final Coloring emptyColoring = new Coloring(null, null, null);
          
           /** Constructs PropertiesTokenColoringInitializer. */
           public ManifestTokenColoringInitializer() {
               super(ManifestTokenContext.context);
           }      
          
           /** Gets token coloring. */
           public Object getTokenColoring(TokenContextPath tokenContextPath,
                   TokenCategory tokenIDOrCategory, boolean printingSet) {
              
               if(!printingSet) {
                   int tokenID = tokenIDOrCategory.getNumericID();
                  
                   if(tokenID == ManifestTokenContext.NAME_ID) {
                       return keyColoring;
                   } else if(tokenID == ManifestTokenContext.VALUE_ID) {
                       return valueColoring;
                   } else if(tokenID == ManifestTokenContext.COLON_ID) {
                       return colonColoring;
                      
                   }
               } else { // printing set
                   return SettingsUtil.defaultPrintColoringEvaluator;
               }
              
               return null;
           }
          
       } // End of class ManifestTokenColoringInitializer.
      
   }

2. 理解文件。 该 Java 类为我们的标记设置默认的颜色。由于在以下部分中描述了支持文件，用户将能够使用 Options 窗口来更改默认值。

创建 Color Restorer

执行以下操作：

1. 创建文件。 右键单击 ManifestSupport 项目节点，选择 New > Java Class，并在 Class Name 中键入 RestoreColoring。单击 Finish。新 Java 类将在 Source Editor 中打开。用以下内容替换默认代码：

   package org.netbeans.modules.manifestsupport;
   
   import org.netbeans.editor.LocaleSupport;
   import org.netbeans.editor.Settings;
   import org.openide.modules.ModuleInstall;
   import org.openide.util.NbBundle;
   
   public class RestoreColoring extends ModuleInstall {
      
       /**
        * Localizer passed to editor.
        */
       private static LocaleSupport.Localizer localizer;
      
       /**
        * Registers properties editor, installs options and copies settings.
        * Overrides superclass method.
        */
       public void restored() {
           addInitializer();
           installOptions();
       }
      
       /**
        * Uninstalls properties options.
        * And cleans up editor settings copy.
        * Overrides superclass method.
        */
       public void uninstalled() {
           uninstallOptions();
       }
      
       /**
        * Adds initializer and registers editor kit.
        */
       public void addInitializer() {
           Settings.addInitializer(new ManifestSettingsInitializer());
       }
      
       /**
        * Installs properties editor and print options.
        */
       public void installOptions() {
           // Adds localizer.
           LocaleSupport.addLocalizer(localizer = new LocaleSupport.Localizer() {
               public String getString(String key) {
                   return NbBundle.getMessage(RestoreColoring.class, key);
               }
           });
       }
      
       /** Uninstalls properties editor and print options. */
       public void uninstallOptions() {
           // remove localizer
           LocaleSupport.removeLocalizer(localizer);
       }
      
   }

2. 理解文件。 该 Java 类用于安装模块并维护其状态。除了创建它之后，您必须在模块的 manifest 文件中指定该类，方法是添加以下行：

   OpenIDE-Module-Install: org/netbeans/modules/manifestsupport/RestoreColoring.class

   注意，OpenIDE-Module-Install 键属于第一部分的结尾部分（它在下面用粗体高亮显示）：

   Manifest-Version: 1.0
   OpenIDE-Module: org.netbeans.modules.manifestsupport
   OpenIDE-Module-Layer: org/netbeans/modules/manifestsupport/layer.xml
   OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/manifestsupport/Bundle.properties
   OpenIDE-Module-Specification-Version: 1.0
   OpenIDE-Module-Install: org/netbeans/modules/manifestsupport/RestoreColoring.class
   
   Name: org/netbeans/modules/manifestsupport/dataobject/ManifestDataLoader.class
   OpenIDE-Module-Class: Loader

创建支持文件

在本部分中，您更新 Options 窗口以允许用户自定义在 IDE 中表示标记的方法。用户在 Options 窗口中不仅仅可以更改颜色，而且还有字体类型和样式以及 Manifest 编辑器本身。