Introduction

This is the first public software release for the Harmonia project. It consists of Harmonia-Mode, a demonstration application for the Harmonia Framework. Harmonia-Mode is an editing mode for XEmacs, like java-mode and c-mode. It demonstrates a set of enhanced editing features enabled by the Harmonia Framework.

Harmonia-Mode

Harmonia Language Support

Harmonia supports the following languages in this second release.

How Harmonia Works

Harmonia runs three compiler analyses on your XEmacs buffer: lexing, parsing (syntax) and semantic analysis. Conceptually, all of these analyses happen on every keystroke (actually, they occur at varying times between keystrokes). Thus, it is important to make the analyses fast, so they don't get in the way. Both lexing and parsing are incremental, meaning they take time proportional to the size of the change you make. Semantics is non-incremental (currently), but in the languages supported does not take any perceptible amount of time (less than 20-30 ms on average).

Using the results of these analyses, Harmonia-mode will supply you with syntax highlighting, indentation, error-detection, and a few other features. Note that you won't gain the benefit of some of these features in sections of your program that are not syntactically correct. Syntax highlighting uses lexical (non-structural) information, and will most often exist and appear to be correct. Indentation has been engineered to use lexical information when the syntax tree is not available. Error detection and other services are usually based on Harmonia's access to the parse tree of your program, thus they will only work in areas of your program that are (or were) syntactically correct. Harmonia-mode remembers the structure of your program as you edit it, but if you type a new method declaration from scratch, it won't know what type signature it has until you type the last semicolon.

The Future

Installation and Setup

Download

Please download Harmonia from our download page. These instructions are for the binary release of Harmonia.

Running Harmonia-Mode

• Linux and Solaris

1. To run Harmonia-mode, just run xemacs from your shell.
   • Note that xemacs is not the same as emacs! Harmonia-mode doesn't work with regular emacs, so make sure that you run xemacs.
2. You will be able to tell that you ran the right program if you see Loading Harmonia...done in the bottom line of your XEmacs window. If you do not see this message, it may have been overwritten by a later one. Look for it in the Message Log (Choose the Show Message Log menu item from the View menu).

• MacOS X

1. To run Harmonia-mode, just double-click on Harmonia-XEmacs in your /Applications folder.

Harmonia-Mode comes with a demo directory in /usr/harmonia/demo (on MacOS X it is /Library/Application Support/Harmonia/demo), inside of which are example programs in each language that this release supports. Load a C file (ending in ".h" or ".c"), a Java file (ending in ".java"), a Scheme file (ending in ".scm"), a Titanium file (ending in ".ti"), or a Cool file (ending in ".cl") and start editing! You should see Harmonia-C, Harmonia-Java, Harmonia-Scheme, Harmonia-Titanium or Harmonia-Cool at the bottom of your window in the modeline. Try them out!

To see what you can do with Harmonia-Mode, read the Features section of this manual (Language Analyses, Indentation and Highlighting, Structural Movement, Structural Search, and Elision).

If you decide to stop using Harmonia-mode, you can switch to the fundamental XEmacs editing mode by typing M-x fundamental-mode. For a more permanent solution, see the next page: Turning it On.

Additional Setup for Harmonia-mode for C

Additional Setup for Harmonia-mode for Java

Troubleshooting

1. XEmacs starts but I don't see the message that Harmonia has loaded.
   1. There may be something in your ~/.xemacs/init.el (or ~/.emacs) file that has an error with XEmacs. This may prevent Harmonia-Mode from loading. Check out your XEmacs startup files and try to fix the problem.
2. I loaded a Java file, but Harmonia-Mode does not start.
   1. Harmonia-Mode is too slow to use on really large files. We disable it on files larger than 200K. You can change this value by configuring Harmonia.
3. I loaded a Titanium file that ends in .java, but it starts in Harmonia-Java-Mode, not Harmonia-Titanium-Mode.
   1. Titanium files must end in .ti to be autodetected by Harmonia-Mode. To switch modes manually, type
      M-x harmonia-titanium-mode.

