pyeditor -- A Scriptable Text Editor

How to add a new toolbar item

1. Find the method create_toolbar in pyeditor.py.

2. Add a new pix map using a line something like the following:

       testpix, testmask = gtk.create_pixmap_from_xpm(win, None, home + "pixmaps/test.xpm")
   

   If you need a new pix map for your button, you will have to create it yourself.

3. Add the new button to the toolbar using something like the following:

       toolbar.append_item("Test", "Run a test",
           "Run a test",
           gtk.GtkPixmap(testpix, testmask),
           self.run_test)
   

4. Implement the method (in this case run_test. Methods used to implement toolbar actions are similar to those used to implement menu item actions. Follow the suggestions for menu item methods above.

How to create a new toolbar

1. In class PyeditorApp, find the definition of method create_toolbar. Duplicate and rename this method definition.

2. Find the call to create_toolbar in method create_window. Add a call to your new toolbar method right after (or before) that call. At this point you might want to run your editor to ensure that it creates two toolbars.

3. Now modify your new toolbar method so that it has the buttons that you need and so that they call the methods you want called. See the section on how to add a new toolbar item for help with this. In particular, for each toolbar item, you will want to change:
   • The text for the item, i.e. the text that will show in addition to or in place of the icon.

   • The text for the tool-tip.

   • The pixmap for the icon.

   • The call-back method.

How to customize behavior for a specific file type

The default behaviors are in class Custom. To implement behavior for a new file type, create a new sub-class of class Custom. As an example, we'll add a new behavior for a property file type which has extension ".prop".

Follow these steps:

1. Create a new class, for example, PropertyCustom as a sub-class of class Custom:

       class PropertyCustom(Custom):
           pass
   

2. ScintillaX is an extension of class Scintilla, the Python wrapping of the Scintilla editor component. Instances of the buffer are instances of class ScintillaX. In the constructor for class ScintillaX, add another case to the if statement that checks the file extension and then creates an instance of the custom class. Use something like the following:

       elif ext == '.prop':
           self.fileCustom = PropertyCustom()
   

3. Implement your special behavior in the custom class, in this case in class PropertyCustom. Here are some hints:
   • In the constructor of your custom class, call the constructor in class Custom to initialize defaults:

         class PropertyCustom(Custom):
             def __init__(self):
                 Custom.__init__(self)
     

   • Override defaults from class Custom as necessary. For example:

         class PropertyCustom(Custom):
             def __init__(self):
                 Custom.__init__(self)
                 self.defaultTabWidth = 8
                 self.useTabs = 1
     

   • See classes PythonCustom, CppCustom, XmlCustom, etc in pyeditor.py for examples.

   • In order to add a new category of behavior, you may need to do the following:
     • Add a new member variable and initialize it to a default value in the constructor of class Custom and initialize it to a special value in your specializing class.

     • Add a new behavior by adding a default method in class Custom and the same method in your specialization class.

Extending pyeditor in C and C++

pyeditor comes with several examples of using Python modules written in C to extend pyeditor. See the file utils_xml.py, where it uses libxml_saxlib (available at http://www.rexx.com/~dkuhlman/libxml_saxlib.html) and libxsltmod (available at http://www.rexx.com/~dkuhlman/libxsltmod.html).

The important thing to remember here is that any Python module can be used in extending pyeditor. From the point of view of using the module, it makes no difference whether the module was written in C/C++ or in plain Python.

Python is particularly well suited for being extended in C and C++. "Python is glue." In fact SWIG (Simplified Wrapper Interface Generator available at http://www.swig.org) will, for some purposes generate these wrappers for you.

Back to top

How to change the buffer menu and pop-up menu etc

The method buffers_buildmenu is called to create the Buffers menu. The method popup_buildmenu is called to create the popup menu (which appears when you right-click in the text edit pane). You can add or remove items in these menus by modifying these two methods.

The method buffers_buildmenu replaces a menu that is created in create_menus. Look at the calls to buffers_buildmenu and the definition of that method itself to learn how to specialize other menus that change dynamically while the editor is running.

Back to top