MonkeyFish Editor

The editor is an embedded Scintilla editor that you may have encountered by using tools such as KDevelop or Anjuta. It is a full featured editing environment with syntax highlighting for many programming languages.

The side bar contains a project window and a directory window. The directory window gives full access to the disk and allows you to edit, delete, rename, create new folders and execute files. The project window allows you to gather resources you need to construct programs in a convienient tree along with the tools you may need for construction.

The output window shows the output from any commands you may execute. It is hooked into the "print" function in the scripting environment. It also allows you to move between errors, save the output and kill the currently running process.

You start the editor by clicking on it's icon or typing monkeyfish at the prompt.

        bash$ monkeyfish
      

To create a new file, choose File->New (Ctrl-N) The application will then display a new tab in the editor window.

To open a file, choose File->Open (Ctrl-O). The application will open a file selector to allow you to choose a file. The file will be opened on a new tab on the editor window. If the file is already open, the tab for that file will be selected.

To save a file, choose File->Save (Ctrl-S) . The application will open a file selector to allow you to choose a file.

You can edit text in the following ways:

You can undo your last edit with Edit->Undo (Ctrl-Z).

You can redo your last undo with Edit->Redo (Ctrl-Shift-Z).

Edit->Find (Ctrl-F)

Set the syntax highlighting mode by choosing Tools->syntax and then selecting the language style you want to use.

Syntax highlighting is confgured via scripts. Open the Tools->Scripts... menu and navigate to the syntax subdirectory and look at one of the sytax files therein for an example. You can add new languages there and they will be picked up the next time MonkeyFish launches.

Currently there is no UI element to use to associate scripts with file extentions. If you want to add new associations you need to edit the config script by hand or the registry in windows (see below). Open the file "$HOME/.MonkeyFish" in GTK or "$HOME/Library/Preferences/MonkeyFish Preferences" in os/x

[files]
[files/exts]
		

If those sections are not there you can add them. Underneath [files/exts] you can make your association to scripts by adding the file extention and the script name without the path like so...

[files]
[files/exts]
java=Java.mf
xml=xml.mf
html=xml.mf
cpp=CPP.mf
mf=Lua.mf
		

You can indent and unindent the current selection with Edit->Indent (Ctrl-]) and Edit->Unindent (Ctrl-[) respectively.

You can select a block of text between braces by putting the caret before the brace in question and choosing Edit->Match Brace.

There is a macro facility available via the Ctrl-1 to Ctrl-9 keys. Macros are MonkeyFish scripts that are accessable instantly with the above mentioned keys. Macros are hooked to scripts in your $SCRIPTDIR called "macro1.mf" up to "macro9.mf". They can perform any operation available to scripts.

For example, lets create a macro to insert a C-style comment. Open "Tools->Scripts" and edit the file "macro1.mf". Add the following text to it and save it...

		
comment = [[
/**
 *
 */
]]

assert( mf, "MonkeyFish not available")
e = assert(mf.selected(), "No editor selected")
e:insert( comment, e:go("bol") )
		

Now place the caret at the first line of a function or method definition in some code and press Ctrl-1.

There is an emacs key compatibility mode because, lets face it, you can't really be productive as a programmer without emacs bindings. Of course it's not a fully compatible mode since MonkeyFish is not emacs, but there is enough to hopefully keep you comfortable and productive.

The toolbar in the project window offers easy access to some common functions. You can open and save projects with the first two buttons.

The next three buttons are hooked into the "Tools" branch of the project tree. If you click on the "Build" button it looks for an entry called "Build" under the "Tools" branch and excutes that. It can either be a Shell tool or a Script tool. "Execute" and "Debug" work them same way. The tool itself can do anything you need so "Build" may run make or it may be hooked into a script that writes a letter to congress.

The popup menu in the project window offers access to various functions depending on the context.

Right-click on the project root:

Right-click on a file or directory:

The project window allows you to organize your source artifacts into more easily managed work areas.

This tool is triggered, if present, from the toolbar Build button. If you wanted to run ant when the build button is pressed, add a Shell Tool as

"Build#ant"

.

This tool is triggered, if present, from the toolbar Execute button. If you wanted to execute the program you are working on by clicking this button add a Shell Tool as

"Execute#cd build;myproggy"

.

This tool is triggered, if present, from the toolbar Debug button. If you wanted to run the debugger by clicking on the Debug button add a Shell tool as

"Debug#cd src;gdb myproggy"

.

MonkeyFish uses Lua for its scripting engine. Lua is a light-wieght programming language designed for extending applications. It combines a procedural syntax with a powerful data description constructs based on associative arrays and extensible semantics. It is dynamically typed and has automatic garbage collection.

Here is an example of a simple MonkeyFish script...

	
-- open a new file and get the editor object
e = mf.new()
-- insert some text into the editor
e:insert("Welcome to MonkeyFish", 0 )
-- save the file to disk
mf.save( "junk.txt" )
    

You can open a new editor and paste this text in. Then type Ctrl-Shift-E to execute it directly. There is no need to save it first.

You should read the documentation in the Lua manual in order to understand the power of the language. As an embedded language MonkeyFish offers some additional constructs that allow you to manipulate the environment.

These are some ideas and examples of the useage of scripting in the MonkeyFish environment.

    
text = [[
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
	"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head>
  <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
  <meta http-equiv="Content-Language" content="en-us" />
  <meta name="ROBOTS" content="ALL" />
  <meta name="Copyright" content="" />
  <meta name="Keywords" content="" />
  <meta name="Description" content="" />
  <meta name="MSSmartTagsPreventParsing" content="true" />
  <style type="text/css" media="all">
    @import "master.css";
  </style>
  
  <title></title>
  
</head>
<body>
</body>
</html>
]]

e = mf.new()
e:insert( text, 0 )
    
	

There are some globals available to your script from within the MonkeyFish scripting environment.

The mf table allows you to interact with the MonkeyFish enviroment itself.

The editor object allows you to interact with the text in an edit buffer. The editor is zero based so the first position is 0 and the first line is 0.