Crash Recovery and Bug Reporting

Harmonia-mode has been engineered to recover from crashes in order to preserve your work, and to help us with debugging. If it crashes, it will ask for permission to file a bug report (via email to harmonia-bugs@sequoia.cs.berkeley.edu). (Note: sending email will not work on MacOS X).

Harmonia-mode will then restart itself on your buffer, and allow you to edit your program again.

If you have any other problems with Harmonia-Mode, please report them using M-x harmonia-report-bug, or send us email at harmonia-bugs@sequoia.cs.berkeley.edu. Harmonia-mode is currently in active development, and we will be updating these web pages to notify you as we fix bugs and add features.

Turning on Harmonia-Mode

In order to use Harmonia-Mode, it must be enabled for each file you edit. By default, Harmonia-Mode is enabled for all files it supports:

You can tell whether or not Harmonia-Mode is enabled for a file you are editing in XEmacs by looking for the word "Harmonia-language" on the modeline (the bar at the bottom of the XEmacs window):

Harmonia-Mode can be enabled either automatically (based upon the file's extension), or on a manual, per-file basis.

Automatically Enabling Harmonia-Mode

Harmonia-Mode's customization system includes an option to automatically enable or disable Harmonia-Mode for files of specified extensions. For more information, see the customization documentation.

Manually Enabling Harmonia-Mode

To manually enable Harmonia in a file being edited, switch to the buffer containing the file and type M-x harmonia-language-mode.

Examples:

Automatically Disabling Harmonia-Mode

The current version of Harmonia-Mode runs (really) slowly on large files. We respect a user-defined file size limit when deciding whether to enable Harmonia-Mode on a particular file. By default, the limit is 200,000 bytes. If Harmonia-Mode does not start up automatically, please check that your file is smaller than this limit. Otherwise, you can extend the limit by using Harmonia's customization feature.

Manually Disabling Harmonia-Mode

You can always change back to a standard XEmacs mode by typing M-x java-mode, M-x c-mode, M-x scheme-mode, etc. appropriately (there is no regular XEmacs Cool or XEmacs Titanium mode, but for these you can use M-x fundamental-mode).

Analyses

Harmonia-Mode utilizes source code analyses to provide many of its services. This section describes these analyses and how they affect the user.

The Three Phases of Analysis

Harmonia has three phases of analysis: Lexical, Syntax, and Semantic. After every user-edit, Harmonia-Mode initializes three "idle timers" (described below) that wait for specified amounts of idle time to pass before executing each of the three analyses.

Lexical Analysis: The Lexer

Lexical analysis is the most lightweight of the three analyses. It organizes character-sequences into separate words, and uncovers most of the information used for syntax-highlighting.

For instance, if a user were to type "private int x;" then the lexer would break it up into the words "private" "space" "int" "space" "x" ";" and would determine that "private" is a keyword to be bold-blue, that "int" is a type to be italicized-grey, and that "x" is an object identifier.

Syntax Analysis: The Parser

The job of the parser is to uncover the structure of programs. For example, it determines, in Java, that the sequence of words "private" "space" "int" "space" "x" ";" is a variable declaration.

Syntax analysis is needed for most Harmonia-Mode features (those that contain "structure" in their names). It also is needed for the syntax-highlighting of a few constructs, like function names.

Semantic Analysis

The main job of semantic analysis is to determine the names and types of program structures, and to verify their correctness. Consequently, this is the phase of analysis which will uncover type and name errors.

The implementation of semantic analysis varies considerably among the supported languages (since every programming language has a unique definition), so it is important to understand its features and limitations for the language in which you are working. See the Languages section for more information.

Analysis Indicator

The current state of the analyses is visible on the XEmacs mode-line. A program can be in any one of four analyzed states:

Modeline Visual	Completed Analyses
	None
	Lexical
	Lexical, Syntactic
	Lexical, Syntactic, Semantic

Some languages in Harmonia do not currently support semantic analysis. Files in these languages have shorter analysis indicators, like this: .

Semantic Context Menus

You can browse Harmonia-Mode's semantic information by right-clicking on function names, class names, variables and constants that you're interested in. Doing so invokes a contextual menu that displays information about the code you clicked on and gives you links to semantically related sections of the program.

For instance, in a Java program containing the statement return x + 3;, you could right-click on x to invoke the following menu:

In this case, clicking on "Show variable declaration" would open the file containing the definition of the variable x and put the cursor on it.

Incrementality

Harmonia-Mode re-analyzes after each keystroke, once a specified amount of time has passed (usually less than a second). This per-keystroke analysis would be too slow on large files if Harmonia-Mode's analyses were not incremental. To retain snappy response times, Harmonia-Mode only re-analyzes the portions of the program which have changed.

The most fundamental analyses, lexical analysis and syntax analysis (parsing), are both fully incremental. Semantic analysis, unfortunately, is usually not incremental, since a change in one region of a file might potentially impact the analysis of code in any other region. For example, renaming a variable declaration can cause errors in any region of code that references the changed variable. Therefore, semantic analysis may be somewhat slow on larger files.

Scheduling the Analyses during Interactive Use

Analysis results beyong lexing are not very useful to display while the user is actively typing, so we delay running the analysis on the assumption that a pause in typing indicates a logical time to run the analysis.Each of the three analyses each have customizable idle times that delay their execution. The analyses run in sequence after every user-edit, pausing between each analysis until the user has been idle for a the specified amount of time.

Here are the default idle times for each analysis:

If the execution of Harmonia-Mode analyses are causing unwanted pauses, increasing the values of these idle times will probably improve things. For more information on how to do so, see the settings section.

Indentation and Highlighting

This section describes Harmonia-Mode's automatic indentation and highlighting systems.

Indentation

Harmonia-Mode can automatically indent the lines of your source code. Harmonia-Mode supports proper (Emacs-style) indentation. If you press tab on a particular line, no matter where on that line, it will indent the line to its proper location, given its context. (By constrast, improper indentation is what you get from a word processor. When you press tab, it inserts a tab at your cursor location no matter what context you are in. While fine for writing poetry, this is not so useful for writing programs.)

Harmonia-Mode's indentation system behaves similarly to XEmacs' system (or at least, we tried to make it behave that way), but is implemented completely differently. Instead of XEmacs' reliance on inexact textual heuristics, we use the tokenization and syntactic structure that Harmonia maintains for each document to provide precise, correct, information to the incremental indentation engine. This engine is programming language-independent; for each programming language that Harmonia-Mode supports, there is a corresponding XML-based indentation specification file (installed in /usr/harmonia/etc) that describes how to indent a particular line in a variety of contexts.

All of XEmacs' indentation commands, such as indent-region, are overridden with Harmonia-Mode's indentation algorithm as well. In this first release of Harmonia-Mode, we have not given you enough documentation to write your own indentation specifications, but feel free to take a look and tinker with it.

Syntax Highlighting

Harmonia-Mode supports syntax highlighting. The decision of what to highlight is undertaken by our own language-specific highlighting specification. Again, instead of relying on XEmacs' reliance on on inexact textual heuristics (regular expressions), Harmonia-Mode uses our precise tokenization and syntactic (where appropriate) information to color tokens. Each programming language's specification is written in a Lisp-like notation (though for this release, is uncustomizable by the user.)

Harmonia-mode uses more faces than font-lock does, each of which may be customized to your liking.

Error and Warning Display

When one of Harmonia-Mode's analyses discover an error in the program (something that a compiler would catch), it informs the programmer by underlining the invalid region and pointing at it with a triangle in the left margin. Compiler warnings are indicated in a different color and marked by an exclamation mark icon.

Moving the mouse cursor or text cursor over the error region causes an explanation of the error to appear at the bottom of the XEmacs window.

As soon as the programmer fixes the error or warning, the underline will disappear from view.

See the customization section for information on changing the way errors and warnings are displayed.

Structural Movement

Structural movement is the ability to move the cursor in terms of program structures instead of characters. For example, instead of moving the cursor to the next character in a file, one might move to the next function definition.

Harmonia-Mode has two different forms of structural movement: structure browsing, and structure jumping.

Structure Browsing:

Harmonia-Mode implements a novel structure-aware cursor, similar to the one used in the Pan research project. This feature allows a programmer to navigate hierarchically throughout a program's source code.

When using this type structural movement, a highlighted region appears with the cursor, indicating the programming structure being browsed. The user can move this structure forward, backward, or make it bigger or smaller.

In this example Cool file, the cursor is the dark red rectangle, and the light-blue region around the "size_of_board" method indicates that it is the current structure being browsed.

Using the Structure Browser:

When structure-browsing, the programmer can navigate:

• larger in the hierarchy, selecting a larger enclosing structure

• smaller, selecting the first sub-structure of the current structure

• forward, selecting the next structure at the same level as the current structure

• or backward, selecting the previous structure at the same level.

The four commands just described are available in the "Structure Browse" sub-menu:

Using the menu is inconvenient, however, for any intensive structural navigation. It is recommended that you use it only as a reference to remember the structure browsing keyboard bindings: C-M-left, C-M-right, C-M-up, and C-M-down.

Structure Browsing sessions involve three steps:

• Enable: Executing any of the four structure browsing commands will automatically enable structure browsing and highlight the current structure.

• Browse: When structure browsing, the user can continue to use the structure browsing commands to navigate their program's hierarchy.

• Disable: Once done, pressing any other key will disable structure browsing and remove the highlight.

Structure Browsing Examples:

1. Structure-browsing is a quick way to move amongst method definitions in a file. For example, pressing C-M-up will take a programmer from this place in the file...

   

   ...directly to the method definition above it:

   

   The programmer can then start editing that method, and the highlight will be disabled.

   
   
2. It's easy to move among larger structures as well, as we see in this Java file:

   

   Pressing C-M-left C-M-left selects first the method definition encompassing the cursor, and then the class:

   

   Now, pressing C-M-down C-M-down moves the programmer to the second class following the current one, leaving the programmer here:

   

   As always, the programmer can now immediately continue normal editing. As soon as he or she moves the cursor or types a keystroke, the highlight will be disabled.

   
   
3. Perhaps, though, the programmer now wants to edit the method "toString()" in this class.

   Pressing C-M-right selects the first method in the class (the constructor "Rule()"), and then pressing C-M-down once brings the programmer directly to the desired method:

   

   
   
4. Although we haven't shown any examples of it here, one can also browse the lower-level structures of their programs, such as method arguments, variable declarations, and the branches of "if" statements.

The "Jump to" Feature:

The "jump to" feature is a simpler alternative to the structure browser. With it, you can "jump" the cursor to the next or previous structure of certain types. Each language has a particular set of structure-types to which one can jump.

Using "jump to"

In the Harmonia menu, select "Jump to".

You will now see a list of program structures to which Harmonia knows how to jump. Selecting one of these items will move the cursor appropriately.

Note: Each item in the menu is listed with its corresponding keyboard shortcut, if available. Browsing these menus is a great way to learn Harmonia-Mode's key-bindings.

Structural Search

The XEmacs incremental search (I-search) feature has been extended in Harmonia-Mode by allowing you search for specific program features.

Using Harmonia's I-search

Original I-search

Just like with the XEmacs I-search, you can enter Harmonia's I-search mode by typing C-s (or C-r). The minibuffer will then display "I-search:". At this point, you can type any sequence of characters, and XEmacs will show you all strings in the current buffer that match the sequence you typed.

Harmonia-mode's I-search supports all the features of XEmacs' built-in I-search. For more information the built-in I-search, see the XEmacs User's Manual.

Harmonia's Filtered Searches

Harmonia-mode adds value to the regular I-search by allowing you to filter searches to return specific types of structures.

Each language has a variety of structure-types to which you can filter a search. There is a keybinding for each type, that you can use to toggle each type's filter.

• To filter the current search to a type of structure, enter the structure's filter command after entering I-search mode.
• Entering the command again will remove the filter.
• Entering the command for a different filter will remove the old filter before adding the new one.

Example: Cool

Cool supports the following filter commands:

To search for the next occurrence of a method with a name containing foo, type C-s M-m foo.

To search for the previous occurrence of the word bar in a comment, type C-r M-c bar.

Example: Java

Java supports the following filter commands:

To search for the next occurrence of a method with a name containing foo, type C-s M-m foo.

To search for the previous occurrence of the word bar in a comment, type C-r M-c bar.

Additional Languages

To see the Harmonia I-search commands for additional languages, see the Key Bindings Reference.

Elision

Harmonia-Mode has a feature that hides from view all structures of specified types. Each language has a list of structure-types that may be hidden when viewing files in the language. The list for each language is always available in the Harmonia-Mode menu under the "Hide" section:

In this example, one can filter all comments from view by selecting "comments" from the menu.

Original Program:

With Comments Hidden:

Notice that the comments are replaced with ellipses ("..."). Some filterable structures have other replacements. The next screenshot shows how punctuation is replaced with a space when hidden.

With Punctuation Hidden:

Future versions of Harmonia-Mode will improve upon this feature. For example, our structural pattern-matcher will enable a powerful user-specified view-filter (that a user could use to hide all debugging code, for instance), and a code-folding feature will allow users to elide specific, individual structures on-demand, rather than hiding all structures of a certain type at once.

Supported Languages

Harmonia-Mode's supported languages currently have varying features, analyses, and caveats. This page describes each language in detail.

Cool

Language version

Harmonia-mode supports Cool as used in the UC Berkeley CS164 course offering of Spring 2003.

What it will do

Harmonia will correctly detect all lexical, syntactic, and semantic errors. Syntax highlighting, structural selection, movement, elision and search, are all complete. Semantic context menus are complete, and supports use-def navigation, type introspection, display of class inheritance, and method name resolution.

Java

Language version

Harmonia-mode supports Java 2 v1.4.2 (as shown in The Java Language Specification Second Edition, (James Gosling, Bill Joy, Guy Steele and Gilad Bracha)). Harmonia-mode supports all current versions of the Java class library as of Java 2 v1.4.2.

What it will do

Harmonia will correctly detect all lexical, syntactic and almost all semantic errors. Syntax highlighting, structural selection, movement, elision and search, are all complete. Semantic context menus are complete, and supports use-def navigation (for types, constructors, methods, fields, local variables) and type introspection,

How it works

Harmonia assumes the standard directory layout defined in Section 7.2.1 of the Java Language Specification.

While Harmonia opens a file, it also loads (in the background) all the other files upon which it depends. The first time ever that it does so, it caches the semantic data. Therefore, you should expect a much longer delay the first time Harmonia consults a particular library file. Harmonia provides a read-only semantic data cache for the JDK version 1.4.2. If Harmonia-Java looks for a file and does not find it, but it is present in the read-only cache, the cache file is used.

The directory "." (i.e. the current directory), does not make much sense when you are in an editor. Therefore, the directory "." is interpreted as the directory containing the particular file being examined if it is not in a named package; otherwise it is the directory up the hierachy as many levels as there are package levels for named packages.

For example, suppose you have a file ~/mycode/Foo.java with the code:

public class Foo {

void m() { new Bar(); }

}

The directory "." will be interpreted as ~/mycode/. Semantics will search this directory for the file Bar.java.

Now suppose you have a file ~/mycode2/myPackage/Foo.java with the code:

package myPackage;

public class Foo {

void m() { new myPackage.Baz(); }

}

The directory "." will be interpreted as ~/mycode2/. Semantics will search this directory for the file myPackage/Baz.java.

This interpretation attempts to approximate the behavior of javac.

At this time, there is no provision for "projects". Thus, all open files are considered for semantic information for all other open files. This can lead to strange results at times, with things being defined when one would not think they ought to be. If something does not seem to be behaving properly, check all other open buffers. Another consequence is that you must manually change classpaths if you have two sets of files with the same classes defined.

Bugs

Harmonia does not check definite assignment and some dataflow information. If you discover any other bugs, please report them with M-x harmonia-report-bug.

Titanium

Language version

Harmonia-mode supports a superset of Titanium, as described in the Titanium Reference Manual 1.11.

What it will do

Harmonia will correctly detect all lexical, syntactic and almost all semantic errors. Syntax highlighting, structural selection, movement, elision and search, are all complete. Semantic context menus are complete, and supports use-def navigation (for types, constructors, methods, fields, local variables) and type introspection.

How it works

Harmonia for Titanium functions similarly to Harmonia for Java, with a few differences.

Harmonia provides a read-only semantic data cache for the TDK version corresponding to version 1.16 of the language reference.

Titanium projects often have files ending in .java. If these files are not in Titanium mode, Harmonia for Titanium will not notice them. To use Java files for Titanium, type M-x harmonia-titanium-mode.

Templates are not type checked beyond information necessary for instantiations, because it is not clear how semantic errors are to be checked and then reported to the user.

The Titanium Reference describes Titanium without nested classes. Harmonia for Titanium is based on Harmonia for Java, and so is a superset of the union of Titanium (based on Java 1.1) and Java 1.4. The Titanium compiler also allows nested classes. Unfortunately, these two versions of nested classes are incompatable in some ways. Please report any incompatability as a bug, as it is unknown all the ways that they differ.

The variables that hold the classpaths for Java and Titanium are different.

Bugs

Harmonia will not cache files containing templates. This is due to compile time constant information from template formals, which is not readily cacheable. Harmonia does not check definite assignment and some dataflow information, nor is single implemented. If you discover any other bugs, please report them with M-x harmonia-report-bug.

C

Language version

Harmonia-mode supports C99 with most GNU extensions.

What it will do

Harmonia will correctly detect all lexical, syntactic and semantic errors. Syntax highlighting, structural selection, movement, elision and search are all complete. Semantic context menus are complete, and support use-def navigation (for types, enums, structs, unions, variables), type introspection, and navigation from 'goto' statements to their targets. In addition, when you move the mouse over an entity in your program, the type of the entity will appear in the modeline.

Preprocessor

Harmonia supports a subset of the C preprocessor through a menu item in the Harmonia-C menu. Before using this for the first time, make sure you have set up the customize variables for the running the C preprocessor on your local computer. To run the preprocessor, pick the menu item Run Preprocessor. Harmonia will execute the preprocessor and insert the contents of #include statements into the buffer (marked invisible and read-only), and will then reanalyze the buffer. Since the #includes are usually very big, Harmonia-Mode will take some time to run its analyses (for the first time).

To see the preprocessed include text in your buffer, pick the menu item, Show Preprocessed Includes. To hide them again, choose the same menu item again. To delete the preprocessed part of the file, pick the menu item, Delete Preprocessed Includes.

If you edit your #include line, for example, by changing <>'s to quotes, or by changing the file that you're loading, the preprocessor information will be out of date. A compiler warning will appear saying that since you changed a #include, semantics is now turned off. You should pick the menu item Rerun Preprocessed Includes to get rid of the preprocessor information and rerun the preprocessor for the up-to-date information.

Scheme

Language version

Harmonia-mode supports R⁵RS Scheme with MIT Scheme extensions for escape characters within strings. Harmonia-mode does not support keywords (special forms) to be used as identifiers. R⁵RS discourages this practice, but does not outright forbid it. In addition, Harmonia-mode does not parse/evaluate Scheme define-syntax macros. Lisp-style macros (quasiquote, comma and comma-at) are supported.

What it will do

Harmonia will correctly detect all lexical and most syntactic errors in Scheme. Harmonia does not analyze Scheme semantics.

Bugs

Harmonia-mode allows Scheme definitions (in 'let', 'let*', 'letrec', 'define' and 'lambda') to have a blank body, but does not tell the user that this is illegal Scheme. Future versions of Harmonia-mode will detect this error and issue a warning to the user. Harmonia-mode does not properly count the number of nestings of quasiquote and commas to verify that they match up.

XEmacs Keybindings

This page lists all user-level commands provided by Harmonia-Mode. It is divided into the following subsections:

• Global Commands

• Commands for Java

• Commands for Titanium

• Commands for C

• Commands for Scheme

• Commands for Cool

Except for the I-Search filters, any of the commands listed below can be invoked with their keybinding or with M-x [command]. For example, typing M-x harmonia-mode will invoke the harmonia-mode command.

The I-Search filters are applied by first entering I-Search mode (with C-s or C-r), and then by entering the particular filter's I-Search command, specified below.

All Languages

Java

Harmonia-Java-Mode I-Search

Titanium

Harmonia-Titanium-Mode I-Search

C

Harmonia-C-Mode I-Search

Scheme

Cool

Harmonia-Cool-Mode I-Search

Harmonia Settings

Harmonia-Mode uses the standard XEmacs "Customize" interface for user-level configuration. To get started, select either "Customize Harmonia-language" or "Customize Harmonia" from the Harmonia-Mode menu:

For example, selecting "Customize Harmonia" will bring you to a screen like this:

The XEmacs customization system is not described in detail here. To learn more about how to use it, see the XEmacs User's Manual.

Customization Groups

Harmonia-Mode's settings are divided into the following groups:

The rest of this section describes each group's settings.

Group: Harmonia

The Harmonia group contains general options, as well as hyperlinks to the other, more specific, customization groups.

Group: Harmonia Faces

A collection of faces used to highlight various sections of `harmonia-mode' buffers. Many of these are prefixed with `font-lock', for consistent access in the "edit faces" screen.

Group: Harmonia Java Faces

A collection of faces used to highlight various sections of `harmonia-java-mode' buffers. Many of these are prefixed with `font-lock', for consistent access in the "edit faces" screen.

Group: Harmonia Titanium Faces

A collection of faces used to highlight various sections of `harmonia-titanium-mode' buffers. Many of these are prefixed with `font-lock', for consistent access in the "edit faces" screen.

Group: Harmonia C Faces

A collection of faces used to highlight various sections of `harmonia-c-mode' buffers. Many of these are prefixed with `font-lock', for consistent access in the "edit faces" screen.

Group: Harmonia Cool Faces

A collection of faces used to highlight various sections of `harmonia-cool-mode' buffers. Many of these are prefixed with `font-lock', for consistent access in the "edit faces" screen.

Group: Harmonia Scheme Faces

A collection of faces used to highlight various sections of `harmonia-scheme-mode' buffers. Many of these are prefixed with `font-lock', for consistent access in the "edit faces" screen.

Group: Harmonia Languages

All Harmonia languages

Group: Harmonia Cool Mode

Options for Harmonia Cool Mode

Group: Harmonia Java Mode

Options for Harmonia Java Mode

Group: Harmonia Titanium Mode

Options for Harmonia Titanium Mode

Group: Harmonia C Mode

Options for Harmonia C Mode

Group: Harmonia Scheme Mode

Options for Harmonia Scheme Mode