nedit.doc

nedit 是一款linux下的开发源码的功能强大的编辑器

  type, or move the insertion cursor after a parenthesis, bracket, or brace. 
  It momentarily highlights either the opposite character ('Delimiter') or the 
  entire expression ('Range') when the opposite character is visible in the 
  window. To find a matching character anywhere in the file, select it or 
  position the cursor after it, and choose Goto Matching from the Search menu. 
  If the character matches itself, such as a quote or slash, select the first 
  character of the pair. NEdit will match {, (, [, <, ", ', `, /, and \. 
  Holding the Shift key while typing the accelerator key (Shift+Ctrl+M, by 
  default), will select all of the text between the matching characters. 

  When syntax highlighting is enabled, the matching routines can optionally 
  make use of the syntax information for improved accuracy. In that case, a 
  brace inside a highlighted string will not match a brace inside a comment, 
  for instance. 


  OPENING INCLUDED FILES

  The Open Selected command in the File menu understands the C preprocessor's 
  #include syntax, so selecting an #include line and invoking Open Selected 
  will generally find the file referred to, unless doing so depends on the 
  settings of compiler switches or other information not available to NEdit. 


  INTERFACE TO PROGRAMMING TOOLS

  Integrated software development environments such as SGI's CaseVision and 
  Centerline Software's Code Center, can be interfaced directly with NEdit via 
  the client server interface. These tools allow you to click directly on 
  compiler and runtime error messages and request NEdit to open files, and 
  select lines of interest. The easiest method is usually to use the tool's 
  interface for character-based editors like vi, to invoke nc, but 
  programmatic interfaces can also be derived using the source code for nc. 

  There are also some simple compile/review, grep, ctree, and ctags browsers 
  available in the NEdit contrib directory on ftp.nedit.org. 

------------------
TABS/EMULATED TABS
------------------


  CHANGING THE TAB DISTANCE

  Tabs are important for programming in languages which use indentation to 
  show nesting, as short-hand for producing white-space for leading indents. 
  As a programmer, you have to decide how to use indentation, and how or 
  whether tab characters map to your indentation scheme. 

  Ideally, tab characters map directly to the amount of indent that you use to 
  distinguish nesting levels in your code. Unfortunately, the Unix standard 
  for interpretation of tab characters is eight characters (probably dating 
  back to mechanical capabilities of the original teletype), which is usually 
  too coarse for a single indent. 

  Most text editors, NEdit included, allow you to change the interpretation of 
  the tab character, and many programmers take advantage of this, and set 
  their tabs to 3 or 4 characters to match their programming style. In NEdit 
  you set the hardware tab distance in Preferences -> Tabs... for the current 
  window, or Preferences -> Default Settings -> Tabs... (general), or 
  Preferences -> Default Settings -> Language Modes... (language-specific) to 
  change the defaults for future windows. 

  Changing the meaning of the tab character makes programming much easier 
  while you're in the editor, but can cause you headaches outside of the 
  editor, because there is no way to pass along the tab setting as part of a 
  plain-text file. All of the other tools which display, print, and otherwise 
  process your source code have to be made aware of how the tabs are set, and 
  must be able to handle the change. Non-standard tabs can also confuse other 
  programmers, or make editing your code difficult for them if their text 
  editors don't support changes in tab distance. 


  EMULATED TABS

  An alternative to changing the interpretation of the tab character is tab 
  emulation. In the Tabs... dialog(s), turning on Emulated Tabs causes the Tab 
  key to insert the correct number of spaces and/or tabs to bring the cursor 
  the next emulated tab stop, as if tabs were set at the emulated tab distance 
  rather than the hardware tab distance. Backspacing immediately after 
  entering an emulated tab will delete the fictitious tab as a unit, but as 
  soon as you move the cursor away from the spot, NEdit will forget that the 
  collection of spaces and tabs is a tab, and will treat it as separate 
  characters. To enter a real tab character with "Emulate Tabs" turned on, use 
  Ctrl+Tab. 

  It is also possible to tell NEdit not to insert ANY tab characters at all in 
  the course of processing emulated tabs, and in shifting and rectangular 
  insertion/deletion operations, for programmers who worry about the 
  misinterpretation of tab characters on other systems. 

-----------------
AUTO/SMART INDENT
-----------------

  Programmers who use structured languages usually require some form of 
  automatic indent, so that they don't have to continually re-type the 
  sequences of tabs and/or spaces needed to maintain lengthy running indents. 
  NEdit therefore offers "smart" indent, in addition to the traditional 
  automatic indent which simply lines up the cursor position with the previous 
  line. 


  SMART INDENT

  Smart indent macros are only available by default for C and C++, and while 
  these can easily be configured for different default indentation distances, 
  they may not conform to everyone's exact C programming style. Smart indent 
  is programmed in terms of macros in the NEdit macro language which can be 
  entered in: Preferences -> Default Settings -> Indent -> Program Smart 
  Indent. Hooks are provided for intervening at the point that a newline is 
  entered, either via the user pressing the Enter key, or through 
  auto-wrapping; and for arbitrary type-in to act on specific characters 
  typed. 

  To type a newline character without invoking smart-indent when operating in 
  smart-indent mode, hold the Shift key while pressing the Return or Enter 
  key. 


  AUTO-INDENT

  With Indent set to Auto (the default), NEdit keeps a running indent. When 
  you press the Return or Enter key, spaces and tabs are inserted to line up 
  the insert point under the start of the previous line. 

  Regardless of indent-mode, Ctrl+Return always does the automatic indent; 
  Shift+Return always does a return without indent. 


  BLOCK INDENTATION ADJUSTMENT

  The Shift Left and Shift Right commands as well as rectangular dragging can 
  be used to adjust the indentation for several lines at once. To shift a 
  block of text one character to the right, select the text, then choose Shift 
  Right from the Edit menu. Note that the accelerator keys for these menu 
  items are Ctrl+9 and Ctrl+0, which correspond to the right and left 
  parenthesis on most keyboards. Remember them as adjusting the text in the 
  direction pointed to by the parenthesis character. Holding the Shift key 
  while selecting either Shift Left or Shift Right will shift the text by one 
  tab stop (or by one emulated tab stop if tab emulation is turned on). The 
  help section "Shifting and Filling" under "Basic Operation" has details. 

-------------------
SYNTAX HIGHLIGHTING
-------------------

  Syntax Highlighting means using colors and fonts to help distinguish 
  language elements in programming languages and other types of structured 
  files. Programmers use syntax highlighting to understand code faster and 
  better, and to spot many kinds of syntax errors more quickly. 

  To use syntax highlighting in NEdit, select Highlight Syntax in the 
  Preferences menu. If NEdit recognizes the computer language that you are 
  using, and highlighting rules (patterns) are available for that language, it 
  will highlight your text, and maintain the highlighting, automatically, as 
  you type. 

  If NEdit doesn't correctly recognize the type of the file you are editing, 
  you can manually select a language mode from Language Modes in the 
  Preferences menu. You can also program the method that NEdit uses to 
  recognize language modes in Preferences -> Default Settings -> Language 
  Modes.... 

  If no highlighting patterns are available for the language that you want to 
  use, you can create new patterns relatively quickly. The Help section 
  "Highlighting Patterns" under "Customizing", has details. 

  If you are satisfied with what NEdit is highlighting, but would like it to 
  use different colors or fonts, you can change these by selecting Preferences 
  -> Default Settings -> Syntax Highlighting -> Text Drawing Styles. 
  Highlighting patterns are connected with font and color information through 
  a common set of styles so that colorings defined for one language will be 
  similar across others, and patterns within the same language which are meant 
  to appear identical can be changed in the same place. To understand which 
  styles are used to highlight the language you are interested in, you may 
  need to look at "Highlighting Patterns" section, as well. 

  Syntax highlighting is CPU intensive, and under some circumstances can 
  affect NEdit's responsiveness. If you have a particularly slow system, or 
  work with very large files, you may not want to use it all of the time. 
  Syntax highlighting introduces two kinds of delays. The first is an initial 
  parsing delay, proportional to the size of the file. This delay is also 
  incurred when pasting large sections of text, filtering text through shell 
  commands, and other circumstances involving changes to large amounts of 
  text. The second kind of delay happens when text which has not previously 
  been visible is scrolled in to view. Depending on your system, and the 
  highlight patterns you are using, this may or may not be noticeable. A 
  typing delay is also possible, but unlikely if you are only using the 
  built-in patterns. 

----------------------------
FINDING DECLARATIONS (CTAGS)
----------------------------

  NEdit can process tags files generated using the Unix ctags command or the 
  Exuberant Ctags program. Ctags creates index files correlating names of 
  functions and declarations with their locations in C, Fortran, or Pascal 
  source code files. (See the ctags manual page for more information). Ctags 
  produces a file called "tags" which can be loaded by NEdit. NEdit can manage 
  any number of tags files simultaneously. Tag collisions are handled with a 
  popup menu to let the user decide which tag to use. In 'Smart' mode NEdit 
  will automatically choose the desired tag based on the scope of the file or 
  module. Once loaded, the information in the tags file enables NEdit to go 
  directly to the declaration of a highlighted function or data structure name 
  with a single command. To load a tags file, select "Load Tags File" from the 
  File menu and choose a tags file to load, or specify the name of the tags 
  file on the NEdit command line: 

      nedit -tags tags

  NEdit can also be set to load a tags file automatically when it starts up. 
  Setting the X resource nedit.tagFile to the name of a tag file tells NEdit 
  to look for that file at startup time (see "Customizing NEdit"). The file 
  name can be either a complete path name, in which case NEdit will always 
  load the same tags file, or a file name without a path or with a relative 
  path, in which case NEdit will load it starting from the current directory. 
  The second option allows you to have different tags files for different 
  projects, each automatically loaded depending on the directory you're in 
  when you start NEdit. Setting the name to "tags" is an obvious choice since 
  this is the name that ctags uses. NEdit normally evaluates relative path tag 
  file specifications every time a file is opened. All accessible tag files 
  are loaded at this time. To disable the automatic loading of tag files 
  specified as relative paths, set the X resource 
  nedit.alwaysCheckRelativeTagsSpecs to False. 

  To unload a tags file, select "Un-load Tags File" from the File menu and 
  choose from the list of tags files. NEdit will keep track of tags file 
  updates by checking the timestamp on the files, and automatically update the 
  tags cache. 

  To find the definition of a function or data structure once a tags file is 
  loaded, select the name anywhere it appears in your program (see "Selecting 
  Text") and choose "Find Definition" from the Search menu. 

--------
CALLTIPS
--------

  Calltips are little yellow boxes that pop up to remind you what the 
  arguments and return type of a function are. More generally, they're a UI 
  mechanism to present a small amount of crucial information in a prominent 
  location. To display a calltip, select some text and choose "Show Calltip" 
  from the Search menu. To kill a displayed calltip, hit Esc. 

  Calltips get their information from one of two places -- either a tags file 
  (see "Finding Declarations (ctags)") or a calltips file. First, any loaded 
  calltips files are searched for a definition, and if nothing is found then 
  the tags database is searched. If a tag is found that matches the hilighted 
  text then a calltip is displayed with the first few lines of the definition 
  -- usually enough to show you what the arguments of a function are. 

  You can load a calltips file by using choosing "Load Calltips File" from the 
  File menu. You can unload a calltips file by selecting it from the "Unload 
  Calltips File" submenu of the File menu. You can also choose one or more 
  default calltips files to be loaded for each language mode using the 
  "Default calltips file(s)" field of the Language Modes dialog. 

  The calltips file format is very simple. calltips files are organized in 
  blocks separated by blank lines. The first line of the block is the key, 
  which is the word that is matched when a calltip is requested. The rest of 
  the block is displayed as the calltip. 

  Almost any text at all can appear in a calltip key or a calltip. There are 
  no special characters that need to be escaped. The only issues to note are 
  that trailing whitespace is ignored, and you cannot have a blank line inside 
  a calltip. (Use a single period instead -- it'll be nearly invisible.) You 
  should also avoid calltip keys that begin and end with '*' characters, since 
  those are used to mark special blocks. 

  There are five special block types--comment, include, language, alias, and 
  version--which are distinguished by their first lines, "* comment *", "* 
  include *", "* language *", "* alias *", and "* version *" respectively 
  (without quotes). 

  Comment blocks are ignored when reading calltips files. 

  Include blocks specify additional calltips files to load, one per line. The 
  ~ character can be used for your $HOME directory, but other shell shortcuts 
  like * and ? can't be used. Include blocks allow you to make a calltips file 
  for your project that includes, say, the calltips files for C, Motif, and 
  Xt. 

  Language blocks specify which language mode the calltips should be used