summarylogtreecommitdiffstats
diff options
context:
space:
mode:
authorConnor Behan2015-07-01 00:13:44 -0400
committerConnor Behan2015-07-01 00:13:44 -0400
commit5970e6dd15d46ec3a93c4a149aa930bed0c9f9f7 (patch)
treeb85463bb75f48e22fa3028d0f59d8775c6c613c9
downloadaur-5970e6dd15d46ec3a93c4a149aa930bed0c9f9f7.tar.gz
Initial import
Diffstat
-rw-r--r--.SRCINFO30
-rw-r--r--PKGBUILD37
-rw-r--r--api_update.patch756
-rw-r--r--internal_moo.patch4974
-rw-r--r--nodrm.patch13
-rw-r--r--pida.desktop9
-rw-r--r--pida.install13
7 files changed, 5832 insertions, 0 deletions
diff --git a/.SRCINFO b/.SRCINFO
new file mode 100644
index 000000000000..b8a86e08a87c
--- /dev/null
+++ b/.SRCINFO
@@ -0,0 +1,30 @@
+pkgbase = pida-hg
+ pkgdesc = Python Integrated Development Application
+ pkgver = 2921.be90809a5d81
+ pkgrel = 1
+ url = http://pidsoff.appspot.com/pida
+ install = pida.install
+ arch = any
+ license = custom
+ makedepends = mercurial
+ makedepends = python2-distribute
+ depends = vte
+ depends = python2-simplejson
+ depends = python2-pygtkhelpers
+ depends = dbus-python
+ depends = python2-logbook
+ depends = python2-notify
+ depends = python2-py
+ optdepends = python2-anyvc: version control integration
+ optdepends = python2-apipkg: version control integration
+ provides = pida
+ conflicts = pida
+ source = hg+https://bitbucket.org/aafshar/pida-main
+ source = pida.desktop
+ source = nodrm.patch
+ md5sums = SKIP
+ md5sums = 0216466cf5f64238c90b5e07df71ce3a
+ md5sums = 479c24a04069112f610667f9746011d4
+
+pkgname = pida-hg
+
diff --git a/PKGBUILD b/PKGBUILD
new file mode 100644
index 000000000000..e89a335419e4
--- /dev/null
+++ b/PKGBUILD
@@ -0,0 +1,37 @@
+# Contributor: Connor Behan <connor.behan@gmail.com>
+
+pkgname=pida-hg
+pkgver=2921.be90809a5d81
+pkgrel=1
+pkgdesc="Python Integrated Development Application"
+arch=('any')
+url="http://pidsoff.appspot.com/pida"
+license=('custom')
+depends=('vte' 'python2-simplejson' 'python2-pygtkhelpers' 'dbus-python' 'python2-logbook' 'python2-notify' 'python2-py')
+makedepends=('mercurial' 'python2-distribute')
+optdepends=('python2-anyvc: version control integration'
+ 'python2-apipkg: version control integration')
+provides=('pida')
+conflicts=('pida')
+source=(hg+https://bitbucket.org/aafshar/pida-main pida.desktop nodrm.patch)
+install=pida.install
+
+pkgver() {
+ cd "$srcdir"/pida-main
+ echo `hg identify -n`.`hg identify -i`
+}
+
+package() {
+ cd "$srcdir"/pida-main
+
+ patch -Np1 -i $srcdir/nodrm.patch
+ #patch -Np1 -i $srcdir/internal_moo.patch
+ #patch -Np1 -i $srcdir/api_update.patch
+ python2 setup.py install --root="$pkgdir" --prefix=/usr
+
+ install -Dm644 COPYING "$pkgdir"/usr/share/licenses/pida/LICENSE
+
+ install -Dm644 pida/resources/pixmaps/pida-icon.png "$pkgdir"/usr/share/pixmaps/pida.png
+ install -Dm644 $startdir/src/pida.desktop "$pkgdir"/usr/share/applications/pida.desktop
+}
+md5sums=('SKIP' '0216466cf5f64238c90b5e07df71ce3a' '479c24a04069112f610667f9746011d4')
diff --git a/api_update.patch b/api_update.patch
new file mode 100644
index 000000000000..50cac108c013
--- /dev/null
+++ b/api_update.patch
@@ -0,0 +1,756 @@
+diff -ru pida.orig/pida/editors/mooedit/mooedit.py pida/pida/editors/mooedit/mooedit.py
+--- pida.orig/pida/editors/mooedit/mooedit.py 2012-03-10 02:57:31.000000000 -0800
++++ pida/pida/editors/mooedit/mooedit.py 2012-03-10 02:58:19.000000000 -0800
+@@ -15,28 +15,7 @@
+ import re
+ from gtk import gdk
+
+-
+-# UGLY UGLY workarround as suggested by muntyan_
+-# this will be changed someday when therue will be a correct
+-# api for this.
+-
+-from pida.core.environment import home, workspace_name
+-
+-SYS_DATA = os.environ.get("XDG_DATA_DIRS",
+- "/usr/share:/usr/local/share")
+-
+-MOO_DATA_DIRS=os.pathsep.join((
+- str(home()/'moo'),
+- os.path.join(os.path.dirname(__file__), "shared"),
+- os.pathsep.join([os.path.join(x, "moo")
+- for x in SYS_DATA.split(os.pathsep)]),
+- "/usr/share/moo",
+- "/usr/local/share/moo",
+- "/usr/share/pida",
+- "/usr/local/share/pida",
+- ))
+-
+-os.environ['MOO_DATA_DIRS'] = MOO_DATA_DIRS
++from pida.core.environment import workspace_name
+
+ def _load_pix(fn):
+ #XXX: not zip save
+@@ -68,7 +47,6 @@
+ from pida.services.buffer import view as buffer_view
+
+
+-
+ # locale
+ from pida.core.locale import Locale
+ locale = Locale('mooedit')
+@@ -147,7 +125,7 @@
+ icon_name = 'package_utilities'
+
+ def create_ui(self):
+- prefs = self.svc._editor_instance.prefs_page()
++ prefs = moo.PrefsPage()
+ prefs.emit('init')
+ prefs.show()
+ vbox = gtk.VBox()
+@@ -255,15 +233,16 @@
+
+ def set_editor(self, editor):
+ self.editor = editor
+- self.editor.props.buffer.connect('changed', self.on_changed)
+- self.add(self.editor)
+- self.editor.show()
++ self.editor_view = editor.get_view()
++ self.editor_view.props.buffer.connect('changed', self.on_changed)
++ self.add(self.editor_view)
++ self.editor_view.show()
+
+ def on_changed(self, textbuffer):
+ #FIXME: this doesn't work, nor does connect_after work correctly.
+ # this is always one changed event to late. as the markers line position
+ # is updated after this event :(
+- self.editor.props.buffer.do_changed(textbuffer)
++ self.editor_view.props.buffer.do_changed(textbuffer)
+ for lm in self.line_markers:
+ lm.update(lm._moo_marker.get_line()+1)
+ return True
+@@ -282,7 +261,7 @@
+ # should be deleted
+ if marker in self.line_markers and hasattr(marker, '_moo_marker'):
+ marker._moo_marker.props.visible = False
+- self.editor.props.buffer.delete_line_mark(marker._moo_marker)
++ self.editor_view.props.buffer.delete_line_mark(marker._moo_marker)
+ self.line_markers.remove(marker)
+ return
+
+@@ -293,14 +272,14 @@
+ lm.props.visible = True
+ marker._moo_marker = lm
+
+- buf = self.editor.props.buffer
++ buf = self.editor.get_buffer()
+ if marker not in self.line_markers:
+ self.line_markers.append(marker)
+ buf.add_line_mark(marker._moo_marker,
+ min(max(0, int(marker.line)-1),buf.get_line_count()))
+ marker._moo_marker.props.visible = True
+ else:
+- self.editor.props.buffer.move_line_mark(marker._moo_marker,
++ self.editor_view.props.buffer.move_line_mark(marker._moo_marker,
+ min(max(0, int(marker.line)-1),buf.get_line_count()))
+
+
+@@ -440,7 +419,6 @@
+ # ne need to disconnect the accelerator as our text widget are
+ # handeling the shortcuts
+ act.disconnect_accelerator()
+- act.opt.add_notify(self.on_completer_change)
+
+ act = self.create_action(
+ 'mooedit_complete_toggle',
+@@ -452,7 +430,6 @@
+ '<Control>space',
+ )
+ act.disconnect_accelerator()
+- act.opt.add_notify(self.on_completer_change)
+
+ act = self.create_action(
+ 'mooedit_completer_next',
+@@ -464,7 +441,6 @@
+ 'Down',
+ )
+ act.disconnect_accelerator()
+- act.opt.add_notify(self.on_completer_change)
+
+ act = self.create_action(
+ 'mooedit_completer_prev',
+@@ -476,7 +452,6 @@
+ 'Up',
+ )
+ act.disconnect_accelerator()
+- act.opt.add_notify(self.on_completer_change)
+
+ act = self.create_action(
+ 'mooedit_completer_accept',
+@@ -488,7 +463,6 @@
+ 'Tab',
+ )
+ act.disconnect_accelerator()
+- act.opt.add_notify(self.on_completer_change)
+
+ def on_completer_change(self, *args):
+ self.svc._update_keyvals()
+@@ -499,35 +473,35 @@
+
+ def on_save_as(self, action):
+ # open in current filebrowser path
+- moo.utils.prefs_new_key_string('Editor/last_dir')
+- moo.utils.prefs_set_string('Editor/last_dir',
++ moo.prefs_new_key_string('Editor/last_dir')
++ moo.prefs_set_string('Editor/last_dir',
+ self.svc.boss.cmd('filemanager', 'get_browsed_path'))
+- self.svc._current.editor.save_as()
++ self.svc._current.editor.save_as(None)
+
+ def on_reload(self, action):
+ self.svc.reload_document(self.svc._current.document)
+
+ def on_find(self, action):
+- self.svc._current.editor.emit('find-interactive')
++ self.svc._current.editor_view.emit('find-interactive')
+
+ def on_find_next(self, action):
+- self.svc._current.editor.emit('find-next-interactive')
++ self.svc._current.editor_view.emit('find-next-interactive')
+
+ def on_find_prev(self, action):
+- self.svc._current.editor.emit('find-prev-interactive')
++ self.svc._current.editor_view.emit('find-prev-interactive')
+
+ def on_replace(self, action):
+- self.svc._current.editor.emit('replace-interactive')
++ self.svc._current.editor_view.emit('replace-interactive')
+
+ def on_find_word_next(self, action):
+- self.svc._current.editor.emit('find-word-at-cursor', True)
++ self.svc._current.editor_view.emit('find-word-at-cursor', True)
+
+ def on_find_word_prev(self, action):
+- self.svc._current.editor.emit('find-word-at-cursor', False)
++ self.svc._current.editor_view.emit('find-word-at-cursor', False)
+
+ def on_goto(self, action):
+ cl = self.svc.get_current_line()
+- self.svc._current.editor.emit('goto-line-interactive')
++ self.svc._current.editor_view.emit('goto-line-interactive')
+ nl = self.svc.get_current_line()
+ if cl != nl:
+ self.svc.boss.get_service('buffer').emit('document-goto',
+@@ -537,10 +511,10 @@
+ self.svc.boss.editor.goto_last_edit()
+
+ def on_comment(self, action):
+- self.svc._current.editor.emit('comment')
++ self.svc._current.editor.comment_selection()
+
+ def on_uncomment(self, action):
+- self.svc._current.editor.emit('uncomment')
++ self.svc._current.editor.uncomment_selection()
+
+ class PidaMooInput(object):
+ """
+@@ -551,13 +525,14 @@
+ self.svc = svc
+ self.editor = editor
+ self.document = document
++ self.editor_view = editor.get_view()
+ self.completer_window = PidaCompleterWindow(type_=gtk.WINDOW_POPUP,
+ show_input=False)
+ self.completer = self.completer_window.widget
+ self.completer.show_all()
+ self.completer.connect("user-accept", self.accept)
+ self.completer.connect("suggestion-selected", self.suggestion_selected)
+- self.editor.connect("cursor-moved", self.on_cursor_moved)
++ self.editor_view.connect("cursor-moved", self.on_cursor_moved)
+ self.model = SuggestionsList()
+ self.completer.set_model(self.model)
+
+@@ -571,26 +546,26 @@
+ self.completer_end = None
+ self.show_auto = False
+ self._task = None
+-
++
+ # db stuff for the autocompleter
+ self.list_matcher = re.compile("""\w{3,100}""")
+ self.list_cache = {}
+ self.list_all = set()
+
+- editor.connect("key-press-event", self.on_keypress)
+- editor.connect("focus-out-event", self.on_do_hide)
+- editor.get_toplevel().connect("focus-out-event", self.on_do_hide)
++ self.editor_view.connect("key-press-event", self.on_keypress)
++ self.editor_view.connect("focus-out-event", self.on_do_hide)
++ self.editor_view.get_toplevel().connect("focus-out-event", self.on_do_hide)
+ #editor.connect_after("key-press-event", self.on_after_keypress)
+
+ def disconnect(self):
+- self.editor.disconnect_by_func(self.on_keypress)
+- self.editor.disconnect_by_func(self.on_do_hide)
++ #self.editor_view.disconnect_by_func(self.on_keypress)
++ #self.editor_view.disconnect_by_func(self.on_do_hide)
+ #try:
+ # self.editor.get_toplevel().disconnect_by_func(self.on_do_hide)
+ #except ValueError: pass
+ self.completer.disconnect_by_func(self.accept)
+ self.completer.disconnect_by_func(self.suggestion_selected)
+- self.editor.disconnect_by_func(self.on_cursor_moved)
++ #self.editor_view.disconnect_by_func(self.on_cursor_moved)
+
+
+ #def on_
+@@ -694,15 +669,15 @@
+ self.completer_end = buf.create_mark('completer_end',
+ buf.get_iter_at_offset(cpos))
+
+- rec = self.editor.get_iter_location(
+- self.editor.props.buffer.get_iter_at_offset(
++ rec = self.editor_view.get_iter_location(
++ self.editor.get_buffer().get_iter_at_offset(
+ buf.props.cursor_position))
+- pos = self.editor.buffer_to_window_coords(gtk.TEXT_WINDOW_WIDGET,
++ pos = self.editor_view.buffer_to_window_coords(gtk.TEXT_WINDOW_WIDGET,
+ rec.x, rec.y + rec.height)
+
+ #tw = self.editor.window.get_toplevel()
+ #abspos = tw.get_position()
+- abspos = self.editor.window.get_origin()
++ abspos = self.editor_view.window.get_origin()
+ rpos = (pos[0]+abspos[0], pos[1]+abspos[1])
+ #self.completer_window.show_all()
+ #self.completer_window.move(rpos[0],rpos[1])
+@@ -712,7 +687,7 @@
+ #self.completer_window.window.set_focus_on_map(False)
+ #self.completer_window.window.set_skip_taskbar_hint(True)
+ #self.completer_window.window.set_skip_pager_hint(True)
+- self.editor.grab_focus()
++ self.editor_view.grab_focus()
+ #if not self.completer_added:
+ #self.editor.add_child_in_window(self.completer,
+ # gtk.TEXT_WINDOW_TOP,
+@@ -765,13 +740,13 @@
+ return buf.get_text(i1, i2)
+
+ def _delete_typed(self):
+- buf = self.editor.props.buffer
++ buf = self.editor.get_buffer()
+ i1 = buf.get_iter_at_mark(self.completer_pos)
+ i2 = buf.get_iter_at_mark(self.completer_start)
+ buf.delete(i1, i2)
+
+ def _insert_typed(self, text):
+- buf = self.editor.props.buffer
++ buf = self.editor.get_buffer()
+ i1 = buf.get_iter_at_mark(self.completer_pos)
+ buf.insert(i1, text)
+ buf.move_mark(self.completer_start, i1)
+@@ -784,7 +759,7 @@
+ self._replace_typed(self._get_typed() + char)
+
+ def _replace_typed(self, text):
+- buf = self.editor.props.buffer
++ buf = self.editor.get_buffer()
+ i1 = buf.get_iter_at_mark(self.completer_pos)
+ i2 = buf.get_iter_at_mark(self.completer_start)
+ buf.delete(i1, i2)
+@@ -793,13 +768,13 @@
+ buf.move_mark(self.completer_start, i1)
+
+ def _get_suggested(self):
+- buf = self.editor.props.buffer
++ buf = self.editor.get_buffer()
+ i1 = buf.get_iter_at_mark(self.completer_start)
+ i2 = buf.get_iter_at_mark(self.completer_end)
+ return buf.get_text(i1, i2)
+
+ def _delete_suggested(self):
+- buf = self.editor.props.buffer
++ buf = self.editor.get_buffer()
+ if not self.completer_start or not self.completer_end:
+ return
+ i1 = buf.get_iter_at_mark(self.completer_start)
+@@ -807,7 +782,7 @@
+ buf.delete(i1, i2)
+
+ def d(self):
+- buf = self.editor.props.buffer
++ buf = self.editor.get_buffer()
+ if self.completer_start:
+ print "cur", buf.props.cursor_position
+ print "pos", buf.get_iter_at_mark(self.completer_pos).get_offset()
+@@ -816,7 +791,7 @@
+
+
+ def _replace_suggested(self, text, mark=True):
+- buf = self.editor.props.buffer
++ buf = self.editor.get_buffer()
+ i1 = buf.get_iter_at_mark(self.completer_start)
+ i2 = buf.get_iter_at_mark(self.completer_end)
+ buf.delete(i1, i2)
+@@ -895,8 +870,8 @@
+ # if we are in show_auto mode, the completion window
+ # is delayed until we have the first visible item.
+ if not self.completer_visible and self.show_auto and \
+- self.editor.get_toplevel().has_toplevel_focus() and \
+- self.editor.is_focus():
++ self.editor_view.get_toplevel().has_toplevel_focus() and \
++ self.editor_view.is_focus():
+ if len(self.completer.model):
+ self.completer_window.show()
+
+@@ -963,7 +938,7 @@
+ # and the code later should be a extra function
+ # but doesn't work as this super function returns True
+ # and stops the processing of connect_after functions
+- modified = self.editor.do_key_press_event(editor, event)
++ modified = self.editor_view.do_key_press_event(self.editor_view, event)
+ #print modified, repr(event.string)
+ #self.d()
+ #if self.completer_start:
+@@ -1056,8 +1031,7 @@
+ class MooeditEventsConfig(EventsConfig):
+
+ def subscribe_all_foreign(self):
+- self.subscribe_foreign('editor', 'marker-changed',
+- self.marker_changed)
++ #self.subscribe_foreign('editor', 'marker-changed', self.marker_changed)
+ self.subscribe_foreign('buffer', 'document-typchanged',
+ self.doctype_changed)
+
+@@ -1066,8 +1040,7 @@
+
+ def doctype_changed(self, document):
+ if document.doctype and getattr(document, 'editor', None):
+- document.editor.set_lang(MAPPINGS.get(document.doctype.internal,
+- None))
++ document.editor.props.lang=MAPPINGS.get(document.doctype.internal, None)
+
+ # Service class
+ class Mooedit(EditorService):
+@@ -1081,27 +1054,17 @@
+ events_config = MooeditEventsConfig
+
+ def pre_start(self):
++ # Horrible hack
++ self._called_once = False
+ # mooedit is able to open empty documents
+ self._last_modified = None
+ self._docwin = None
+ self.features.publish('new_file')
+
+ try:
+- self.script_path = os.path.join(pida_home, 'pida_mooedit.rc')
+- self._state_path = os.path.join(pida_home, 'pida_mooedit.state')
+- try:
+- moo.utils.prefs_load(sys_files=None, file_rc=self.script_path, file_state=self._state_path)
+- except gobject.GError:
+- pass
+- # if a workspace specific rc file exists, load it and make it the current one
+- if os.path.exists(os.path.join(pida_home, 'pida_mooedit.%s.rc' %workspace_name())):
+- self.script_path = os.path.join(pida_home, 'pida_mooedit.%s.rc' %workspace_name())
+- try:
+- moo.utils.prefs_load(sys_files=None, file_rc=self.script_path, file_state=None)
+- except gobject.GError:
+- pass
+- self._editor_instance = moo.edit.create_editor_instance()
+- moo.edit.plugin_read_dirs()
++ self._editor_instance = moo.Editor.create_instance()
++ self._app_instance = moo.App()
++ self._app_instance.emit('load-session')
+ self._documents = {}
+ self._current = None
+ self._main = MooeditMain(self)
+@@ -1125,6 +1088,8 @@
+ return False
+
+ def start(self):
++ if self._called_once:
++ return True
+ # we only disable the buttons if no document is loaded
+ # session may already have loaded docs
+ if not len(self._documents):
+@@ -1132,10 +1097,12 @@
+ self.get_action('mooedit_last_edit').set_sensitive(False)
+ self._update_keyvals()
+ self.boss.get_service('editor').emit('started')
++ # It seems to start twice no matter what medit is installed
++ self._called_once = True
+
+ # build a mapping table
+- build_mapping(moo.edit.lang_mgr_default(),
+- self.boss.get_service('language').doctypes)
++ #build_mapping(moo.edit.lang_mgr_default(),
++ # self.boss.get_service('language').doctypes)
+
+ return True
+
+@@ -1147,7 +1114,8 @@
+ view.update_marker(marker)
+
+ def save_moo_state(self):
+- moo.utils.prefs_save(self.script_path, self._state_path)
++ self._app_instance.emit('save-session')
++ #moo.utils.prefs_save(self.script_path, self._state_path)
+
+ def show_preferences(self, visible):
+ if visible:
+@@ -1194,15 +1162,15 @@
+
+ def _update_keyvals(self):
+ self.key_toggle = gtk.accelerator_parse(
+- self.get_keyboard_options()['mooedit_complete_toggle'].value)
++ self.actions._defaults['mooedit_complete_toggle'])
+ self.key_close = gtk.accelerator_parse(
+- self.get_keyboard_options()['mooedit_completer_close'].value)
++ self.actions._defaults['mooedit_completer_close'])
+ self.key_next = gtk.accelerator_parse(
+- self.get_keyboard_options()['mooedit_completer_next'].value)
++ self.actions._defaults['mooedit_completer_next'])
+ self.key_prev = gtk.accelerator_parse(
+- self.get_keyboard_options()['mooedit_completer_prev'].value)
++ self.actions._defaults['mooedit_completer_prev'])
+ self.key_accept = gtk.accelerator_parse(
+- self.get_keyboard_options()['mooedit_completer_accept'].value)
++ self.actions._defaults['mooedit_completer_accept'])
+
+ def open(self, document):
+ """Open a document"""
+@@ -1253,32 +1221,25 @@
+
+ def save(self):
+ """Save the current document"""
+- # man, medit resets the language on save
+- olang = self._current.editor.props.buffer.get_lang()
+ self._current.editor.save()
+- self._current.editor.set_lang(olang)
+- gcall(self._current.editor.set_lang, olang)
+ self.boss.cmd('buffer', 'current_file_saved')
+
+ def save_as(self):
+ """Save the current document"""
+- olang = self._current.editor.props.buffer.get_lang()
+- self._current.editor.save_as()
+- self._current.editor.set_lang(olang)
+- gcall(self._current.editor.set_lang, olang)
++ self._current.editor.save_as(None)
+ self.boss.cmd('buffer', 'current_file_saved')
+
+ def cut(self):
+ """Cut to the clipboard"""
+- self._current.editor.emit('cut-clipboard')
++ self._current.editor_view.emit('cut-clipboard')
+
+ def copy(self):
+ """Copy to the clipboard"""
+- self._current.editor.emit('copy-clipboard')
++ self._current.editor_view.emit('copy-clipboard')
+
+ def paste(self):
+ """Paste from the clipboard"""
+- self._current.editor.emit('paste-clipboard')
++ self._current.editor_view.emit('paste-clipboard')
+
+ def undo(self):
+ self._current.editor.undo()
+@@ -1294,7 +1255,7 @@
+
+ def goto_line(self, line):
+ """Goto a line"""
+- self._current.editor.move_cursor(line-1, 0, False, True)
++ self._current.editor_view.move_cursor(line-1, 0, False, True)
+ self.boss.get_service('buffer').emit('document-goto',
+ document=self._current.document, line=line-1)
+
+@@ -1311,7 +1272,7 @@
+
+ def grab_focus(self):
+ if self._current is not None:
+- self._current.editor.grab_focus()
++ self._current.editor_view.grab_focus()
+
+ def _changed_page(self, notebook, page, page_num):
+ self._current = self._embed.get_nth_page(page_num)
+@@ -1321,39 +1282,19 @@
+ """
+ Reloads a document from disc
+ """
+- # TODO: moo does no export reload functionality, so this really sucks
+- view = self._documents[document.unique_id]
+- buf = document.editor.get_buffer()
+- last_line = buf.get_iter_at_offset(buf.props.cursor_position)\
+- .get_line()
+-
+- document.editor.disconnect_by_func(self._buffer_status_changed)
+- document.editor.disconnect_by_func(self._buffer_renamed)
+- document.editor.get_buffer().disconnect_by_func(self._buffer_changed)
+- closing = document.editor.close()
+- if closing:
+- label = document.editor._label
+- view.remove(document.editor)
+- editor = self._editor_instance.create_doc(document.filename)
+- editor._label = label
+- editor.inputter = PidaMooInput(self, editor, document)
+- document.editor = editor
+- view.set_editor(editor)
+- gcall(editor.move_cursor, last_line, 0, False, True)
+- document.editor.connect("doc_status_changed", self._buffer_status_changed, view)
+- document.editor.connect("filename-changed", self._buffer_renamed, view)
+- document.editor.get_buffer().connect("changed", self._buffer_changed, view)
++ document.editor.reload()
+ document.editor.emit("doc_status_changed")
+
+ def _load_file(self, document):
+ try:
+ if document is None:
+- editor = self._editor_instance.new_doc()
++ editor = self._editor_instance.create_doc()
+ else:
+ editor = self._editor_instance.create_doc(document.filename)
+ document.editor = editor
++ self._editor_view = editor.get_view()
+ editor.inputter = PidaMooInput(self, editor, document)
+- editor.props.show_line_marks = True
++ self._editor_view.props.show_line_marks = True
+ editor.props.enable_bookmarks = False
+ #FIXME: this should be implemented but needs some code and a pref
+ #editor.props.enable_folding = True
+@@ -1379,7 +1320,7 @@
+
+ def _buffer_status_changed(self, buffer, view):
+ status = view.editor.get_status()
+- if moo.edit.EDIT_MODIFIED & status == moo.edit.EDIT_MODIFIED:
++ if moo.EDIT_STATUS_MODIFIED & status == moo.EDIT_STATUS_MODIFIED:
+ if not self._current.editor.can_redo():
+ self.get_action('redo').set_sensitive(False)
+ if not view._star:
+@@ -1392,11 +1333,11 @@
+ self.get_action('undo').set_sensitive(True)
+ self.get_action('save').set_sensitive(True)
+
+- if moo.edit.EDIT_CLEAN & status == moo.edit.EDIT_CLEAN:
++ if moo.EDIT_STATUS_CLEAN & status == moo.EDIT_STATUS_CLEAN:
+ status = 0
+- if moo.edit.EDIT_NEW & status == moo.edit.EDIT_NEW:
++ if moo.EDIT_STATUS_NEW & status == moo.EDIT_STATUS_NEW:
+ status = 0
+- if moo.edit.EDIT_CHANGED_ON_DISK & status == moo.edit.EDIT_CHANGED_ON_DISK:
++ if moo.EDIT_STATUS_MODIFIED_ON_DISK & status == moo.EDIT_STATUS_MODIFIED_ON_DISK:
+ if not view._exclam:
+ s = view.editor._label._markup
+ if view._star:
+@@ -1426,8 +1367,8 @@
+ view.editor._label.set_markup(ns)
+ view.editor._label._markup(ns)
+
+- def _buffer_renamed(self, buffer, new_name, view):
+- view.document.filename = new_name
++ def _buffer_renamed(self, buffer, view):
++ view.document.filename = buffer.get_filename()
+ ns = self._get_document_title(view.document)
+ view.editor._label.set_markup(ns)
+ view.editor._label._markup = ns
+@@ -1584,7 +1525,7 @@
+ buf.place_cursor(itr)
+ if scroll:
+ itr = buf.get_iter_at_offset(position)
+- self._current.editor.scroll_to_iter(itr, 0.05, use_align=True)
++ self._current.editor_view.scroll_to_iter(itr, 0.05, use_align=True)
+
+ def do_doc_destroy(self, *args):
+ if self._docwin:
+@@ -1592,18 +1533,18 @@
+ self._docwin = None
+
+ def on_doc_destroy(self, *args):
+- self._current.editor.props.buffer.disconnect(self._editor_mi)
++ self._current.editor_view.props.buffer.disconnect(self._editor_mi)
+
+
+ def show_documentation(self):
+- buf = self._current.editor.props.buffer
+- rec = self._current.editor.get_iter_location(
++ buf = self._current.editor.get_buffer()
++ rec = self._current.editor_view.get_iter_location(
+ buf.get_iter_at_offset(
+ buf.props.cursor_position))
+- pos = self._current.editor.buffer_to_window_coords(
++ pos = self._current.editor_view.buffer_to_window_coords(
+ gtk.TEXT_WINDOW_WIDGET,
+ rec.x, rec.y)
+- abspos = self._current.editor.window.get_origin()
++ abspos = self._current.editor_view.window.get_origin()
+ rpos = (pos[0]+abspos[0], pos[1]+abspos[1])
+ dm = self.boss.get_service('language').get_documentator(
+ self._current.document)
+@@ -1625,7 +1566,7 @@
+ quick=True)
+ return
+ pd.connect("destroy-event", self.on_doc_destroy)
+- self._current.editor.props.buffer.connect(
++ self._current.editor_view.props.buffer.connect(
+ 'cursor-moved', self.do_doc_destroy)
+ pd.move(rpos[0], rpos[1] + rec.height)
+ self._docwin = pd
+@@ -1654,5 +1595,10 @@
+
+
+
++# Required Service attribute for service loading
++Service = Mooedit
++
++
++
+ # vim:set shiftwidth=4 tabstop=4 expandtab textwidth=79:
+
+diff -ru pida.orig/pida/ui/paneds.py pida/pida/ui/paneds.py
+--- pida.orig/pida/ui/paneds.py 2012-03-10 02:57:31.000000000 -0800
++++ pida/pida/ui/paneds.py 2012-03-10 02:58:34.000000000 -0800
+@@ -9,7 +9,7 @@
+ # Don't import moo twice from different locations when the full editor is
+ # being used.
+ try:
+- import moo
++ import notmoo
+ from moo.utils import BigPaned, PaneLabel, PaneParams, Paned, Pane
+ from moo.utils import PANE_POS_BOTTOM, PANE_POS_TOP, PANE_POS_RIGHT, PANE_POS_LEFT
+ version = moo.version.split('.')
+@@ -21,8 +21,8 @@
+ use_old = True
+
+ except ImportError:
+- from pida.ui.moo_stub import BigPaned, PaneLabel, PaneParams, Paned, Pane
+- from pida.ui.moo_stub import PANE_POS_BOTTOM, PANE_POS_TOP, PANE_POS_RIGHT, PANE_POS_LEFT
++ from pida.ui.moo_stub import InternalBigPaned, InternalPaneLabel, InternalPaneParams, InternalPaned, InternalPane
++ from pida.ui.moo_stub import INTERNAL_PANE_POS_BOTTOM, INTERNAL_PANE_POS_TOP, INTERNAL_PANE_POS_RIGHT, INTERNAL_PANE_POS_LEFT
+ use_old = False
+
+ from pygtkhelpers.utils import gsignal
+@@ -34,17 +34,17 @@
+ PANE_PLUGIN = 'Plugin'
+
+ POS_MAP = {
+- PANE_TERMINAL: PANE_POS_BOTTOM,
+- PANE_BUFFER: PANE_POS_LEFT,
+- PANE_PLUGIN: PANE_POS_RIGHT,
++ PANE_TERMINAL: INTERNAL_PANE_POS_BOTTOM,
++ PANE_BUFFER: INTERNAL_PANE_POS_LEFT,
++ PANE_PLUGIN: INTERNAL_PANE_POS_RIGHT,
+ }
+
+-class PidaPaned(BigPaned):
++class PidaPaned(InternalBigPaned):
+
+ gsignal('pane-attachment-changed', gobject.TYPE_PYOBJECT, bool)
+
+ def __init__(self):
+- BigPaned.__init__(self)
++ InternalBigPaned.__init__(self)
+ self._fullscreen = False
+ self._fullscreen_vis = {}
+ self.set_property('enable-detaching', True)
+@@ -62,8 +62,8 @@
+
+ def get_all_pos(self, every=False):
+ if every:
+- return [PANE_POS_TOP, PANE_POS_BOTTOM, PANE_POS_LEFT, PANE_POS_RIGHT]
+- return [PANE_POS_TOP, PANE_POS_LEFT, PANE_POS_RIGHT]
++ return [INTERNAL_PANE_POS_TOP, INTERNAL_PANE_POS_BOTTOM, INTERNAL_PANE_POS_LEFT, INTERNAL_PANE_POS_RIGHT]
++ return [INTERNAL_PANE_POS_TOP, INTERNAL_PANE_POS_LEFT, INTERNAL_PANE_POS_RIGHT]
+
+ def get_all_paneds(self, every=False):
+ for pos in self.get_all_pos(every):
+@@ -100,7 +100,7 @@
+ self.add_child(view.get_toplevel())
+ else:
+ POS = POS_MAP[name]
+- lab = PaneLabel(view.icon_name, None, view.label_text)
++ lab = InternalPaneLabel(view.icon_name, None, view.label_text)
+ if use_old:
+ pane = self.insert_pane(view.get_toplevel(), lab, POS, POS)
+ else:
+@@ -127,7 +127,7 @@
+ self.show_all()
+
+ def __contains__(self, item):
+- if not isinstance(item, Pane):
++ if not isinstance(item, InternalPane):
+ item = item.pane
+ for paned in self.get_all_paneds(True):
+ for pane in paned.list_panes():
+@@ -146,7 +146,7 @@
+
+ def detach_view(self, view, size=(400,300)):
+ paned, pos = self.find_pane(view.get_toplevel())
+- dparam = PaneParams(keep_on_top=True, detached=True)
++ dparam = InternalPaneParams(keep_on_top=True, detached=True)
+ paned.set_params(dparam)
+ paned.detach()
+ self._center_on_parent(view, size)
+@@ -248,7 +248,7 @@
+ mbuttons = None
+ is_top = oparam.keep_on_top
+
+- nparam = PaneParams(keep_on_top=is_top,
++ nparam = InternalPaneParams(keep_on_top=is_top,
+ detached=kwargs.get('detached', oparam.detached),
+ window_position=kwargs.get('window_position', oparam.window_position),
+ maximized=kwargs.get('maximized', oparam.maximized))
+@@ -257,11 +257,11 @@
+ def get_focus_pane(self):
+ if self.get_toplevel().is_active():
+ last_pane = getattr(self, 'focus_child', None)
+- if not isinstance(last_pane, Paned):
++ if not isinstance(last_pane, InternalPaned):
+ return
+ while True:
+ child_pane = getattr(last_pane, 'focus_child', None)
+- if isinstance(child_pane, Paned):
++ if isinstance(child_pane, InternalPaned):
+ last_pane = child_pane
+ else:
+ return last_pane.get_open_pane()
diff --git a/internal_moo.patch b/internal_moo.patch
new file mode 100644
index 000000000000..2ebabb0d1cab
--- /dev/null
+++ b/internal_moo.patch
@@ -0,0 +1,4974 @@
+diff -ru pida.orig/contrib/moo/moobigpaned.c pida/contrib/moo/moobigpaned.c
+--- pida.orig/contrib/moo/moobigpaned.c 2011-04-24 12:08:25.000000000 -0400
++++ pida/contrib/moo/moobigpaned.c 2011-04-24 12:28:39.000000000 -0400
+@@ -38,19 +38,19 @@
+ int size;
+ int sticky;
+ char *active;
+-} MooPanedConfig;
++} MooInternalPanedConfig;
+
+ typedef struct {
+- MooPanedConfig paned[4];
++ MooInternalPanedConfig paned[4];
+ GHashTable *panes;
+-} MooBigPanedConfig;
++} MooInternalBigPanedConfig;
+
+-struct MooBigPanedPrivate {
+- MooPanePosition order[4]; /* inner is paned[order[3]] */
++struct MooInternalBigPanedPrivate {
++ MooInternalPanePosition order[4]; /* inner is paned[order[3]] */
+ GtkWidget *inner;
+ GtkWidget *outer;
+
+- MooBigPanedConfig *config;
++ MooInternalBigPanedConfig *config;
+ GHashTable *panes;
+
+ int drop_pos;
+@@ -79,41 +79,41 @@
+
+ static gboolean moo_big_paned_expose (GtkWidget *widget,
+ GdkEventExpose *event,
+- MooBigPaned *paned);
++ MooInternalBigPaned *paned);
+
+ static void child_set_pane_size (GtkWidget *child,
+ int size,
+- MooBigPaned *paned);
++ MooInternalBigPaned *paned);
+ static void sticky_pane_notify (GtkWidget *child,
+ GParamSpec *pspec,
+- MooBigPaned *paned);
++ MooInternalBigPaned *paned);
+ static void active_pane_notify (GtkWidget *child,
+ GParamSpec *pspec,
+- MooBigPaned *paned);
++ MooInternalBigPaned *paned);
+
+-static gboolean check_children_order (MooBigPaned *paned);
++static gboolean check_children_order (MooInternalBigPaned *paned);
+
+-static void handle_drag_start (MooPaned *child,
++static void handle_drag_start (MooInternalPaned *child,
+ GtkWidget *pane_widget,
+- MooBigPaned *paned);
+-static void handle_drag_motion (MooPaned *child,
++ MooInternalBigPaned *paned);
++static void handle_drag_motion (MooInternalPaned *child,
+ GtkWidget *pane_widget,
+- MooBigPaned *paned);
+-static void handle_drag_end (MooPaned *child,
++ MooInternalBigPaned *paned);
++static void handle_drag_end (MooInternalPaned *child,
+ GtkWidget *pane_widget,
+ gboolean drop,
+- MooBigPaned *paned);
++ MooInternalBigPaned *paned);
+
+-static void config_changed (MooBigPaned *paned);
++static void config_changed (MooInternalBigPaned *paned);
+
+-static MooBigPanedConfig *config_new (void);
+-static void config_free (MooBigPanedConfig *config);
+-static MooBigPanedConfig *config_parse (const char *string);
+-static char *config_serialize (MooBigPanedConfig *config);
++static MooInternalBigPanedConfig *config_new (void);
++static void config_free (MooInternalBigPanedConfig *config);
++static MooInternalBigPanedConfig *config_parse (const char *string);
++static char *config_serialize (MooInternalBigPanedConfig *config);
+
+
+-/* MOO_TYPE_BIG_PANED */
+-G_DEFINE_TYPE (MooBigPaned, moo_big_paned, GTK_TYPE_FRAME)
++/* MOO_TYPE_INTERNAL_BIG_PANED */
++G_DEFINE_TYPE (MooInternalBigPaned, moo_big_paned, GTK_TYPE_FRAME)
+
+ enum {
+ PROP_0,
+@@ -131,11 +131,11 @@
+ static guint signals[NUM_SIGNALS];
+
+ static void
+-moo_big_paned_class_init (MooBigPanedClass *klass)
++moo_big_paned_class_init (MooInternalBigPanedClass *klass)
+ {
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+- g_type_class_add_private (klass, sizeof (MooBigPanedPrivate));
++ g_type_class_add_private (klass, sizeof (MooInternalBigPanedPrivate));
+
+ gobject_class->finalize = moo_big_paned_finalize;
+ gobject_class->set_property = moo_big_paned_set_property;
+@@ -187,13 +187,13 @@
+ #define NTH_CHILD(paned,n) paned->paned[paned->priv->order[n]]
+
+ static void
+-moo_big_paned_init (MooBigPaned *paned)
++moo_big_paned_init (MooInternalBigPaned *paned)
+ {
+ int i;
+
+ paned->priv = G_TYPE_INSTANCE_GET_PRIVATE (paned,
+- MOO_TYPE_BIG_PANED,
+- MooBigPanedPrivate);
++ MOO_TYPE_INTERNAL_BIG_PANED,
++ MooInternalBigPanedPrivate);
+
+ paned->priv->panes = g_hash_table_new_full (g_str_hash, g_str_equal,
+ g_free, g_object_unref);
+@@ -207,8 +207,8 @@
+ GtkWidget *child;
+
+ paned->paned[i] = child =
+- g_object_new (MOO_TYPE_PANED,
+- "pane-position", (MooPanePosition) i,
++ g_object_new (MOO_TYPE_INTERNAL_PANED,
++ "pane-position", (MooInternalPanePosition) i,
+ NULL);
+
+ MOO_OBJECT_REF_SINK (child);
+@@ -234,10 +234,10 @@
+ paned);
+ }
+
+- paned->priv->order[0] = MOO_PANE_POS_LEFT;
+- paned->priv->order[1] = MOO_PANE_POS_RIGHT;
+- paned->priv->order[2] = MOO_PANE_POS_TOP;
+- paned->priv->order[3] = MOO_PANE_POS_BOTTOM;
++ paned->priv->order[0] = MOO_INTERNAL_PANE_POS_LEFT;
++ paned->priv->order[1] = MOO_INTERNAL_PANE_POS_RIGHT;
++ paned->priv->order[2] = MOO_INTERNAL_PANE_POS_TOP;
++ paned->priv->order[3] = MOO_INTERNAL_PANE_POS_BOTTOM;
+
+ paned->priv->inner = NTH_CHILD (paned, 3);
+ paned->priv->outer = NTH_CHILD (paned, 0);
+@@ -252,7 +252,7 @@
+
+
+ static gboolean
+-check_children_order (MooBigPaned *paned)
++check_children_order (MooInternalBigPaned *paned)
+ {
+ int i;
+
+@@ -268,10 +268,10 @@
+
+
+ void
+-moo_big_paned_set_pane_order (MooBigPaned *paned,
++moo_big_paned_set_pane_order (MooInternalBigPaned *paned,
+ int *order)
+ {
+- MooPanePosition new_order[4] = {8, 8, 8, 8};
++ MooInternalPanePosition new_order[4] = {8, 8, 8, 8};
+ int i;
+ GtkWidget *child;
+
+@@ -332,7 +332,7 @@
+ static void
+ moo_big_paned_finalize (GObject *object)
+ {
+- MooBigPaned *paned = MOO_BIG_PANED (object);
++ MooInternalBigPaned *paned = MOO_INTERNAL_BIG_PANED (object);
+ int i;
+
+ g_hash_table_destroy (paned->priv->panes);
+@@ -355,12 +355,12 @@
+ GtkWidget*
+ moo_big_paned_new (void)
+ {
+- return g_object_new (MOO_TYPE_BIG_PANED, NULL);
++ return g_object_new (MOO_TYPE_INTERNAL_BIG_PANED, NULL);
+ }
+
+
+ static void
+-config_changed (MooBigPaned *paned)
++config_changed (MooInternalBigPaned *paned)
+ {
+ g_signal_emit (paned, signals[CONFIG_CHANGED], 0);
+ }
+@@ -368,9 +368,9 @@
+ static void
+ child_set_pane_size (GtkWidget *child,
+ int size,
+- MooBigPaned *paned)
++ MooInternalBigPaned *paned)
+ {
+- MooPanePosition pos;
++ MooInternalPanePosition pos;
+
+ g_object_get (child, "pane-position", &pos, NULL);
+ g_return_if_fail (paned->paned[pos] == child);
+@@ -382,9 +382,9 @@
+ static void
+ sticky_pane_notify (GtkWidget *child,
+ G_GNUC_UNUSED GParamSpec *pspec,
+- MooBigPaned *paned)
++ MooInternalBigPaned *paned)
+ {
+- MooPanePosition pos;
++ MooInternalPanePosition pos;
+ gboolean sticky;
+
+ g_object_get (child, "pane-position", &pos,
+@@ -401,12 +401,12 @@
+ static void
+ active_pane_notify (GtkWidget *child,
+ G_GNUC_UNUSED GParamSpec *pspec,
+- MooBigPaned *paned)
++ MooInternalBigPaned *paned)
+ {
+- MooPanePosition pos;
+- MooPane *pane = NULL;
++ MooInternalPanePosition pos;
++ MooInternalPane *pane = NULL;
+ const char *id = NULL;
+- MooPanedConfig *pc;
++ MooInternalPanedConfig *pc;
+
+ g_object_get (child, "pane-position", &pos,
+ "active-pane", &pane, NULL);
+@@ -429,12 +429,12 @@
+ }
+
+ static void
+-pane_params_changed (MooPane *pane,
++pane_params_changed (MooInternalPane *pane,
+ G_GNUC_UNUSED GParamSpec *pspec,
+- MooBigPaned *paned)
++ MooInternalBigPaned *paned)
+ {
+ const char *id;
+- MooPaneParams *params;
++ MooInternalPaneParams *params;
+
+ id = moo_pane_get_id (pane);
+ g_return_if_fail (id != NULL);
+@@ -446,13 +446,13 @@
+ }
+
+
+-static MooPaneParams *
+-get_pane_config (MooBigPaned *paned,
++static MooInternalPaneParams *
++get_pane_config (MooInternalBigPaned *paned,
+ const char *id,
+- MooPanePosition *position,
++ MooInternalPanePosition *position,
+ int *index)
+ {
+- MooPaneParams *params;
++ MooInternalPaneParams *params;
+ int pos;
+ gboolean found = FALSE;
+
+@@ -493,8 +493,8 @@
+ }
+
+ static void
+-add_pane_id_to_list (MooBigPaned *paned,
+- MooPanedConfig *pc,
++add_pane_id_to_list (MooInternalBigPaned *paned,
++ MooInternalPanedConfig *pc,
+ const char *id,
+ int index)
+ {
+@@ -518,13 +518,13 @@
+ }
+
+ static void
+-add_pane_config (MooBigPaned *paned,
++add_pane_config (MooInternalBigPaned *paned,
+ const char *id,
+- MooPane *pane,
+- MooPanePosition pos,
++ MooInternalPane *pane,
++ MooInternalPanePosition pos,
+ int index)
+ {
+- MooPaneParams *params;
++ MooInternalPaneParams *params;
+
+ g_return_if_fail (index >= 0);
+ g_return_if_fail (!g_hash_table_lookup (paned->priv->config->panes, id));
+@@ -538,15 +538,15 @@
+ }
+
+ static void
+-move_pane_config (MooBigPaned *paned,
++move_pane_config (MooInternalBigPaned *paned,
+ const char *id,
+- MooPanePosition old_pos,
+- MooPanePosition new_pos,
++ MooInternalPanePosition old_pos,
++ MooInternalPanePosition new_pos,
+ int new_index)
+ {
+ GSList *old_link;
+- MooBigPanedConfig *config = paned->priv->config;
+- MooPanedConfig *old_pc, *new_pc;
++ MooInternalBigPanedConfig *config = paned->priv->config;
++ MooInternalPanedConfig *old_pc, *new_pc;
+
+ g_return_if_fail (new_index >= 0);
+ g_return_if_fail (g_hash_table_lookup (config->panes, id) != NULL);
+@@ -565,10 +565,10 @@
+
+
+ void
+-moo_big_paned_set_config (MooBigPaned *paned,
++moo_big_paned_set_config (MooInternalBigPaned *paned,
+ const char *string)
+ {
+- MooBigPanedConfig *config;
++ MooInternalBigPanedConfig *config;
+ int pos;
+
+ g_return_if_fail (MOO_IS_BIG_PANED (paned));
+@@ -602,32 +602,32 @@
+ for (pos = 0; pos < 4; ++pos)
+ {
+ if (config->paned[pos].size > 0)
+- moo_paned_set_pane_size (MOO_PANED (paned->paned[pos]),
++ moo_paned_set_pane_size (MOO_INTERNAL_PANED (paned->paned[pos]),
+ config->paned[pos].size);
+ if (config->paned[pos].sticky >= 0)
+- moo_paned_set_sticky_pane (MOO_PANED (paned->paned[pos]),
++ moo_paned_set_sticky_pane (MOO_INTERNAL_PANED (paned->paned[pos]),
+ config->paned[pos].sticky);
+ }
+ }
+
+ char *
+-moo_big_paned_get_config (MooBigPaned *paned)
++moo_big_paned_get_config (MooInternalBigPaned *paned)
+ {
+ g_return_val_if_fail (MOO_IS_BIG_PANED (paned), NULL);
+ return config_serialize (paned->priv->config);
+ }
+
+
+-MooPane *
+-moo_big_paned_insert_pane (MooBigPaned *paned,
++MooInternalPane *
++moo_big_paned_insert_pane (MooInternalBigPaned *paned,
+ GtkWidget *pane_widget,
+ const char *id,
+- MooPaneLabel *pane_label,
+- MooPanePosition position,
++ MooInternalPaneLabel *pane_label,
++ MooInternalPanePosition position,
+ int index)
+ {
+- MooPane *pane;
+- MooPaneParams *params = NULL;
++ MooInternalPane *pane;
++ MooInternalPaneParams *params = NULL;
+
+ g_return_val_if_fail (MOO_IS_BIG_PANED (paned), NULL);
+ g_return_val_if_fail (GTK_IS_WIDGET (pane_widget), NULL);
+@@ -644,9 +644,9 @@
+ params = get_pane_config (paned, id, &position, &index);
+
+ if (index < 0)
+- index = moo_paned_n_panes (MOO_PANED (paned->paned[position]));
++ index = moo_paned_n_panes (MOO_INTERNAL_PANED (paned->paned[position]));
+
+- pane = moo_paned_insert_pane (MOO_PANED (paned->paned[position]),
++ pane = moo_paned_insert_pane (MOO_INTERNAL_PANED (paned->paned[position]),
+ pane_widget, pane_label, index);
+
+ if (pane && id)
+@@ -676,14 +676,14 @@
+
+
+ void
+-moo_big_paned_reorder_pane (MooBigPaned *paned,
++moo_big_paned_reorder_pane (MooInternalBigPaned *paned,
+ GtkWidget *pane_widget,
+- MooPanePosition new_position,
++ MooInternalPanePosition new_position,
+ int new_index)
+ {
+- MooPane *pane;
+- MooPaned *child;
+- MooPanePosition old_position;
++ MooInternalPane *pane;
++ MooInternalPaned *child;
++ MooInternalPanePosition old_position;
+ int old_index;
+ const char *id;
+
+@@ -703,7 +703,7 @@
+ if (old_position == new_position)
+ new_index = (int) moo_paned_n_panes (child) - 1;
+ else
+- new_index = moo_paned_n_panes (MOO_PANED (paned->paned[new_position]));
++ new_index = moo_paned_n_panes (MOO_INTERNAL_PANED (paned->paned[new_position]));
+ }
+
+ if (old_position == new_position && old_index == new_index)
+@@ -720,7 +720,7 @@
+ g_object_ref (pane);
+
+ moo_paned_remove_pane (child, pane_widget);
+- _moo_paned_insert_pane (MOO_PANED (paned->paned[new_position]), pane, new_index);
++ _moo_paned_insert_pane (MOO_INTERNAL_PANED (paned->paned[new_position]), pane, new_index);
+ moo_pane_open (pane);
+
+ g_object_unref (pane);
+@@ -732,7 +732,7 @@
+
+
+ void
+-moo_big_paned_add_child (MooBigPaned *paned,
++moo_big_paned_add_child (MooInternalBigPaned *paned,
+ GtkWidget *child)
+ {
+ g_return_if_fail (MOO_IS_BIG_PANED (paned));
+@@ -741,7 +741,7 @@
+
+
+ void
+-moo_big_paned_remove_child (MooBigPaned *paned)
++moo_big_paned_remove_child (MooInternalBigPaned *paned)
+ {
+ g_return_if_fail (MOO_IS_BIG_PANED (paned));
+ gtk_container_remove (GTK_CONTAINER (paned->priv->inner),
+@@ -750,7 +750,7 @@
+
+
+ GtkWidget *
+-moo_big_paned_get_child (MooBigPaned *paned)
++moo_big_paned_get_child (MooInternalBigPaned *paned)
+ {
+ g_return_val_if_fail (MOO_IS_BIG_PANED (paned), NULL);
+ return GTK_BIN(paned->priv->inner)->child;
+@@ -758,11 +758,11 @@
+
+
+ gboolean
+-moo_big_paned_remove_pane (MooBigPaned *paned,
++moo_big_paned_remove_pane (MooInternalBigPaned *paned,
+ GtkWidget *widget)
+ {
+- MooPaned *child;
+- MooPane *pane;
++ MooInternalPaned *child;
++ MooInternalPane *pane;
+ const char *id;
+
+ g_return_val_if_fail (MOO_IS_BIG_PANED (paned), FALSE);
+@@ -780,8 +780,8 @@
+ }
+
+
+-MooPane *
+-moo_big_paned_lookup_pane (MooBigPaned *paned,
++MooInternalPane *
++moo_big_paned_lookup_pane (MooInternalBigPaned *paned,
+ const char *pane_id)
+ {
+ g_return_val_if_fail (MOO_IS_BIG_PANED (paned), NULL);
+@@ -792,11 +792,11 @@
+
+ #define PROXY_FUNC(name) \
+ void \
+-moo_big_paned_##name (MooBigPaned *paned, \
++moo_big_paned_##name (MooInternalBigPaned *paned, \
+ GtkWidget *widget) \
+ { \
+- MooPane *pane; \
+- MooPaned *child = NULL; \
++ MooInternalPane *pane; \
++ MooInternalPaned *child = NULL; \
+ \
+ g_return_if_fail (MOO_IS_BIG_PANED (paned)); \
+ g_return_if_fail (GTK_IS_WIDGET (widget)); \
+@@ -815,10 +815,10 @@
+ #undef PROXY_FUNC
+
+ void
+-moo_big_paned_hide_pane (MooBigPaned *paned,
++moo_big_paned_hide_pane (MooInternalBigPaned *paned,
+ GtkWidget *widget)
+ {
+- MooPaned *child = NULL;
++ MooInternalPaned *child = NULL;
+
+ g_return_if_fail (MOO_IS_BIG_PANED (paned));
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+@@ -830,23 +830,23 @@
+ }
+
+
+-MooPaned *
+-moo_big_paned_get_paned (MooBigPaned *paned,
+- MooPanePosition position)
++MooInternalPaned *
++moo_big_paned_get_paned (MooInternalBigPaned *paned,
++ MooInternalPanePosition position)
+ {
+ g_return_val_if_fail (MOO_IS_BIG_PANED (paned), NULL);
+ g_return_val_if_fail (position < 4, NULL);
+- return MOO_PANED (paned->paned[position]);
++ return MOO_INTERNAL_PANED (paned->paned[position]);
+ }
+
+
+-MooPane *
+-moo_big_paned_find_pane (MooBigPaned *paned,
++MooInternalPane *
++moo_big_paned_find_pane (MooInternalBigPaned *paned,
+ GtkWidget *widget,
+- MooPaned **child_paned)
++ MooInternalPaned **child_paned)
+ {
+ int i;
+- MooPane *pane;
++ MooInternalPane *pane;
+
+ g_return_val_if_fail (MOO_IS_BIG_PANED (paned), NULL);
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
+@@ -856,12 +856,12 @@
+
+ for (i = 0; i < 4; ++i)
+ {
+- pane = moo_paned_get_pane (MOO_PANED (paned->paned[i]), widget);
++ pane = moo_paned_get_pane (MOO_INTERNAL_PANED (paned->paned[i]), widget);
+
+ if (pane)
+ {
+ if (child_paned)
+- *child_paned = MOO_PANED (paned->paned[i]);
++ *child_paned = MOO_INTERNAL_PANED (paned->paned[i]);
+ return pane;
+ }
+ }
+@@ -876,7 +876,7 @@
+ const GValue *value,
+ GParamSpec *pspec)
+ {
+- MooBigPaned *paned = MOO_BIG_PANED (object);
++ MooInternalBigPaned *paned = MOO_INTERNAL_BIG_PANED (object);
+ int i;
+
+ switch (prop_id)
+@@ -921,7 +921,7 @@
+ GValue *value,
+ GParamSpec *pspec)
+ {
+- MooBigPaned *paned = MOO_BIG_PANED (object);
++ MooInternalBigPaned *paned = MOO_INTERNAL_BIG_PANED (object);
+ GdkCursorType cursor_type;
+
+ switch (prop_id)
+@@ -943,13 +943,13 @@
+
+
+ GtkWidget *
+-moo_big_paned_get_pane (MooBigPaned *paned,
+- MooPanePosition position,
++moo_big_paned_get_pane (MooInternalBigPaned *paned,
++ MooInternalPanePosition position,
+ int index_)
+ {
+ g_return_val_if_fail (MOO_IS_BIG_PANED (paned), NULL);
+ g_return_val_if_fail (position < 4, NULL);
+- return moo_pane_get_child (moo_paned_get_nth_pane (MOO_PANED (paned->paned[position]), index_));
++ return moo_pane_get_child (moo_paned_get_nth_pane (MOO_INTERNAL_PANED (paned->paned[position]), index_));
+ }
+
+
+@@ -957,14 +957,14 @@
+ /* rearranging panes
+ */
+
+-static void create_drop_outline (MooBigPaned *paned);
+-static void get_drop_area (MooBigPaned *paned,
+- MooPaned *active_child,
+- MooPanePosition position,
++static void create_drop_outline (MooInternalBigPaned *paned);
++static void get_drop_area (MooInternalBigPaned *paned,
++ MooInternalPaned *active_child,
++ MooInternalPanePosition position,
+ int index,
+ GdkRectangle *rect,
+ GdkRectangle *button_rect);
+-// static void invalidate_drop_outline (MooBigPaned *paned);
++// static void invalidate_drop_outline (MooInternalBigPaned *paned);
+
+
+ static GdkRegion *
+@@ -1006,7 +1006,7 @@
+ #define BOTTOM(rect) ((rect).y + (rect).height - 1)
+
+ static void
+-get_drop_zones (MooBigPaned *paned)
++get_drop_zones (MooInternalBigPaned *paned)
+ {
+ int pos;
+ GdkRectangle parent;
+@@ -1021,7 +1021,7 @@
+
+ for (pos = 0; pos < 4; ++pos)
+ {
+- bbox_size[pos] = moo_paned_get_button_box_size (MOO_PANED (paned->paned[pos]));
++ bbox_size[pos] = moo_paned_get_button_box_size (MOO_INTERNAL_PANED (paned->paned[pos]));
+ if (bbox_size[pos] <= 0)
+ bbox_size[pos] = 30;
+ paned->priv->dz[pos].bbox_size = bbox_size[pos];
+@@ -1030,20 +1030,20 @@
+ parent = paned->priv->outer->allocation;
+
+ child_rect = parent;
+- child_rect.x += bbox_size[MOO_PANE_POS_LEFT];
+- child_rect.width -= bbox_size[MOO_PANE_POS_LEFT] +
+- bbox_size[MOO_PANE_POS_RIGHT];
+- child_rect.y += bbox_size[MOO_PANE_POS_TOP];
+- child_rect.height -= bbox_size[MOO_PANE_POS_TOP] +
+- bbox_size[MOO_PANE_POS_BOTTOM];
++ child_rect.x += bbox_size[MOO_INTERNAL_PANE_POS_LEFT];
++ child_rect.width -= bbox_size[MOO_INTERNAL_PANE_POS_LEFT] +
++ bbox_size[MOO_INTERNAL_PANE_POS_RIGHT];
++ child_rect.y += bbox_size[MOO_INTERNAL_PANE_POS_TOP];
++ child_rect.height -= bbox_size[MOO_INTERNAL_PANE_POS_TOP] +
++ bbox_size[MOO_INTERNAL_PANE_POS_BOTTOM];
+
+ button_rect = parent;
+- button_rect.x += 2*bbox_size[MOO_PANE_POS_LEFT];
+- button_rect.width -= 2*bbox_size[MOO_PANE_POS_LEFT] +
+- 2*bbox_size[MOO_PANE_POS_RIGHT];
+- button_rect.y += 2*bbox_size[MOO_PANE_POS_TOP];
+- button_rect.height -= 2*bbox_size[MOO_PANE_POS_TOP] +
+- 2*bbox_size[MOO_PANE_POS_BOTTOM];
++ button_rect.x += 2*bbox_size[MOO_INTERNAL_PANE_POS_LEFT];
++ button_rect.width -= 2*bbox_size[MOO_INTERNAL_PANE_POS_LEFT] +
++ 2*bbox_size[MOO_INTERNAL_PANE_POS_RIGHT];
++ button_rect.y += 2*bbox_size[MOO_INTERNAL_PANE_POS_TOP];
++ button_rect.height -= 2*bbox_size[MOO_INTERNAL_PANE_POS_TOP] +
++ 2*bbox_size[MOO_INTERNAL_PANE_POS_BOTTOM];
+
+ drop_rect = button_rect;
+ drop_rect.x += button_rect.width / 3;
+@@ -1051,53 +1051,53 @@
+ drop_rect.width -= 2 * button_rect.width / 3;
+ drop_rect.height -= 2 * button_rect.height / 3;
+
+- paned->priv->dz[MOO_PANE_POS_TOP].bbox_region =
++ paned->priv->dz[MOO_INTERNAL_PANE_POS_TOP].bbox_region =
+ region_6 (LEFT (child_rect), TOP (parent),
+ RIGHT (child_rect), TOP (parent),
+ RIGHT (child_rect), TOP (child_rect),
+ RIGHT (button_rect), TOP (button_rect),
+ LEFT (button_rect), TOP (button_rect),
+ LEFT (child_rect), TOP (child_rect));
+- paned->priv->dz[MOO_PANE_POS_TOP].def_region =
++ paned->priv->dz[MOO_INTERNAL_PANE_POS_TOP].def_region =
+ region_4 (LEFT (button_rect), TOP (button_rect),
+ RIGHT (button_rect), TOP (button_rect),
+ RIGHT (drop_rect), TOP (drop_rect),
+ LEFT (drop_rect), TOP (drop_rect));
+
+- paned->priv->dz[MOO_PANE_POS_LEFT].bbox_region =
++ paned->priv->dz[MOO_INTERNAL_PANE_POS_LEFT].bbox_region =
+ region_6 (LEFT (parent), TOP (child_rect),
+ LEFT (child_rect), TOP (child_rect),
+ LEFT (button_rect), TOP (button_rect),
+ LEFT (button_rect), BOTTOM (button_rect),
+ LEFT (child_rect), BOTTOM (child_rect),
+ LEFT (parent), BOTTOM (child_rect));
+- paned->priv->dz[MOO_PANE_POS_LEFT].def_region =
++ paned->priv->dz[MOO_INTERNAL_PANE_POS_LEFT].def_region =
+ region_4 (LEFT (button_rect), TOP (button_rect),
+ LEFT (drop_rect), TOP (drop_rect),
+ LEFT (drop_rect), BOTTOM (drop_rect),
+ LEFT (button_rect), BOTTOM (button_rect));
+
+- paned->priv->dz[MOO_PANE_POS_BOTTOM].bbox_region =
++ paned->priv->dz[MOO_INTERNAL_PANE_POS_BOTTOM].bbox_region =
+ region_6 (LEFT (child_rect), BOTTOM (parent),
+ LEFT (child_rect), BOTTOM (child_rect),
+ LEFT (button_rect), BOTTOM (button_rect),
+ RIGHT (button_rect), BOTTOM (button_rect),
+ RIGHT (child_rect), BOTTOM (child_rect),
+ RIGHT (child_rect), BOTTOM (parent));
+- paned->priv->dz[MOO_PANE_POS_BOTTOM].def_region =
++ paned->priv->dz[MOO_INTERNAL_PANE_POS_BOTTOM].def_region =
+ region_4 (LEFT (button_rect), BOTTOM (button_rect),
+ LEFT (drop_rect), BOTTOM (drop_rect),
+ RIGHT (drop_rect), BOTTOM (drop_rect),
+ RIGHT (button_rect), BOTTOM (button_rect));
+
+- paned->priv->dz[MOO_PANE_POS_RIGHT].bbox_region =
++ paned->priv->dz[MOO_INTERNAL_PANE_POS_RIGHT].bbox_region =
+ region_6 (RIGHT (parent), TOP (child_rect),
+ RIGHT (child_rect), TOP (child_rect),
+ RIGHT (button_rect), TOP (button_rect),
+ RIGHT (button_rect), BOTTOM (button_rect),
+ RIGHT (child_rect), BOTTOM (child_rect),
+ RIGHT (parent), BOTTOM (child_rect));
+- paned->priv->dz[MOO_PANE_POS_RIGHT].def_region =
++ paned->priv->dz[MOO_INTERNAL_PANE_POS_RIGHT].def_region =
+ region_4 (RIGHT (button_rect), TOP (button_rect),
+ RIGHT (drop_rect), TOP (drop_rect),
+ RIGHT (drop_rect), BOTTOM (drop_rect),
+@@ -1114,9 +1114,9 @@
+
+
+ static void
+-handle_drag_start (G_GNUC_UNUSED MooPaned *child,
++handle_drag_start (G_GNUC_UNUSED MooInternalPaned *child,
+ G_GNUC_UNUSED GtkWidget *pane_widget,
+- MooBigPaned *paned)
++ MooInternalBigPaned *paned)
+ {
+ g_return_if_fail (GTK_WIDGET_REALIZED (paned->priv->outer));
+
+@@ -1129,16 +1129,16 @@
+
+
+ static gboolean
+-get_new_button_index (MooBigPaned *paned,
+- MooPaned *active_child,
++get_new_button_index (MooInternalBigPaned *paned,
++ MooInternalPaned *active_child,
+ int x,
+ int y)
+ {
+ int new_button;
+- MooPaned *child;
++ MooInternalPaned *child;
+
+ g_assert (paned->priv->drop_pos >= 0);
+- child = MOO_PANED (paned->paned[paned->priv->drop_pos]);
++ child = MOO_INTERNAL_PANED (paned->paned[paned->priv->drop_pos]);
+
+ new_button = _moo_paned_get_button (child, x, y,
+ paned->priv->outer->window);
+@@ -1162,13 +1162,13 @@
+ }
+
+ static void
+-get_default_button_index (MooBigPaned *paned,
+- MooPaned *active_child)
++get_default_button_index (MooInternalBigPaned *paned,
++ MooInternalPaned *active_child)
+ {
+- MooPaned *child;
++ MooInternalPaned *child;
+
+ g_assert (paned->priv->drop_pos >= 0);
+- child = MOO_PANED (paned->paned[paned->priv->drop_pos]);
++ child = MOO_INTERNAL_PANED (paned->paned[paned->priv->drop_pos]);
+
+ if (child == active_child)
+ paned->priv->drop_button_index =
+@@ -1178,8 +1178,8 @@
+ }
+
+ static gboolean
+-get_new_drop_position (MooBigPaned *paned,
+- MooPaned *active_child,
++get_new_drop_position (MooInternalBigPaned *paned,
++ MooInternalPaned *active_child,
+ int x,
+ int y)
+ {
+@@ -1228,9 +1228,9 @@
+ }
+
+ static void
+-handle_drag_motion (MooPaned *child,
++handle_drag_motion (MooInternalPaned *child,
+ G_GNUC_UNUSED GtkWidget *pane_widget,
+- MooBigPaned *paned)
++ MooInternalBigPaned *paned)
+ {
+ int x, y;
+
+@@ -1260,7 +1260,7 @@
+
+
+ static void
+-cleanup_drag (MooBigPaned *paned)
++cleanup_drag (MooInternalBigPaned *paned)
+ {
+ int pos;
+
+@@ -1289,13 +1289,13 @@
+ }
+
+ static void
+-handle_drag_end (MooPaned *child,
++handle_drag_end (MooInternalPaned *child,
+ GtkWidget *pane_widget,
+ gboolean drop,
+- MooBigPaned *paned)
++ MooInternalBigPaned *paned)
+ {
+ int x, y;
+- MooPanePosition new_pos;
++ MooInternalPanePosition new_pos;
+ int new_index;
+
+ g_return_if_fail (GTK_WIDGET_REALIZED (paned->priv->outer));
+@@ -1324,15 +1324,15 @@
+
+
+ static void
+-get_drop_area (MooBigPaned *paned,
+- MooPaned *active_child,
+- MooPanePosition position,
++get_drop_area (MooInternalBigPaned *paned,
++ MooInternalPaned *active_child,
++ MooInternalPanePosition position,
+ int index,
+ GdkRectangle *rect,
+ GdkRectangle *button_rect)
+ {
+ int width, height, size = 0;
+- MooPanePosition active_position;
++ MooInternalPanePosition active_position;
+
+ width = paned->priv->outer->allocation.width;
+ height = paned->priv->outer->allocation.height;
+@@ -1349,12 +1349,12 @@
+ {
+ switch (position)
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ size = width / 3;
+ break;
+- case MOO_PANE_POS_TOP:
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ size = height / 3;
+ break;
+ }
+@@ -1362,14 +1362,14 @@
+
+ switch (position)
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ rect->y = paned->priv->outer->allocation.y;
+ rect->width = size;
+ rect->height = height;
+ break;
+- case MOO_PANE_POS_TOP:
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ rect->x = paned->priv->outer->allocation.x;
+ rect->width = width;
+ rect->height = size;
+@@ -1378,21 +1378,21 @@
+
+ switch (position)
+ {
+- case MOO_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
+ rect->x = paned->priv->outer->allocation.x;
+ break;
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ rect->x = paned->priv->outer->allocation.x + width - size;
+ break;
+- case MOO_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_TOP:
+ rect->y = paned->priv->outer->allocation.y;
+ break;
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ rect->y = paned->priv->outer->allocation.y + height - size;
+ break;
+ }
+
+- _moo_paned_get_button_position (MOO_PANED (paned->paned[position]),
++ _moo_paned_get_button_position (MOO_INTERNAL_PANED (paned->paned[position]),
+ index, button_rect,
+ paned->priv->outer->window);
+ }
+@@ -1403,14 +1403,14 @@
+ x >= (rect)->x && y >= (rect)->y)
+
+ // static int
+-// get_drop_position (MooBigPaned *paned,
+-// MooPaned *child,
++// get_drop_position (MooInternalBigPaned *paned,
++// MooInternalPaned *child,
+ // int x,
+ // int y,
+ // int *button_index)
+ // {
+ // int width, height, i;
+-// MooPanePosition position;
++// MooInternalPanePosition position;
+ // GdkRectangle rect, button_rect;
+ //
+ // *button_index = -1;
+@@ -1449,7 +1449,7 @@
+
+
+ // static void
+-// invalidate_drop_outline (MooBigPaned *paned)
++// invalidate_drop_outline (MooInternalBigPaned *paned)
+ // {
+ // GdkRectangle line;
+ // GdkRegion *outline;
+@@ -1488,7 +1488,7 @@
+ static gboolean
+ moo_big_paned_expose (GtkWidget *widget,
+ GdkEventExpose *event,
+- MooBigPaned *paned)
++ MooInternalBigPaned *paned)
+ {
+ GTK_WIDGET_CLASS(G_OBJECT_GET_CLASS (widget))->expose_event (widget, event);
+
+@@ -1545,7 +1545,7 @@
+ }
+
+ static void
+-create_drop_outline (MooBigPaned *paned)
++create_drop_outline (MooInternalBigPaned *paned)
+ {
+ static GdkWindowAttr attributes;
+ int attributes_mask;
+@@ -1590,13 +1590,13 @@
+ #define CONFIG_STRING_MAGIC "mbpconfig-1.0 "
+ #define CONFIG_STRING_MAGIC_LEN strlen (CONFIG_STRING_MAGIC)
+
+-static MooBigPanedConfig *
++static MooInternalBigPanedConfig *
+ config_new (void)
+ {
+- MooBigPanedConfig *config;
++ MooInternalBigPanedConfig *config;
+ int pos;
+
+- config = g_new0 (MooBigPanedConfig, 1);
++ config = g_new0 (MooInternalBigPanedConfig, 1);
+
+ for (pos = 0; pos < 4; pos++)
+ {
+@@ -1613,7 +1613,7 @@
+ }
+
+ static void
+-config_free (MooBigPanedConfig *config)
++config_free (MooInternalBigPanedConfig *config)
+ {
+ if (config)
+ {
+@@ -1663,7 +1663,7 @@
+
+ static gboolean
+ parse_paned_config (const char *string,
+- MooPanedConfig *config)
++ MooInternalPanedConfig *config)
+ {
+ char **tokens, **p;
+
+@@ -1708,7 +1708,7 @@
+ }
+
+ static void
+-paned_config_serialize (MooPanedConfig *config,
++paned_config_serialize (MooInternalPanedConfig *config,
+ GString *string)
+ {
+ GSList *l;
+@@ -1730,7 +1730,7 @@
+ {
+ char **tokens = NULL;
+ const char *colon;
+- MooPaneParams params = {{-1, -1, -1, -1}, 0, 0, 0};
++ MooInternalPaneParams params = {{-1, -1, -1, -1}, 0, 0, 0};
+ gboolean value[3];
+
+ if (!(colon = strchr (string, ':')) || colon == string)
+@@ -1787,7 +1787,7 @@
+
+ static void
+ pane_config_serialize (const char *id,
+- MooPaneParams *params,
++ MooInternalPaneParams *params,
+ GString *string)
+ {
+ g_string_append_printf (string, ";%s:%d,%d,%d,%d,%s,%s,%s",
+@@ -1802,10 +1802,10 @@
+ }
+
+
+-static MooBigPanedConfig *
++static MooInternalBigPanedConfig *
+ config_parse (const char *string)
+ {
+- MooBigPanedConfig *config = NULL;
++ MooInternalBigPanedConfig *config = NULL;
+ char **tokens = NULL;
+ char **p;
+ int pos;
+@@ -1846,7 +1846,7 @@
+ }
+
+ static char *
+-config_serialize (MooBigPanedConfig *config)
++config_serialize (MooInternalBigPanedConfig *config)
+ {
+ GString *string;
+ int pos;
+diff -ru pida.orig/contrib/moo/moobigpaned.h pida/contrib/moo/moobigpaned.h
+--- pida.orig/contrib/moo/moobigpaned.h 2011-04-24 12:08:25.000000000 -0400
++++ pida/contrib/moo/moobigpaned.h 2011-04-24 12:28:36.000000000 -0400
+@@ -13,8 +13,8 @@
+ * License along with medit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+-#ifndef MOO_BIG_PANED_H
+-#define MOO_BIG_PANED_H
++#ifndef MOO_INTERNAL_BIG_PANED_H
++#define MOO_INTERNAL_BIG_PANED_H
+
+ #include <gtk/gtkframe.h>
+ #include "moopaned.h"
+@@ -22,26 +22,26 @@
+ G_BEGIN_DECLS
+
+
+-#define MOO_TYPE_BIG_PANED (moo_big_paned_get_type ())
+-#define MOO_BIG_PANED(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), MOO_TYPE_BIG_PANED, MooBigPaned))
+-#define MOO_BIG_PANED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MOO_TYPE_BIG_PANED, MooBigPanedClass))
+-#define MOO_IS_BIG_PANED(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), MOO_TYPE_BIG_PANED))
+-#define MOO_IS_BIG_PANED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MOO_TYPE_BIG_PANED))
+-#define MOO_BIG_PANED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MOO_TYPE_BIG_PANED, MooBigPanedClass))
++#define MOO_TYPE_INTERNAL_BIG_PANED (moo_big_paned_get_type ())
++#define MOO_INTERNAL_BIG_PANED(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), MOO_TYPE_INTERNAL_BIG_PANED, MooInternalBigPaned))
++#define MOO_INTERNAL_BIG_PANED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MOO_TYPE_INTERNAL_BIG_PANED, MooInternalBigPanedClass))
++#define MOO_IS_BIG_PANED(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), MOO_TYPE_INTERNAL_BIG_PANED))
++#define MOO_IS_BIG_PANED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MOO_TYPE_INTERNAL_BIG_PANED))
++#define MOO_INTERNAL_BIG_PANED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MOO_TYPE_INTERNAL_BIG_PANED, MooInternalBigPanedClass))
+
+
+-typedef struct MooBigPaned MooBigPaned;
+-typedef struct MooBigPanedPrivate MooBigPanedPrivate;
+-typedef struct MooBigPanedClass MooBigPanedClass;
++typedef struct MooInternalBigPaned MooInternalBigPaned;
++typedef struct MooInternalBigPanedPrivate MooInternalBigPanedPrivate;
++typedef struct MooInternalBigPanedClass MooInternalBigPanedClass;
+
+-struct MooBigPaned
++struct MooInternalBigPaned
+ {
+ GtkFrame base;
+- MooBigPanedPrivate *priv;
++ MooInternalBigPanedPrivate *priv;
+ GtkWidget *paned[4]; /* indexed by PanePos */
+ };
+
+-struct MooBigPanedClass
++struct MooInternalBigPanedClass
+ {
+ GtkFrameClass base_class;
+ };
+@@ -51,55 +51,55 @@
+
+ GtkWidget *moo_big_paned_new (void);
+
+-void moo_big_paned_set_pane_order (MooBigPaned *paned,
++void moo_big_paned_set_pane_order (MooInternalBigPaned *paned,
+ int *order);
+-void moo_big_paned_set_config (MooBigPaned *paned,
++void moo_big_paned_set_config (MooInternalBigPaned *paned,
+ const char *config_string);
+-char *moo_big_paned_get_config (MooBigPaned *paned);
++char *moo_big_paned_get_config (MooInternalBigPaned *paned);
+
+-MooPane *moo_big_paned_find_pane (MooBigPaned *paned,
++MooInternalPane *moo_big_paned_find_pane (MooInternalBigPaned *paned,
+ GtkWidget *pane_widget,
+- MooPaned **child_paned);
++ MooInternalPaned **child_paned);
+
+-void moo_big_paned_add_child (MooBigPaned *paned,
++void moo_big_paned_add_child (MooInternalBigPaned *paned,
+ GtkWidget *widget);
+-void moo_big_paned_remove_child (MooBigPaned *paned);
+-GtkWidget *moo_big_paned_get_child (MooBigPaned *paned);
++void moo_big_paned_remove_child (MooInternalBigPaned *paned);
++GtkWidget *moo_big_paned_get_child (MooInternalBigPaned *paned);
+
+-MooPane *moo_big_paned_insert_pane (MooBigPaned *paned,
++MooInternalPane *moo_big_paned_insert_pane (MooInternalBigPaned *paned,
+ GtkWidget *pane_widget,
+ const char *pane_id,
+- MooPaneLabel *pane_label,
+- MooPanePosition position,
++ MooInternalPaneLabel *pane_label,
++ MooInternalPanePosition position,
+ int index_);
+-gboolean moo_big_paned_remove_pane (MooBigPaned *paned,
++gboolean moo_big_paned_remove_pane (MooInternalBigPaned *paned,
+ GtkWidget *pane_widget);
+-MooPane *moo_big_paned_lookup_pane (MooBigPaned *paned,
++MooInternalPane *moo_big_paned_lookup_pane (MooInternalBigPaned *paned,
+ const char *pane_id);
+
+-GtkWidget *moo_big_paned_get_pane (MooBigPaned *paned,
+- MooPanePosition position,
++GtkWidget *moo_big_paned_get_pane (MooInternalBigPaned *paned,
++ MooInternalPanePosition position,
+ int index_);
+-void moo_big_paned_reorder_pane (MooBigPaned *paned,
++void moo_big_paned_reorder_pane (MooInternalBigPaned *paned,
+ GtkWidget *pane_widget,
+- MooPanePosition new_position,
++ MooInternalPanePosition new_position,
+ int new_index);
+
+-MooPaned *moo_big_paned_get_paned (MooBigPaned *paned,
+- MooPanePosition position);
++MooInternalPaned *moo_big_paned_get_paned (MooInternalBigPaned *paned,
++ MooInternalPanePosition position);
+
+-void moo_big_paned_open_pane (MooBigPaned *paned,
++void moo_big_paned_open_pane (MooInternalBigPaned *paned,
+ GtkWidget *pane_widget);
+-void moo_big_paned_hide_pane (MooBigPaned *paned,
++void moo_big_paned_hide_pane (MooInternalBigPaned *paned,
+ GtkWidget *pane_widget);
+-void moo_big_paned_present_pane (MooBigPaned *paned,
++void moo_big_paned_present_pane (MooInternalBigPaned *paned,
+ GtkWidget *pane_widget);
+-void moo_big_paned_attach_pane (MooBigPaned *paned,
++void moo_big_paned_attach_pane (MooInternalBigPaned *paned,
+ GtkWidget *pane_widget);
+-void moo_big_paned_detach_pane (MooBigPaned *paned,
++void moo_big_paned_detach_pane (MooInternalBigPaned *paned,
+ GtkWidget *pane_widget);
+
+
+ G_END_DECLS
+
+-#endif /* MOO_BIG_PANED_H */
++#endif /* MOO_INTERNAL_BIG_PANED_H */
+diff -ru pida.orig/contrib/moo/moopane.c pida/contrib/moo/moopane.c
+--- pida.orig/contrib/moo/moopane.c 2011-04-24 12:08:25.000000000 -0400
++++ pida/contrib/moo/moopane.c 2011-04-24 12:28:26.000000000 -0400
+@@ -92,15 +92,15 @@
+ #endif
+
+
+-struct MooPane {
++struct MooInternalPane {
+ GtkObject base;
+
+ char *id;
+- MooPaned *parent;
++ MooInternalPaned *parent;
+ GtkWidget *child;
+
+ GtkWidget *child_holder;
+- MooPaneLabel *label;
++ MooInternalPaneLabel *label;
+ GtkWidget *frame;
+ GtkWidget *handle;
+ GtkWidget *small_handle;
+@@ -123,7 +123,7 @@
+ GtkWidget *keep_on_top_button;
+ GtkWidget *window_child_holder;
+
+- MooPaneParams *params;
++ MooInternalPaneParams *params;
+
+ guint open_timeout;
+ guint button_highlight : 1;
+@@ -135,12 +135,12 @@
+ guint params_changed_blocked : 1;
+ };
+
+-struct MooPaneClass {
++struct MooInternalPaneClass {
+ GtkObjectClass base_class;
+- gboolean (*remove) (MooPane *pane);
++ gboolean (*remove) (MooInternalPane *pane);
+ };
+
+-G_DEFINE_TYPE (MooPane, moo_pane, GTK_TYPE_OBJECT)
++G_DEFINE_TYPE (MooInternalPane, moo_pane, GTK_TYPE_OBJECT)
+
+ enum {
+ PROP_0,
+@@ -160,7 +160,7 @@
+
+
+ static void
+-set_pane_window_icon_and_title (MooPane *pane)
++set_pane_window_icon_and_title (MooInternalPane *pane)
+ {
+ if (pane->window && pane->label)
+ {
+@@ -177,7 +177,7 @@
+ }
+
+ static void
+-update_label_widgets (MooPane *pane)
++update_label_widgets (MooInternalPane *pane)
+ {
+ if (pane->label && pane->label_widget)
+ {
+@@ -204,10 +204,10 @@
+ }
+
+ void
+-moo_pane_set_label (MooPane *pane,
+- MooPaneLabel *label)
++moo_pane_set_label (MooInternalPane *pane,
++ MooInternalPaneLabel *label)
+ {
+- MooPaneLabel *tmp;
++ MooInternalPaneLabel *tmp;
+
+ g_return_if_fail (MOO_IS_PANE (pane));
+ g_return_if_fail (label != NULL);
+@@ -222,15 +222,15 @@
+ }
+
+
+-MooPaneParams *
+-moo_pane_get_params (MooPane *pane)
++MooInternalPaneParams *
++moo_pane_get_params (MooInternalPane *pane)
+ {
+ g_return_val_if_fail (MOO_IS_PANE (pane), NULL);
+ return moo_pane_params_copy (pane->params);
+ }
+
+-MooPaneLabel *
+-moo_pane_get_label (MooPane *pane)
++MooInternalPaneLabel *
++moo_pane_get_label (MooInternalPane *pane)
+ {
+ g_return_val_if_fail (MOO_IS_PANE (pane), NULL);
+ return moo_pane_label_copy (pane->label);
+@@ -238,10 +238,10 @@
+
+
+ void
+-moo_pane_set_params (MooPane *pane,
+- MooPaneParams *params)
++moo_pane_set_params (MooInternalPane *pane,
++ MooInternalPaneParams *params)
+ {
+- MooPaneParams *old_params;
++ MooInternalPaneParams *old_params;
+
+ g_return_if_fail (MOO_IS_PANE (pane));
+ g_return_if_fail (params != NULL);
+@@ -266,7 +266,7 @@
+
+
+ void
+-moo_pane_set_detachable (MooPane *pane,
++moo_pane_set_detachable (MooInternalPane *pane,
+ gboolean detachable)
+ {
+ g_return_if_fail (MOO_IS_PANE (pane));
+@@ -287,7 +287,7 @@
+
+
+ void
+-moo_pane_set_removable (MooPane *pane,
++moo_pane_set_removable (MooInternalPane *pane,
+ gboolean removable)
+ {
+ g_return_if_fail (MOO_IS_PANE (pane));
+@@ -305,14 +305,14 @@
+
+
+ gboolean
+-moo_pane_get_detachable (MooPane *pane)
++moo_pane_get_detachable (MooInternalPane *pane)
+ {
+ g_return_val_if_fail (MOO_IS_PANE (pane), FALSE);
+ return pane->detachable;
+ }
+
+ gboolean
+-moo_pane_get_removable (MooPane *pane)
++moo_pane_get_removable (MooInternalPane *pane)
+ {
+ g_return_val_if_fail (MOO_IS_PANE (pane), FALSE);
+ return pane->removable;
+@@ -325,7 +325,7 @@
+ const GValue *value,
+ GParamSpec *pspec)
+ {
+- MooPane *pane = MOO_PANE (object);
++ MooInternalPane *pane = MOO_INTERNAL_PANE (object);
+
+ switch (prop_id)
+ {
+@@ -352,7 +352,7 @@
+ GValue *value,
+ GParamSpec *pspec)
+ {
+- MooPane *pane = MOO_PANE (object);
++ MooInternalPane *pane = MOO_INTERNAL_PANE (object);
+
+ switch (prop_id)
+ {
+@@ -378,7 +378,7 @@
+
+
+ static void
+-moo_pane_init (MooPane *pane)
++moo_pane_init (MooInternalPane *pane)
+ {
+ pane->detachable = TRUE;
+ pane->removable = TRUE;
+@@ -408,7 +408,7 @@
+ static void
+ moo_pane_finalize (GObject *object)
+ {
+- MooPane *pane = MOO_PANE (object);
++ MooInternalPane *pane = MOO_INTERNAL_PANE (object);
+
+ g_free (pane->id);
+ moo_pane_label_free (pane->label);
+@@ -420,7 +420,7 @@
+ static void
+ moo_pane_dispose (GObject *object)
+ {
+- MooPane *pane = MOO_PANE (object);
++ MooInternalPane *pane = MOO_INTERNAL_PANE (object);
+
+ if (pane->child)
+ {
+@@ -451,7 +451,7 @@
+ }
+
+ static void
+-moo_pane_class_init (MooPaneClass *klass)
++moo_pane_class_init (MooInternalPaneClass *klass)
+ {
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+@@ -466,11 +466,11 @@
+
+ g_object_class_install_property (gobject_class, PROP_LABEL,
+ g_param_spec_boxed ("label", "label", "label",
+- MOO_TYPE_PANE_LABEL, G_PARAM_READWRITE));
++ MOO_TYPE_INTERNAL_PANE_LABEL, G_PARAM_READWRITE));
+
+ g_object_class_install_property (gobject_class, PROP_PARAMS,
+ g_param_spec_boxed ("params", "params", "params",
+- MOO_TYPE_PANE_PARAMS, G_PARAM_READWRITE));
++ MOO_TYPE_INTERNAL_PANE_PARAMS, G_PARAM_READWRITE));
+
+ g_object_class_install_property (gobject_class, PROP_DETACHABLE,
+ g_param_spec_boolean ("detachable", "detachable", "detachable",
+@@ -484,7 +484,7 @@
+ g_signal_new ("remove",
+ G_OBJECT_CLASS_TYPE (klass),
+ G_SIGNAL_RUN_LAST,
+- G_STRUCT_OFFSET (MooPaneClass, remove),
++ G_STRUCT_OFFSET (MooInternalPaneClass, remove),
+ g_signal_accumulator_true_handled, NULL,
+ _moo_marshal_BOOL__VOID,
+ G_TYPE_BOOLEAN, 0);
+@@ -492,7 +492,7 @@
+
+
+ static void
+-close_button_clicked (MooPane *pane)
++close_button_clicked (MooInternalPane *pane)
+ {
+ g_return_if_fail (MOO_IS_PANE (pane));
+ if (pane->parent)
+@@ -500,7 +500,7 @@
+ }
+
+ static void
+-hide_button_clicked (MooPane *pane)
++hide_button_clicked (MooInternalPane *pane)
+ {
+ g_return_if_fail (MOO_IS_PANE (pane));
+ if (pane->parent)
+@@ -508,7 +508,7 @@
+ }
+
+ static void
+-attach_button_clicked (MooPane *pane)
++attach_button_clicked (MooInternalPane *pane)
+ {
+ g_return_if_fail (MOO_IS_PANE (pane));
+ if (pane->parent)
+@@ -516,14 +516,14 @@
+ }
+
+ static void
+-detach_button_clicked (MooPane *pane)
++detach_button_clicked (MooInternalPane *pane)
+ {
+ moo_paned_detach_pane (pane->parent, pane);
+ }
+
+ static void
+ sticky_button_toggled (GtkToggleButton *button,
+- MooPane *pane)
++ MooInternalPane *pane)
+ {
+ g_return_if_fail (MOO_IS_PANE (pane));
+ moo_paned_set_sticky_pane (pane->parent, gtk_toggle_button_get_active (button));
+@@ -531,7 +531,7 @@
+
+
+ static void
+-update_sticky_button (MooPane *pane)
++update_sticky_button (MooInternalPane *pane)
+ {
+ if (pane->parent)
+ {
+@@ -545,7 +545,7 @@
+
+
+ void
+-moo_pane_set_frame_markup (MooPane *pane,
++moo_pane_set_frame_markup (MooInternalPane *pane,
+ const char *text)
+ {
+ char *tmp;
+@@ -570,7 +570,7 @@
+ }
+
+ void
+-moo_pane_set_frame_text (MooPane *pane,
++moo_pane_set_frame_text (MooInternalPane *pane,
+ const char *text)
+ {
+ char *tmp;
+@@ -590,7 +590,7 @@
+
+
+ static GtkWidget *
+-create_button (MooPane *pane,
++create_button (MooInternalPane *pane,
+ GtkWidget *toolbar,
+ const char *tip,
+ gboolean toggle,
+@@ -619,8 +619,8 @@
+ }
+
+ static GtkWidget *
+-create_frame_widget (MooPane *pane,
+- MooPanePosition position,
++create_frame_widget (MooInternalPane *pane,
++ MooInternalPanePosition position,
+ gboolean embedded)
+ {
+ GtkWidget *vbox, *toolbar, *separator, *handle, *table, *child_holder;
+@@ -726,12 +726,12 @@
+
+ switch (position)
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ separator = gtk_vseparator_new ();
+ break;
+- case MOO_PANE_POS_TOP:
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ separator = gtk_hseparator_new ();
+ break;
+ }
+@@ -740,7 +740,7 @@
+
+ switch (position)
+ {
+- case MOO_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
+ gtk_table_attach (GTK_TABLE (table), separator,
+ 0, 1, 0, 1,
+ 0, GTK_FILL, 0, 0);
+@@ -748,7 +748,7 @@
+ 1, 2, 0, 1,
+ GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
+ break;
+- case MOO_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_TOP:
+ gtk_table_attach (GTK_TABLE (table), separator,
+ 0, 1, 0, 1,
+ 0, GTK_FILL, 0, 0);
+@@ -756,7 +756,7 @@
+ 0, 1, 1, 2,
+ GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
+ break;
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ gtk_table_attach (GTK_TABLE (table), separator,
+ 1, 2, 0, 1,
+ 0, GTK_FILL, 0, 0);
+@@ -764,7 +764,7 @@
+ 0, 1, 0, 1,
+ GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
+ break;
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ gtk_table_attach (GTK_TABLE (table), separator,
+ 0, 1, 1, 2,
+ 0, GTK_FILL, 0, 0);
+@@ -778,7 +778,7 @@
+ }
+
+ static GtkWidget *
+-create_label_widget (MooPanePosition position,
++create_label_widget (MooInternalPanePosition position,
+ GtkWidget **label_widget,
+ GtkWidget **icon_widget)
+ {
+@@ -790,10 +790,10 @@
+
+ switch (position)
+ {
+- case MOO_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
+ gtk_label_set_angle (GTK_LABEL (*label_widget), 90);
+ break;
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ gtk_label_set_angle (GTK_LABEL (*label_widget), 270);
+ break;
+ default:
+@@ -804,8 +804,8 @@
+
+ switch (position)
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ box = gtk_vbox_new (FALSE, SPACING_IN_BUTTON);
+ break;
+ default:
+@@ -815,7 +815,7 @@
+
+ switch (position)
+ {
+- case MOO_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
+ gtk_box_pack_start (GTK_BOX (box), *label_widget, FALSE, FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (box), *icon_widget, FALSE, FALSE, 0);
+ break;
+@@ -831,7 +831,7 @@
+
+
+ static void
+-paned_enable_detaching_notify (MooPane *pane)
++paned_enable_detaching_notify (MooInternalPane *pane)
+ {
+ gboolean enable;
+ g_object_get (pane->parent, "enable-detaching", &enable, NULL);
+@@ -839,7 +839,7 @@
+ }
+
+ static void
+-paned_sticky_pane_notify (MooPane *pane)
++paned_sticky_pane_notify (MooInternalPane *pane)
+ {
+ update_sticky_button (pane);
+ }
+@@ -849,7 +849,7 @@
+ button_drag_leave (GtkWidget *button,
+ G_GNUC_UNUSED GdkDragContext *context,
+ G_GNUC_UNUSED guint time,
+- MooPane *pane)
++ MooInternalPane *pane)
+ {
+ if (pane->open_timeout)
+ g_source_remove (pane->open_timeout);
+@@ -860,7 +860,7 @@
+ }
+
+ static gboolean
+-drag_open_pane (MooPane *pane)
++drag_open_pane (MooInternalPane *pane)
+ {
+ moo_pane_open (pane);
+
+@@ -878,7 +878,7 @@
+ G_GNUC_UNUSED int x,
+ G_GNUC_UNUSED int y,
+ guint time,
+- MooPane *pane)
++ MooInternalPane *pane)
+ {
+ g_return_val_if_fail (MOO_IS_PANE (pane), FALSE);
+
+@@ -920,7 +920,7 @@
+ }
+
+ static void
+-setup_button_dnd (MooPane *pane)
++setup_button_dnd (MooInternalPane *pane)
+ {
+ gtk_drag_dest_set (pane->button, 0, NULL, 0, GDK_ACTION_COPY | GDK_ACTION_MOVE);
+ g_signal_connect (pane->button, "drag-motion",
+@@ -930,7 +930,7 @@
+ }
+
+ void
+-moo_pane_set_drag_dest (MooPane *pane)
++moo_pane_set_drag_dest (MooInternalPane *pane)
+ {
+ g_return_if_fail (MOO_IS_PANE (pane));
+
+@@ -943,7 +943,7 @@
+ }
+
+ void
+-moo_pane_unset_drag_dest (MooPane *pane)
++moo_pane_unset_drag_dest (MooInternalPane *pane)
+ {
+ g_return_if_fail (MOO_IS_PANE (pane));
+
+@@ -971,8 +971,8 @@
+
+
+ static void
+-create_widgets (MooPane *pane,
+- MooPanePosition position,
++create_widgets (MooInternalPane *pane,
++ MooInternalPanePosition position,
+ GdkWindow *pane_window)
+ {
+ GtkWidget *label;
+@@ -1008,15 +1008,15 @@
+ G_CALLBACK (sticky_button_toggled), pane);
+ }
+
+-MooPane *
++MooInternalPane *
+ _moo_pane_new (GtkWidget *child,
+- MooPaneLabel *label)
++ MooInternalPaneLabel *label)
+ {
+- MooPane *pane;
++ MooInternalPane *pane;
+
+ g_return_val_if_fail (GTK_IS_WIDGET (child), NULL);
+
+- pane = g_object_new (MOO_TYPE_PANE, NULL);
++ pane = g_object_new (MOO_TYPE_INTERNAL_PANE, NULL);
+ pane->child = g_object_ref (child);
+ gtk_widget_show (pane->child);
+ g_object_set_data (G_OBJECT (pane->child), "moo-pane", pane);
+@@ -1028,14 +1028,14 @@
+ }
+
+ const char *
+-moo_pane_get_id (MooPane *pane)
++moo_pane_get_id (MooInternalPane *pane)
+ {
+ g_return_val_if_fail (MOO_IS_PANE (pane), NULL);
+ return pane->id;
+ }
+
+ void
+-_moo_pane_set_id (MooPane *pane,
++_moo_pane_set_id (MooInternalPane *pane,
+ const char *id)
+ {
+ char *tmp;
+@@ -1048,7 +1048,7 @@
+ }
+
+ void
+-_moo_pane_set_parent (MooPane *pane,
++_moo_pane_set_parent (MooInternalPane *pane,
+ gpointer parent,
+ GdkWindow *pane_window)
+ {
+@@ -1077,7 +1077,7 @@
+
+
+ void
+-_moo_pane_size_request (MooPane *pane,
++_moo_pane_size_request (MooInternalPane *pane,
+ GtkRequisition *req)
+ {
+ g_return_if_fail (MOO_IS_PANE (pane) && pane->frame != NULL);
+@@ -1085,7 +1085,7 @@
+ }
+
+ void
+-_moo_pane_size_allocate (MooPane *pane,
++_moo_pane_size_allocate (MooInternalPane *pane,
+ GtkAllocation *allocation)
+ {
+ g_return_if_fail (MOO_IS_PANE (pane) && pane->frame != NULL);
+@@ -1093,7 +1093,7 @@
+ }
+
+ void
+-_moo_pane_get_size_request (MooPane *pane,
++_moo_pane_get_size_request (MooInternalPane *pane,
+ GtkRequisition *req)
+ {
+ g_return_if_fail (MOO_IS_PANE (pane) && pane->frame != NULL);
+@@ -1101,28 +1101,28 @@
+ }
+
+ GtkWidget *
+-_moo_pane_get_frame (MooPane *pane)
++_moo_pane_get_frame (MooInternalPane *pane)
+ {
+ g_return_val_if_fail (MOO_IS_PANE (pane), NULL);
+ return pane->frame;
+ }
+
+ GtkWidget *
+-_moo_pane_get_focus_child (MooPane *pane)
++_moo_pane_get_focus_child (MooInternalPane *pane)
+ {
+ g_return_val_if_fail (MOO_IS_PANE (pane), NULL);
+ return pane->focus_child;
+ }
+
+ GtkWidget *
+-_moo_pane_get_button (MooPane *pane)
++_moo_pane_get_button (MooInternalPane *pane)
+ {
+ g_return_val_if_fail (MOO_IS_PANE (pane), NULL);
+ return pane->button;
+ }
+
+ void
+-_moo_pane_get_handle (MooPane *pane,
++_moo_pane_get_handle (MooInternalPane *pane,
+ GtkWidget **big,
+ GtkWidget **small)
+ {
+@@ -1132,21 +1132,21 @@
+ }
+
+ GtkWidget *
+-_moo_pane_get_window (MooPane *pane)
++_moo_pane_get_window (MooInternalPane *pane)
+ {
+ g_return_val_if_fail (MOO_IS_PANE (pane), NULL);
+ return pane->window;
+ }
+
+ GtkWidget *
+-moo_pane_get_child (MooPane *pane)
++moo_pane_get_child (MooInternalPane *pane)
+ {
+ g_return_val_if_fail (MOO_IS_PANE (pane), NULL);
+ return pane->child;
+ }
+
+ gpointer
+-_moo_pane_get_parent (MooPane *pane)
++_moo_pane_get_parent (MooInternalPane *pane)
+ {
+ g_return_val_if_fail (MOO_IS_PANE (pane), NULL);
+ return pane->parent;
+@@ -1154,7 +1154,7 @@
+
+
+ void
+-_moo_pane_params_changed (MooPane *pane)
++_moo_pane_params_changed (MooInternalPane *pane)
+ {
+ g_return_if_fail (MOO_IS_PANE (pane));
+ if (!pane->params_changed_blocked)
+@@ -1162,21 +1162,21 @@
+ }
+
+ void
+-_moo_pane_freeze_params (MooPane *pane)
++_moo_pane_freeze_params (MooInternalPane *pane)
+ {
+ g_return_if_fail (MOO_IS_PANE (pane));
+ pane->params_changed_blocked = TRUE;
+ }
+
+ void
+-_moo_pane_thaw_params (MooPane *pane)
++_moo_pane_thaw_params (MooInternalPane *pane)
+ {
+ g_return_if_fail (MOO_IS_PANE (pane));
+ pane->params_changed_blocked = FALSE;
+ }
+
+ gboolean
+-_moo_pane_get_detached (MooPane *pane)
++_moo_pane_get_detached (MooInternalPane *pane)
+ {
+ g_return_val_if_fail (MOO_IS_PANE (pane), FALSE);
+ return pane->params->detached;
+@@ -1184,7 +1184,7 @@
+
+
+ void
+-_moo_pane_unparent (MooPane *pane)
++_moo_pane_unparent (MooInternalPane *pane)
+ {
+ g_return_if_fail (MOO_IS_PANE (pane));
+
+@@ -1244,7 +1244,7 @@
+ }
+
+ void
+-_moo_pane_update_focus_child (MooPane *pane)
++_moo_pane_update_focus_child (MooInternalPane *pane)
+ {
+ g_return_if_fail (MOO_IS_PANE (pane));
+
+@@ -1259,7 +1259,7 @@
+
+
+ static gboolean
+-pane_window_delete_event (MooPane *pane)
++pane_window_delete_event (MooInternalPane *pane)
+ {
+ g_return_val_if_fail (MOO_IS_PANE (pane), FALSE);
+ moo_paned_attach_pane (pane->parent, pane);
+@@ -1268,7 +1268,7 @@
+
+ static void
+ keep_on_top_button_toggled (GtkToggleButton *button,
+- MooPane *pane)
++ MooInternalPane *pane)
+ {
+ gboolean active;
+
+@@ -1296,7 +1296,7 @@
+ static gboolean
+ pane_window_configure (GtkWidget *window,
+ GdkEventConfigure *event,
+- MooPane *pane)
++ MooInternalPane *pane)
+ {
+ g_return_val_if_fail (MOO_IS_PANE (pane), FALSE);
+ g_return_val_if_fail (pane->window == window, FALSE);
+@@ -1311,7 +1311,7 @@
+ }
+
+ static void
+-create_pane_window (MooPane *pane)
++create_pane_window (MooInternalPane *pane)
+ {
+ int width = -1;
+ int height = -1;
+@@ -1334,13 +1334,13 @@
+
+ switch (_moo_paned_get_position (pane->parent))
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ width = moo_paned_get_pane_size (pane->parent);
+ height = GTK_WIDGET(pane->parent)->allocation.height;
+ break;
+- case MOO_PANE_POS_TOP:
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ height = moo_paned_get_pane_size (pane->parent);
+ width = GTK_WIDGET(pane->parent)->allocation.width;
+ break;
+@@ -1378,7 +1378,7 @@
+ }
+
+ void
+-_moo_pane_detach (MooPane *pane)
++_moo_pane_detach (MooInternalPane *pane)
+ {
+ gboolean visible;
+
+@@ -1429,7 +1429,7 @@
+
+
+ void
+-_moo_pane_attach (MooPane *pane)
++_moo_pane_attach (MooInternalPane *pane)
+ {
+ g_return_if_fail (MOO_IS_PANE (pane));
+
+@@ -1452,7 +1452,7 @@
+
+
+ void
+-_moo_pane_try_remove (MooPane *pane)
++_moo_pane_try_remove (MooInternalPane *pane)
+ {
+ gboolean ret;
+
+@@ -1471,7 +1471,7 @@
+
+
+ void
+-moo_pane_open (MooPane *pane)
++moo_pane_open (MooInternalPane *pane)
+ {
+ g_return_if_fail (MOO_IS_PANE (pane));
+ g_return_if_fail (pane->parent != NULL);
+@@ -1479,7 +1479,7 @@
+ }
+
+ void
+-moo_pane_present (MooPane *pane)
++moo_pane_present (MooInternalPane *pane)
+ {
+ g_return_if_fail (MOO_IS_PANE (pane));
+ g_return_if_fail (pane->parent != NULL);
+@@ -1487,7 +1487,7 @@
+ }
+
+ void
+-moo_pane_attach (MooPane *pane)
++moo_pane_attach (MooInternalPane *pane)
+ {
+ g_return_if_fail (MOO_IS_PANE (pane));
+ g_return_if_fail (pane->parent != NULL);
+@@ -1495,7 +1495,7 @@
+ }
+
+ void
+-moo_pane_detach (MooPane *pane)
++moo_pane_detach (MooInternalPane *pane)
+ {
+ g_return_if_fail (MOO_IS_PANE (pane));
+ g_return_if_fail (pane->parent != NULL);
+@@ -1504,7 +1504,7 @@
+
+
+ int
+-moo_pane_get_index (MooPane *pane)
++moo_pane_get_index (MooInternalPane *pane)
+ {
+ g_return_val_if_fail (MOO_IS_PANE (pane), -1);
+ if (pane->parent)
+diff -ru pida.orig/contrib/moo/moopane.h pida/contrib/moo/moopane.h
+--- pida.orig/contrib/moo/moopane.h 2011-04-24 12:08:25.000000000 -0400
++++ pida/contrib/moo/moopane.h 2011-04-24 12:28:25.000000000 -0400
+@@ -13,37 +13,37 @@
+ * License along with medit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+-#ifndef MOO_PANE_H
+-#define MOO_PANE_H
++#ifndef MOO_INTERNAL_PANE_H
++#define MOO_INTERNAL_PANE_H
+
+ #include <gtk/gtkwidget.h>
+
+ G_BEGIN_DECLS
+
+
+-#define MOO_TYPE_PANE (moo_pane_get_type ())
+-#define MOO_PANE(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), MOO_TYPE_PANE, MooPane))
+-#define MOO_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MOO_TYPE_PANE, MooPaneClass))
+-#define MOO_IS_PANE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), MOO_TYPE_PANE))
+-#define MOO_IS_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MOO_TYPE_PANE))
+-#define MOO_PANE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MOO_TYPE_PANE, MooPaneClass))
+-
+-#define MOO_TYPE_PANE_LABEL (moo_pane_label_get_type ())
+-#define MOO_TYPE_PANE_PARAMS (moo_pane_params_get_type ())
+-
+-typedef struct MooPane MooPane;
+-typedef struct MooPaneClass MooPaneClass;
+-typedef struct MooPaneLabel MooPaneLabel;
+-typedef struct MooPaneParams MooPaneParams;
++#define MOO_TYPE_INTERNAL_PANE (moo_pane_get_type ())
++#define MOO_INTERNAL_PANE(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), MOO_TYPE_INTERNAL_PANE, MooInternalPane))
++#define MOO_INTERNAL_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MOO_TYPE_INTERNAL_PANE, MooInternalPaneClass))
++#define MOO_IS_PANE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), MOO_TYPE_INTERNAL_PANE))
++#define MOO_IS_PANE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MOO_TYPE_INTERNAL_PANE))
++#define MOO_INTERNAL_PANE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MOO_TYPE_INTERNAL_PANE, MooInternalPaneClass))
++
++#define MOO_TYPE_INTERNAL_PANE_LABEL (moo_pane_label_get_type ())
++#define MOO_TYPE_INTERNAL_PANE_PARAMS (moo_pane_params_get_type ())
++
++typedef struct MooInternalPane MooInternalPane;
++typedef struct MooInternalPaneClass MooInternalPaneClass;
++typedef struct MooInternalPaneLabel MooInternalPaneLabel;
++typedef struct MooInternalPaneParams MooInternalPaneParams;
+
+-struct MooPaneLabel {
++struct MooInternalPaneLabel {
+ char *icon_stock_id;
+ GdkPixbuf *icon_pixbuf;
+ char *label;
+ char *window_title;
+ };
+
+-struct MooPaneParams
++struct MooInternalPaneParams
+ {
+ GdkRectangle window_position;
+ guint detached : 1;
+@@ -56,85 +56,85 @@
+ GType moo_pane_label_get_type (void) G_GNUC_CONST;
+ GType moo_pane_params_get_type (void) G_GNUC_CONST;
+
+-const char *moo_pane_get_id (MooPane *pane);
++const char *moo_pane_get_id (MooInternalPane *pane);
+
+-void moo_pane_set_label (MooPane *pane,
+- MooPaneLabel *label);
++void moo_pane_set_label (MooInternalPane *pane,
++ MooInternalPaneLabel *label);
+ /* result must be freed with moo_pane_label_free() */
+-MooPaneLabel *moo_pane_get_label (MooPane *pane);
+-void moo_pane_set_frame_markup (MooPane *pane,
++MooInternalPaneLabel *moo_pane_get_label (MooInternalPane *pane);
++void moo_pane_set_frame_markup (MooInternalPane *pane,
+ const char *markup);
+-void moo_pane_set_frame_text (MooPane *pane,
++void moo_pane_set_frame_text (MooInternalPane *pane,
+ const char *text);
+-void moo_pane_set_params (MooPane *pane,
+- MooPaneParams *params);
++void moo_pane_set_params (MooInternalPane *pane,
++ MooInternalPaneParams *params);
+ /* result must be freed with moo_pane_params_free() */
+-MooPaneParams *moo_pane_get_params (MooPane *pane);
+-void moo_pane_set_detachable (MooPane *pane,
++MooInternalPaneParams *moo_pane_get_params (MooInternalPane *pane);
++void moo_pane_set_detachable (MooInternalPane *pane,
+ gboolean detachable);
+-gboolean moo_pane_get_detachable (MooPane *pane);
+-void moo_pane_set_removable (MooPane *pane,
++gboolean moo_pane_get_detachable (MooInternalPane *pane);
++void moo_pane_set_removable (MooInternalPane *pane,
+ gboolean removable);
+-gboolean moo_pane_get_removable (MooPane *pane);
++gboolean moo_pane_get_removable (MooInternalPane *pane);
+
+-GtkWidget *moo_pane_get_child (MooPane *pane);
+-int moo_pane_get_index (MooPane *pane);
++GtkWidget *moo_pane_get_child (MooInternalPane *pane);
++int moo_pane_get_index (MooInternalPane *pane);
+
+-void moo_pane_open (MooPane *pane);
+-void moo_pane_present (MooPane *pane);
+-void moo_pane_attach (MooPane *pane);
+-void moo_pane_detach (MooPane *pane);
++void moo_pane_open (MooInternalPane *pane);
++void moo_pane_present (MooInternalPane *pane);
++void moo_pane_attach (MooInternalPane *pane);
++void moo_pane_detach (MooInternalPane *pane);
+
+-void moo_pane_set_drag_dest (MooPane *pane);
+-void moo_pane_unset_drag_dest (MooPane *pane);
++void moo_pane_set_drag_dest (MooInternalPane *pane);
++void moo_pane_unset_drag_dest (MooInternalPane *pane);
+
+-MooPaneParams *moo_pane_params_new (GdkRectangle *window_position,
++MooInternalPaneParams *moo_pane_params_new (GdkRectangle *window_position,
+ gboolean detached,
+ gboolean maximized,
+ gboolean keep_on_top);
+-MooPaneParams *moo_pane_params_copy (MooPaneParams *params);
+-void moo_pane_params_free (MooPaneParams *params);
++MooInternalPaneParams *moo_pane_params_copy (MooInternalPaneParams *params);
++void moo_pane_params_free (MooInternalPaneParams *params);
+
+-MooPaneLabel *moo_pane_label_new (const char *icon_stock_id,
++MooInternalPaneLabel *moo_pane_label_new (const char *icon_stock_id,
+ GdkPixbuf *pixbuf,
+ const char *label,
+ const char *window_title);
+-MooPaneLabel *moo_pane_label_copy (MooPaneLabel *label);
+-void moo_pane_label_free (MooPaneLabel *label);
++MooInternalPaneLabel *moo_pane_label_copy (MooInternalPaneLabel *label);
++void moo_pane_label_free (MooInternalPaneLabel *label);
+
+-MooPane *_moo_pane_new (GtkWidget *child,
+- MooPaneLabel *label);
+-void _moo_pane_set_id (MooPane *pane,
++MooInternalPane *_moo_pane_new (GtkWidget *child,
++ MooInternalPaneLabel *label);
++void _moo_pane_set_id (MooInternalPane *pane,
+ const char *id);
+
+-gpointer _moo_pane_get_parent (MooPane *pane);
+-GtkWidget *_moo_pane_get_frame (MooPane *pane);
+-void _moo_pane_update_focus_child (MooPane *pane);
+-GtkWidget *_moo_pane_get_focus_child (MooPane *pane);
+-GtkWidget *_moo_pane_get_button (MooPane *pane);
+-void _moo_pane_get_handle (MooPane *pane,
++gpointer _moo_pane_get_parent (MooInternalPane *pane);
++GtkWidget *_moo_pane_get_frame (MooInternalPane *pane);
++void _moo_pane_update_focus_child (MooInternalPane *pane);
++GtkWidget *_moo_pane_get_focus_child (MooInternalPane *pane);
++GtkWidget *_moo_pane_get_button (MooInternalPane *pane);
++void _moo_pane_get_handle (MooInternalPane *pane,
+ GtkWidget **big,
+ GtkWidget **small);
+-GtkWidget *_moo_pane_get_window (MooPane *pane);
++GtkWidget *_moo_pane_get_window (MooInternalPane *pane);
+
+-void _moo_pane_params_changed (MooPane *pane);
+-void _moo_pane_freeze_params (MooPane *pane);
+-void _moo_pane_thaw_params (MooPane *pane);
+-void _moo_pane_size_request (MooPane *pane,
++void _moo_pane_params_changed (MooInternalPane *pane);
++void _moo_pane_freeze_params (MooInternalPane *pane);
++void _moo_pane_thaw_params (MooInternalPane *pane);
++void _moo_pane_size_request (MooInternalPane *pane,
+ GtkRequisition *req);
+-void _moo_pane_get_size_request (MooPane *pane,
++void _moo_pane_get_size_request (MooInternalPane *pane,
+ GtkRequisition *req);
+-void _moo_pane_size_allocate (MooPane *pane,
++void _moo_pane_size_allocate (MooInternalPane *pane,
+ GtkAllocation *allocation);
+
+-gboolean _moo_pane_get_detached (MooPane *pane);
+-void _moo_pane_attach (MooPane *pane);
+-void _moo_pane_detach (MooPane *pane);
+-void _moo_pane_set_parent (MooPane *pane,
++gboolean _moo_pane_get_detached (MooInternalPane *pane);
++void _moo_pane_attach (MooInternalPane *pane);
++void _moo_pane_detach (MooInternalPane *pane);
++void _moo_pane_set_parent (MooInternalPane *pane,
+ gpointer parent,
+ GdkWindow *window);
+-void _moo_pane_unparent (MooPane *pane);
+-void _moo_pane_try_remove (MooPane *pane);
++void _moo_pane_unparent (MooInternalPane *pane);
++void _moo_pane_try_remove (MooInternalPane *pane);
+
+ typedef enum {
+ MOO_SMALL_ICON_HIDE,
+@@ -151,4 +151,4 @@
+
+ G_END_DECLS
+
+-#endif /* MOO_PANE_H */
++#endif /* MOO_INTERNAL_PANE_H */
+diff -ru pida.orig/contrib/moo/moopaned.c pida/contrib/moo/moopaned.c
+--- pida.orig/contrib/moo/moopaned.c 2011-04-24 12:08:25.000000000 -0400
++++ pida/contrib/moo/moopaned.c 2011-04-24 12:28:31.000000000 -0400
+@@ -46,8 +46,8 @@
+ FOCUS_BUTTON
+ } FocusPosition;
+
+-struct _MooPanedPrivate {
+- MooPanePosition pane_position;
++struct _MooInternalPanedPrivate {
++ MooInternalPanePosition pane_position;
+
+ GdkWindow *bin_window;
+ GdkWindow *handle_window;
+@@ -55,12 +55,12 @@
+
+ /* XXX weak pointer */
+ gpointer focus_child; /* focused grandchild of bin->child */
+- MooPane *focus_pane;
++ MooInternalPane *focus_pane;
+ FocusPosition focus;
+ gboolean button_real_focus; /* button was focused by keyboard navigation */
+ gboolean dont_move_focus; /* do not try to move focus in open_pane/hide_pane */
+
+- MooPane *current_pane;
++ MooInternalPane *current_pane;
+ GSList *panes;
+
+ gboolean close_on_child_focus;
+@@ -140,15 +140,15 @@
+ static gboolean moo_paned_key_press (GtkWidget *widget,
+ GdkEventKey *event);
+
+-static int pane_index (MooPaned *paned,
+- MooPane *pane);
+-static MooPane *get_nth_pane (MooPaned *paned,
++static int pane_index (MooInternalPaned *paned,
++ MooInternalPane *pane);
++static MooInternalPane *get_nth_pane (MooInternalPaned *paned,
+ guint index_);
+
+-static void moo_paned_open_pane_real (MooPaned *paned,
++static void moo_paned_open_pane_real (MooInternalPaned *paned,
+ guint index);
+-static void moo_paned_hide_pane_real (MooPaned *paned);
+-static void moo_paned_set_pane_size_real(MooPaned *paned,
++static void moo_paned_hide_pane_real (MooInternalPaned *paned);
++static void moo_paned_set_pane_size_real(MooInternalPaned *paned,
+ int size);
+
+ static void moo_paned_forall (GtkContainer *container,
+@@ -160,41 +160,41 @@
+ static void moo_paned_remove (GtkContainer *container,
+ GtkWidget *widget);
+
+-static void realize_handle (MooPaned *paned);
+-static void realize_pane (MooPaned *paned);
+-static void draw_handle (MooPaned *paned,
++static void realize_handle (MooInternalPaned *paned);
++static void realize_pane (MooInternalPaned *paned);
++static void draw_handle (MooInternalPaned *paned,
+ GdkEventExpose *event);
+-static void draw_border (MooPaned *paned,
++static void draw_border (MooInternalPaned *paned,
+ GdkEventExpose *event);
+-static void button_box_visible_notify (MooPaned *paned);
++static void button_box_visible_notify (MooInternalPaned *paned);
+
+ static void pane_button_toggled (GtkToggleButton *button,
+- MooPaned *paned);
++ MooInternalPaned *paned);
+
+ static gboolean handle_button_press (GtkWidget *widget,
+ GdkEventButton *event,
+- MooPaned *paned);
++ MooInternalPaned *paned);
+ static gboolean handle_button_release (GtkWidget *widget,
+ GdkEventButton *event,
+- MooPaned *paned);
++ MooInternalPaned *paned);
+ static gboolean handle_motion (GtkWidget *widget,
+ GdkEventMotion *event,
+- MooPaned *paned);
++ MooInternalPaned *paned);
+ static gboolean handle_expose (GtkWidget *widget,
+ GdkEventExpose *event,
+- MooPaned *paned);
++ MooInternalPaned *paned);
+ static void handle_realize (GtkWidget *widget,
+- MooPaned *paned);
++ MooInternalPaned *paned);
+
+ static void moo_paned_set_handle_cursor_type
+- (MooPaned *paned,
++ (MooInternalPaned *paned,
+ GdkCursorType cursor_type,
+ gboolean really_set);
+ static void moo_paned_set_enable_detaching
+- (MooPaned *paned,
++ (MooInternalPaned *paned,
+ gboolean enable);
+
+-G_DEFINE_TYPE (MooPaned, moo_paned, GTK_TYPE_BIN)
++G_DEFINE_TYPE (MooInternalPaned, moo_paned, GTK_TYPE_BIN)
+
+ enum {
+ PANED_PROP_0,
+@@ -220,14 +220,14 @@
+ static guint paned_signals[PANED_NUM_SIGNALS];
+
+ static void
+-moo_paned_class_init (MooPanedClass *klass)
++moo_paned_class_init (MooInternalPanedClass *klass)
+ {
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+ GtkObjectClass *gtkobject_class = GTK_OBJECT_CLASS (klass);
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+ GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
+
+- g_type_class_add_private (klass, sizeof (MooPanedPrivate));
++ g_type_class_add_private (klass, sizeof (MooInternalPanedPrivate));
+
+ gobject_class->set_property = moo_paned_set_property;
+ gobject_class->get_property = moo_paned_get_property;
+@@ -260,11 +260,11 @@
+
+ g_object_class_install_property (gobject_class, PANED_PROP_ACTIVE_PANE,
+ g_param_spec_object ("active-pane", "active-pane", "active-pane",
+- MOO_TYPE_PANE, G_PARAM_READWRITE));
++ MOO_TYPE_INTERNAL_PANE, G_PARAM_READWRITE));
+
+ g_object_class_install_property (gobject_class, PANED_PROP_PANE_POSITION,
+ g_param_spec_enum ("pane-position", "pane-position", "pane-position",
+- MOO_TYPE_PANE_POSITION, MOO_PANE_POS_LEFT,
++ MOO_TYPE_INTERNAL_PANE_POSITION, MOO_INTERNAL_PANE_POS_LEFT,
+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+
+ g_object_class_install_property (gobject_class, PANED_PROP_CLOSE_PANE_ON_CHILD_FOCUS,
+@@ -304,7 +304,7 @@
+ g_signal_new ("set-pane-size",
+ G_OBJECT_CLASS_TYPE (klass),
+ G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
+- G_STRUCT_OFFSET (MooPanedClass, set_pane_size),
++ G_STRUCT_OFFSET (MooInternalPanedClass, set_pane_size),
+ NULL, NULL,
+ _moo_marshal_VOID__INT,
+ G_TYPE_NONE, 1,
+@@ -314,7 +314,7 @@
+ g_signal_new ("handle-drag-start",
+ G_OBJECT_CLASS_TYPE (klass),
+ G_SIGNAL_RUN_FIRST,
+- G_STRUCT_OFFSET (MooPanedClass, handle_drag_start),
++ G_STRUCT_OFFSET (MooInternalPanedClass, handle_drag_start),
+ NULL, NULL,
+ _moo_marshal_VOID__OBJECT,
+ G_TYPE_NONE, 1,
+@@ -324,7 +324,7 @@
+ g_signal_new ("handle-drag-motion",
+ G_OBJECT_CLASS_TYPE (klass),
+ G_SIGNAL_RUN_FIRST,
+- G_STRUCT_OFFSET (MooPanedClass, handle_drag_motion),
++ G_STRUCT_OFFSET (MooInternalPanedClass, handle_drag_motion),
+ NULL, NULL,
+ _moo_marshal_VOID__OBJECT,
+ G_TYPE_NONE, 1,
+@@ -334,7 +334,7 @@
+ g_signal_new ("handle-drag-end",
+ G_OBJECT_CLASS_TYPE (klass),
+ G_SIGNAL_RUN_FIRST,
+- G_STRUCT_OFFSET (MooPanedClass, handle_drag_end),
++ G_STRUCT_OFFSET (MooInternalPanedClass, handle_drag_end),
+ NULL, NULL,
+ _moo_marshal_VOID__OBJECT_BOOL,
+ G_TYPE_NONE, 2,
+@@ -345,7 +345,7 @@
+ g_signal_new ("pane-params-changed",
+ G_OBJECT_CLASS_TYPE (klass),
+ G_SIGNAL_RUN_LAST,
+- G_STRUCT_OFFSET (MooPanedClass, pane_params_changed),
++ G_STRUCT_OFFSET (MooInternalPanedClass, pane_params_changed),
+ NULL, NULL,
+ _moo_marshal_VOID__UINT,
+ G_TYPE_NONE, 1,
+@@ -354,13 +354,13 @@
+
+
+ static void
+-moo_paned_init (MooPaned *paned)
++moo_paned_init (MooInternalPaned *paned)
+ {
+ GTK_WIDGET_SET_FLAGS (paned, GTK_NO_WINDOW);
+
+ paned->priv = G_TYPE_INSTANCE_GET_PRIVATE (paned,
+- MOO_TYPE_PANED,
+- MooPanedPrivate);
++ MOO_TYPE_INTERNAL_PANED,
++ MooInternalPanedPrivate);
+
+ paned->button_box = NULL;
+
+@@ -396,31 +396,31 @@
+ GObjectConstructParam *construct_properties)
+ {
+ GObject *object;
+- MooPaned *paned;
++ MooInternalPaned *paned;
+ int button_spacing;
+
+ object = G_OBJECT_CLASS(moo_paned_parent_class)->constructor (type,
+ n_construct_properties, construct_properties);
+- paned = MOO_PANED (object);
++ paned = MOO_INTERNAL_PANED (object);
+
+ gtk_widget_style_get (GTK_WIDGET (paned),
+ "button-spacing", &button_spacing, NULL);
+
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ paned->button_box = gtk_vbox_new (FALSE, button_spacing);
+ break;
+- case MOO_PANE_POS_TOP:
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ paned->button_box = gtk_hbox_new (FALSE, button_spacing);
+ break;
+ default:
+ g_warning ("%s: invalid 'pane-position' property value '%u',"
+- "falling back to MOO_PANE_POS_LEFT", G_STRLOC,
++ "falling back to MOO_INTERNAL_PANE_POS_LEFT", G_STRLOC,
+ paned->priv->pane_position);
+- paned->priv->pane_position = MOO_PANE_POS_LEFT;
++ paned->priv->pane_position = MOO_INTERNAL_PANE_POS_LEFT;
+ paned->button_box = gtk_vbox_new (FALSE, button_spacing);
+ break;
+ }
+@@ -443,7 +443,7 @@
+ const GValue *value,
+ GParamSpec *pspec)
+ {
+- MooPaned *paned = MOO_PANED (object);
++ MooInternalPaned *paned = MOO_INTERNAL_PANED (object);
+
+ switch (prop_id)
+ {
+@@ -504,7 +504,7 @@
+ GValue *value,
+ GParamSpec *pspec)
+ {
+- MooPaned *paned = MOO_PANED (object);
++ MooInternalPaned *paned = MOO_INTERNAL_PANED (object);
+
+ switch (prop_id)
+ {
+@@ -550,7 +550,7 @@
+ moo_paned_destroy (GtkObject *object)
+ {
+ GSList *l;
+- MooPaned *paned = MOO_PANED (object);
++ MooInternalPaned *paned = MOO_INTERNAL_PANED (object);
+
+ for (l = paned->priv->panes; l != NULL; l = l->next)
+ gtk_object_destroy (l->data);
+@@ -566,16 +566,16 @@
+
+
+ GtkWidget*
+-moo_paned_new (MooPanePosition pane_position)
++moo_paned_new (MooInternalPanePosition pane_position)
+ {
+- return GTK_WIDGET (g_object_new (MOO_TYPE_PANED,
++ return GTK_WIDGET (g_object_new (MOO_TYPE_INTERNAL_PANED,
+ "pane-position", pane_position,
+ NULL));
+ }
+
+
+-MooPanePosition
+-_moo_paned_get_position (MooPaned *paned)
++MooInternalPanePosition
++_moo_paned_get_position (MooInternalPaned *paned)
+ {
+ g_return_val_if_fail (MOO_IS_PANED (paned), 0);
+ return paned->priv->pane_position;
+@@ -586,7 +586,7 @@
+ moo_paned_style_set (GtkWidget *widget,
+ G_GNUC_UNUSED GtkStyle *old_style)
+ {
+- MooPaned *paned = MOO_PANED (widget);
++ MooInternalPaned *paned = MOO_INTERNAL_PANED (widget);
+
+ if (widget->style)
+ {
+@@ -610,9 +610,9 @@
+ {
+ static GdkWindowAttr attributes;
+ gint attributes_mask;
+- MooPaned *paned;
++ MooInternalPaned *paned;
+
+- paned = MOO_PANED (widget);
++ paned = MOO_INTERNAL_PANED (widget);
+
+ widget->window = gtk_widget_get_parent_window (widget);
+ g_object_ref (widget->window);
+@@ -650,7 +650,7 @@
+
+
+ static void
+-realize_handle (MooPaned *paned)
++realize_handle (MooInternalPaned *paned)
+ {
+ static GdkWindowAttr attributes;
+ gint attributes_mask;
+@@ -658,14 +658,14 @@
+
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ attributes.y = 0;
+ attributes.width = paned->priv->handle_size;
+ attributes.height = widget->allocation.height;
+ break;
+- case MOO_PANE_POS_TOP:
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ attributes.x = 0;
+ attributes.width = widget->allocation.width;
+ attributes.height = paned->priv->handle_size;
+@@ -674,16 +674,16 @@
+
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
+ attributes.x = paned->priv->pane_widget_size;
+ break;
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ attributes.x = 0;
+ break;
+- case MOO_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_TOP:
+ attributes.y = paned->priv->pane_widget_size;
+ break;
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ attributes.y = 0;
+ break;
+ }
+@@ -704,12 +704,12 @@
+
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ attributes.cursor = gdk_cursor_new (GDK_SB_H_DOUBLE_ARROW);
+ break;
+- case MOO_PANE_POS_TOP:
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ attributes.cursor = gdk_cursor_new (GDK_SB_V_DOUBLE_ARROW);
+ break;
+ }
+@@ -730,36 +730,36 @@
+
+
+ static void
+-get_pane_window_rect (MooPaned *paned,
++get_pane_window_rect (MooInternalPaned *paned,
+ GdkRectangle *rect)
+ {
+ *rect = GTK_WIDGET(paned)->allocation;
+
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ rect->width = paned->priv->pane_widget_size + paned->priv->handle_size;
+ break;
+- case MOO_PANE_POS_TOP:
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ rect->height = paned->priv->pane_widget_size + paned->priv->handle_size;
+ break;
+ }
+
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
+ rect->x += paned->priv->button_box_size;
+ break;
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ rect->x += GTK_WIDGET(paned)->allocation.width - rect->width -
+ paned->priv->button_box_size;
+ break;
+- case MOO_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_TOP:
+ rect->y += paned->priv->button_box_size;
+ break;
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ rect->y += GTK_WIDGET(paned)->allocation.height - rect->height -
+ paned->priv->button_box_size;
+ break;
+@@ -768,7 +768,7 @@
+
+
+ static void
+-realize_pane (MooPaned *paned)
++realize_pane (MooInternalPaned *paned)
+ {
+ static GdkWindowAttr attributes;
+ gint attributes_mask;
+@@ -811,7 +811,7 @@
+ static void
+ moo_paned_unrealize (GtkWidget *widget)
+ {
+- MooPaned *paned = MOO_PANED (widget);
++ MooInternalPaned *paned = MOO_INTERNAL_PANED (widget);
+
+ if (paned->priv->handle_window)
+ {
+@@ -843,20 +843,20 @@
+
+
+ static void
+-add_button_box_requisition (MooPaned *paned,
++add_button_box_requisition (MooInternalPaned *paned,
+ GtkRequisition *requisition,
+ GtkRequisition *child_requisition)
+ {
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ requisition->width += child_requisition->width;
+ requisition->height = MAX (child_requisition->height, requisition->height);
+ paned->priv->button_box_size = child_requisition->width;
+ break;
+- case MOO_PANE_POS_TOP:
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ requisition->height += child_requisition->height;
+ requisition->width = MAX (child_requisition->width, requisition->width);
+ paned->priv->button_box_size = child_requisition->height;
+@@ -866,7 +866,7 @@
+
+
+ static void
+-add_handle_requisition (MooPaned *paned,
++add_handle_requisition (MooInternalPaned *paned,
+ GtkRequisition *requisition)
+ {
+ gtk_widget_style_get (GTK_WIDGET (paned),
+@@ -875,12 +875,12 @@
+
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ requisition->width += paned->priv->handle_size;
+ break;
+- case MOO_PANE_POS_TOP:
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ requisition->height += paned->priv->handle_size;
+ break;
+ }
+@@ -888,14 +888,14 @@
+
+
+ static void
+-add_pane_widget_requisition (MooPaned *paned,
++add_pane_widget_requisition (MooInternalPaned *paned,
+ GtkRequisition *requisition,
+ GtkRequisition *child_requisition)
+ {
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ requisition->height = MAX (child_requisition->height, requisition->height);
+
+ if (paned->priv->sticky)
+@@ -911,8 +911,8 @@
+
+ break;
+
+- case MOO_PANE_POS_TOP:
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ requisition->width = MAX (child_requisition->width, requisition->width);
+
+ if (paned->priv->sticky)
+@@ -931,14 +931,14 @@
+
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ paned->priv->pane_widget_size = MAX (paned->priv->position,
+ child_requisition->width);
+ paned->priv->position = paned->priv->pane_widget_size;
+ break;
+- case MOO_PANE_POS_TOP:
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ paned->priv->pane_widget_size = MAX (paned->priv->position,
+ child_requisition->height);
+ paned->priv->position = paned->priv->pane_widget_size;
+@@ -952,7 +952,7 @@
+ GtkRequisition *requisition)
+ {
+ GtkBin *bin = GTK_BIN (widget);
+- MooPaned *paned = MOO_PANED (widget);
++ MooInternalPaned *paned = MOO_INTERNAL_PANED (widget);
+ GtkRequisition child_requisition;
+
+ requisition->width = 0;
+@@ -994,13 +994,13 @@
+ {
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ paned->priv->border_size = widget->style->xthickness;
+ requisition->width += paned->priv->border_size;
+ break;
+- case MOO_PANE_POS_TOP:
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ paned->priv->border_size = widget->style->ythickness;
+ requisition->height += paned->priv->border_size;
+ break;
+@@ -1014,7 +1014,7 @@
+
+
+ static void
+-get_pane_widget_allocation (MooPaned *paned,
++get_pane_widget_allocation (MooInternalPaned *paned,
+ GtkAllocation *allocation)
+ {
+ allocation->x = 0;
+@@ -1024,17 +1024,17 @@
+
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ allocation->x += paned->priv->handle_size;
+ /* fall through */
+- case MOO_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
+ allocation->width = paned->priv->pane_widget_size;
+ break;
+
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ allocation->y += paned->priv->handle_size;
+ /* fall through */
+- case MOO_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_TOP:
+ allocation->height = paned->priv->pane_widget_size;
+ break;
+ }
+@@ -1042,19 +1042,19 @@
+
+
+ static void
+-get_button_box_allocation (MooPaned *paned,
++get_button_box_allocation (MooInternalPaned *paned,
+ GtkAllocation *allocation)
+ {
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ allocation->y = 0;
+ allocation->height = GTK_WIDGET(paned)->allocation.height;
+ allocation->width = paned->priv->button_box_size;
+ break;
+- case MOO_PANE_POS_TOP:
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ allocation->x = 0;
+ allocation->width = GTK_WIDGET(paned)->allocation.width;
+ allocation->height = paned->priv->button_box_size;
+@@ -1063,16 +1063,16 @@
+
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
+ allocation->x = 0;
+ break;
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ allocation->x = GTK_WIDGET(paned)->allocation.width - allocation->width;
+ break;
+- case MOO_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_TOP:
+ allocation->y = 0;
+ break;
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ allocation->y = GTK_WIDGET(paned)->allocation.height - allocation->height;
+ break;
+ }
+@@ -1080,21 +1080,21 @@
+
+
+ static void
+-get_bin_child_allocation (MooPaned *paned,
++get_bin_child_allocation (MooInternalPaned *paned,
+ GtkAllocation *allocation)
+ {
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ allocation->y = 0;
+ allocation->height = GTK_WIDGET(paned)->allocation.height;
+ allocation->width = GTK_WIDGET(paned)->allocation.width -
+ paned->priv->button_box_size -
+ paned->priv->border_size;
+ break;
+- case MOO_PANE_POS_TOP:
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ allocation->x = 0;
+ allocation->width = GTK_WIDGET(paned)->allocation.width;
+ allocation->height = GTK_WIDGET(paned)->allocation.height -
+@@ -1105,18 +1105,18 @@
+
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
+ allocation->x = paned->priv->button_box_size +
+ paned->priv->border_size;
+ break;
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ allocation->x = 0;
+ break;
+- case MOO_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_TOP:
+ allocation->y = paned->priv->button_box_size +
+ paned->priv->border_size;
+ break;
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ allocation->y = 0;
+ break;
+ }
+@@ -1127,18 +1127,18 @@
+
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
+ allocation->x += add;
+ allocation->width -= add;
+ break;
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ allocation->width -= add;
+ break;
+- case MOO_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_TOP:
+ allocation->y += add;
+ allocation->height -= add;
+ break;
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ allocation->height -= add;
+ break;
+ }
+@@ -1147,17 +1147,17 @@
+
+
+ static void
+-clamp_handle_size (MooPaned *paned)
++clamp_handle_size (MooInternalPaned *paned)
+ {
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ paned->priv->handle_size = CLAMP (paned->priv->handle_size, 0,
+ GTK_WIDGET(paned)->allocation.width);
+ break;
+- case MOO_PANE_POS_TOP:
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ paned->priv->handle_size = CLAMP (paned->priv->handle_size, 0,
+ GTK_WIDGET(paned)->allocation.height);
+ break;
+@@ -1166,18 +1166,18 @@
+
+
+ static void
+-clamp_button_box_size (MooPaned *paned)
++clamp_button_box_size (MooInternalPaned *paned)
+ {
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ paned->priv->button_box_size = CLAMP (paned->priv->button_box_size, 0,
+ GTK_WIDGET(paned)->allocation.width -
+ paned->priv->handle_size);
+ break;
+- case MOO_PANE_POS_TOP:
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ paned->priv->button_box_size = CLAMP (paned->priv->button_box_size, 0,
+ GTK_WIDGET(paned)->allocation.height -
+ paned->priv->handle_size);
+@@ -1187,21 +1187,21 @@
+
+
+ static void
+-clamp_child_requisition (MooPaned *paned,
++clamp_child_requisition (MooInternalPaned *paned,
+ GtkRequisition *requisition)
+ {
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ requisition->width = CLAMP (requisition->width, 0,
+ GTK_WIDGET(paned)->allocation.width -
+ paned->priv->handle_size -
+ paned->priv->button_box_size -
+ paned->priv->border_size);
+ break;
+- case MOO_PANE_POS_TOP:
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ requisition->height = CLAMP (requisition->height, 0,
+ GTK_WIDGET(paned)->allocation.height -
+ paned->priv->handle_size -
+@@ -1213,7 +1213,7 @@
+
+
+ static void
+-clamp_pane_widget_size (MooPaned *paned,
++clamp_pane_widget_size (MooInternalPaned *paned,
+ GtkRequisition *child_requisition)
+ {
+ int min_size;
+@@ -1221,16 +1221,16 @@
+
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ max_size = GTK_WIDGET(paned)->allocation.width -
+ paned->priv->handle_size -
+ paned->priv->button_box_size;
+ if (paned->priv->sticky)
+ max_size -= child_requisition->width;
+ break;
+- case MOO_PANE_POS_TOP:
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ max_size = GTK_WIDGET(paned)->allocation.height -
+ paned->priv->handle_size -
+ paned->priv->button_box_size;
+@@ -1247,19 +1247,19 @@
+
+
+ static void
+-get_handle_window_rect (MooPaned *paned,
++get_handle_window_rect (MooInternalPaned *paned,
+ GdkRectangle *rect)
+ {
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ rect->y = 0;
+ rect->width = paned->priv->handle_size;
+ rect->height = GTK_WIDGET(paned)->allocation.height;
+ break;
+- case MOO_PANE_POS_TOP:
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ rect->x = 0;
+ rect->height = paned->priv->handle_size;
+ rect->width = GTK_WIDGET(paned)->allocation.width;
+@@ -1268,16 +1268,16 @@
+
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
+ rect->x = paned->priv->pane_widget_size;
+ break;
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ rect->x = 0;
+ break;
+- case MOO_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_TOP:
+ rect->y = paned->priv->pane_widget_size;
+ break;
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ rect->y = 0;
+ break;
+ }
+@@ -1289,13 +1289,13 @@
+ GtkAllocation *allocation)
+ {
+ GtkBin *bin;
+- MooPaned *paned;
++ MooInternalPaned *paned;
+ GtkAllocation child_allocation;
+ GtkRequisition child_requisition = {0, 0};
+
+ widget->allocation = *allocation;
+ bin = GTK_BIN (widget);
+- paned = MOO_PANED (widget);
++ paned = MOO_INTERNAL_PANED (widget);
+
+ if (!paned->priv->handle_visible)
+ paned->priv->handle_size = 0;
+@@ -1372,7 +1372,7 @@
+ static void
+ moo_paned_map (GtkWidget *widget)
+ {
+- MooPaned *paned = MOO_PANED (widget);
++ MooInternalPaned *paned = MOO_INTERNAL_PANED (widget);
+
+ gdk_window_show (paned->priv->bin_window);
+
+@@ -1389,7 +1389,7 @@
+ static void
+ moo_paned_unmap (GtkWidget *widget)
+ {
+- MooPaned *paned = MOO_PANED (widget);
++ MooInternalPaned *paned = MOO_INTERNAL_PANED (widget);
+
+ if (paned->priv->handle_window)
+ gdk_window_hide (paned->priv->handle_window);
+@@ -1403,7 +1403,7 @@
+
+
+ static void
+-forall_internals (MooPaned *paned,
++forall_internals (MooInternalPaned *paned,
+ GtkCallback callback,
+ gpointer callback_data)
+ {
+@@ -1421,7 +1421,7 @@
+ GtkCallback callback,
+ gpointer callback_data)
+ {
+- MooPaned *paned = MOO_PANED (container);
++ MooInternalPaned *paned = MOO_INTERNAL_PANED (container);
+ GtkBin *bin = GTK_BIN (container);
+
+ if (!paned->priv->forall_bottom_to_top && include_internals)
+@@ -1439,7 +1439,7 @@
+ moo_paned_expose (GtkWidget *widget,
+ GdkEventExpose *event)
+ {
+- MooPaned *paned = MOO_PANED (widget);
++ MooInternalPaned *paned = MOO_INTERNAL_PANED (widget);
+
+ if (paned->priv->button_box_visible)
+ gtk_container_propagate_expose (GTK_CONTAINER (paned),
+@@ -1468,7 +1468,7 @@
+
+ #if 0
+ /* TODO */
+-static GdkEventExpose *clip_bin_child_event (MooPaned *paned,
++static GdkEventExpose *clip_bin_child_event (MooInternalPaned *paned,
+ GdkEventExpose *event)
+ {
+ GtkAllocation child_alloc;
+@@ -1508,7 +1508,7 @@
+ return;
+ }
+
+- gtk_widget_set_parent_window (child, MOO_PANED(container)->priv->bin_window);
++ gtk_widget_set_parent_window (child, MOO_INTERNAL_PANED(container)->priv->bin_window);
+ gtk_widget_set_parent (child, GTK_WIDGET (bin));
+ bin->child = child;
+ }
+@@ -1518,7 +1518,7 @@
+ moo_paned_remove (GtkContainer *container,
+ GtkWidget *widget)
+ {
+- MooPaned *paned = MOO_PANED (container);
++ MooInternalPaned *paned = MOO_INTERNAL_PANED (container);
+
+ g_return_if_fail (widget == GTK_BIN(paned)->child);
+
+@@ -1527,7 +1527,7 @@
+
+
+ static void
+-draw_handle (MooPaned *paned,
++draw_handle (MooInternalPaned *paned,
+ GdkEventExpose *event)
+ {
+ GtkWidget *widget = GTK_WIDGET (paned);
+@@ -1538,8 +1538,8 @@
+
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ shadow_size = widget->style->xthickness;
+ area.width = paned->priv->handle_size;
+ area.height = widget->allocation.height;
+@@ -1549,8 +1549,8 @@
+ area.width -= shadow_size;
+ orientation = GTK_ORIENTATION_VERTICAL;
+ break;
+- case MOO_PANE_POS_TOP:
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ shadow_size = widget->style->ythickness;
+ area.width = widget->allocation.width;
+ area.height = paned->priv->handle_size;
+@@ -1640,7 +1640,7 @@
+
+
+ static void
+-draw_border (MooPaned *paned,
++draw_border (MooInternalPaned *paned,
+ GdkEventExpose *event)
+ {
+ GdkRectangle rect;
+@@ -1651,11 +1651,11 @@
+
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ rect.x = widget->allocation.width -
+ paned->priv->button_box_size -
+ paned->priv->border_size;
+- case MOO_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
+ rect.y = 0;
+ rect.height = widget->allocation.height;
+ rect.width = paned->priv->border_size;
+@@ -1671,11 +1671,11 @@
+ rect.x);
+ break;
+
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ rect.y = widget->allocation.height -
+ paned->priv->button_box_size -
+ paned->priv->border_size;
+- case MOO_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_TOP:
+ rect.x = 0;
+ rect.width = widget->allocation.width;
+ rect.height = paned->priv->border_size;
+@@ -1695,7 +1695,7 @@
+
+
+ void
+-moo_paned_set_sticky_pane (MooPaned *paned,
++moo_paned_set_sticky_pane (MooInternalPaned *paned,
+ gboolean sticky)
+ {
+ g_return_if_fail (MOO_IS_PANED (paned));
+@@ -1712,8 +1712,8 @@
+ }
+
+
+-MooPane *
+-moo_paned_get_nth_pane (MooPaned *paned,
++MooInternalPane *
++moo_paned_get_nth_pane (MooInternalPaned *paned,
+ guint n)
+ {
+ g_return_val_if_fail (MOO_IS_PANED (paned), NULL);
+@@ -1721,11 +1721,11 @@
+ }
+
+
+-MooPane *
+-moo_paned_get_pane (MooPaned *paned,
++MooInternalPane *
++moo_paned_get_pane (MooInternalPaned *paned,
+ GtkWidget *widget)
+ {
+- MooPane *pane;
++ MooInternalPane *pane;
+
+ g_return_val_if_fail (MOO_IS_PANED (paned), NULL);
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
+@@ -1740,10 +1740,10 @@
+
+
+ int
+-moo_paned_get_pane_num (MooPaned *paned,
++moo_paned_get_pane_num (MooInternalPaned *paned,
+ GtkWidget *widget)
+ {
+- MooPane *pane;
++ MooInternalPane *pane;
+
+ g_return_val_if_fail (MOO_IS_PANED (paned), -1);
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), -1);
+@@ -1761,7 +1761,7 @@
+ moo_paned_motion (GtkWidget *widget,
+ G_GNUC_UNUSED GdkEventMotion *event)
+ {
+- MooPaned *paned = MOO_PANED (widget);
++ MooInternalPaned *paned = MOO_INTERNAL_PANED (widget);
+
+ if (paned->priv->in_drag)
+ {
+@@ -1772,11 +1772,11 @@
+
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ gdk_window_get_pointer (paned->priv->bin_window, &size, NULL, NULL);
+
+- if (paned->priv->pane_position == MOO_PANE_POS_RIGHT)
++ if (paned->priv->pane_position == MOO_INTERNAL_PANE_POS_RIGHT)
+ size = widget->allocation.width - size;
+
+ size -= (paned->priv->drag_start + paned->priv->button_box_size);
+@@ -1785,11 +1785,11 @@
+ paned->priv->handle_size);
+ break;
+
+- case MOO_PANE_POS_TOP:
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ gdk_window_get_pointer (paned->priv->bin_window, NULL, &size, NULL);
+
+- if (paned->priv->pane_position == MOO_PANE_POS_BOTTOM)
++ if (paned->priv->pane_position == MOO_INTERNAL_PANE_POS_BOTTOM)
+ size = widget->allocation.height - size;
+
+ size -= (paned->priv->drag_start + paned->priv->button_box_size);
+@@ -1808,20 +1808,20 @@
+
+
+ static void
+-get_handle_rect (MooPaned *paned,
++get_handle_rect (MooInternalPaned *paned,
+ GdkRectangle *rect)
+ {
+ rect->x = rect->y = 0;
+
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ rect->width = paned->priv->handle_size;
+ rect->height = GTK_WIDGET(paned)->allocation.height;
+ break;
+- case MOO_PANE_POS_TOP:
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ rect->height = paned->priv->handle_size;
+ rect->width = GTK_WIDGET(paned)->allocation.width;
+ break;
+@@ -1833,7 +1833,7 @@
+ moo_paned_enter (GtkWidget *widget,
+ GdkEventCrossing *event)
+ {
+- MooPaned *paned = MOO_PANED (widget);
++ MooInternalPaned *paned = MOO_INTERNAL_PANED (widget);
+ GdkRectangle rect;
+
+ if (event->window == paned->priv->handle_window &&
+@@ -1853,7 +1853,7 @@
+ static gboolean moo_paned_leave (GtkWidget *widget,
+ GdkEventCrossing *event)
+ {
+- MooPaned *paned = MOO_PANED (widget);
++ MooInternalPaned *paned = MOO_INTERNAL_PANED (widget);
+ GdkRectangle rect;
+
+ if (event->window == paned->priv->handle_window &&
+@@ -1874,7 +1874,7 @@
+ moo_paned_button_press (GtkWidget *widget,
+ GdkEventButton *event)
+ {
+- MooPaned *paned = MOO_PANED (widget);
++ MooInternalPaned *paned = MOO_INTERNAL_PANED (widget);
+
+ if (!paned->priv->in_drag &&
+ (event->window == paned->priv->handle_window) &&
+@@ -1895,12 +1895,12 @@
+
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ paned->priv->drag_start = event->x;
+ break;
+- case MOO_PANE_POS_TOP:
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ paned->priv->drag_start = event->y;
+ break;
+ }
+@@ -1916,7 +1916,7 @@
+ moo_paned_button_release (GtkWidget *widget,
+ GdkEventButton *event)
+ {
+- MooPaned *paned = MOO_PANED (widget);
++ MooInternalPaned *paned = MOO_INTERNAL_PANED (widget);
+
+ if (paned->priv->in_drag && (event->button == 1))
+ {
+@@ -1932,7 +1932,7 @@
+
+
+ int
+-moo_paned_get_pane_size (MooPaned *paned)
++moo_paned_get_pane_size (MooInternalPaned *paned)
+ {
+ g_return_val_if_fail (MOO_IS_PANED (paned), 0);
+ return paned->priv->position;
+@@ -1940,7 +1940,7 @@
+
+
+ int
+-moo_paned_get_button_box_size (MooPaned *paned)
++moo_paned_get_button_box_size (MooInternalPaned *paned)
+ {
+ g_return_val_if_fail (MOO_IS_PANED (paned), 0);
+ return paned->priv->button_box_size;
+@@ -1948,7 +1948,7 @@
+
+
+ static void
+-compute_window_offset (MooPaned *paned,
++compute_window_offset (MooInternalPaned *paned,
+ GdkWindow *parent,
+ int *x,
+ int *y)
+@@ -1971,7 +1971,7 @@
+ }
+
+ void
+-_moo_paned_get_button_position (MooPaned *paned,
++_moo_paned_get_button_position (MooInternalPaned *paned,
+ int index,
+ GdkRectangle *rect,
+ GdkWindow *reference)
+@@ -2014,14 +2014,14 @@
+
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ rect->y += rect->height + button_spacing;
+ rect->height = MIN (60, widget->allocation.height - rect->y);
+ rect->height = MAX (rect->height, 10);
+ break;
+- case MOO_PANE_POS_TOP:
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ rect->x += rect->width + button_spacing;
+ rect->width = MIN (60, widget->allocation.width - rect->x);
+ rect->width = MAX (rect->width, 10);
+@@ -2037,15 +2037,15 @@
+
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ rect->x = widget->allocation.width - 30;
+- case MOO_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
+ rect->height = 60;
+ rect->width = 30;
+ break;
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ rect->y = widget->allocation.height - 30;
+- case MOO_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_TOP:
+ rect->width = 60;
+ rect->height = 30;
+ break;
+@@ -2056,14 +2056,14 @@
+ rect->x += x_offset;
+ rect->y += y_offset;
+
+-// if (paned->priv->pane_position == MOO_PANE_POS_BOTTOM)
++// if (paned->priv->pane_position == MOO_INTERNAL_PANE_POS_BOTTOM)
+ // g_print ("%d, %d, %d, %d\n", rect->x, rect->y, rect->width, rect->height);
+
+ g_list_free (buttons);
+ }
+
+ int
+-_moo_paned_get_button (MooPaned *paned,
++_moo_paned_get_button (MooInternalPaned *paned,
+ int x,
+ int y,
+ GdkWindow *reference)
+@@ -2088,13 +2088,13 @@
+
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ if (y < button->allocation.y + button->allocation.height)
+ in_button = TRUE;
+ break;
+- case MOO_PANE_POS_TOP:
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ if (x < button->allocation.x + button->allocation.width)
+ in_button = TRUE;
+ break;
+@@ -2115,7 +2115,7 @@
+ }
+
+ int
+-_moo_paned_get_open_pane_index (MooPaned *paned)
++_moo_paned_get_open_pane_index (MooInternalPaned *paned)
+ {
+ if (paned->priv->current_pane)
+ return pane_index (paned, paned->priv->current_pane);
+@@ -2125,7 +2125,7 @@
+
+
+ static void
+-moo_paned_set_pane_size_real (MooPaned *paned,
++moo_paned_set_pane_size_real (MooInternalPaned *paned,
+ int size)
+ {
+ GtkWidget *widget;
+@@ -2143,14 +2143,14 @@
+
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ size = CLAMP (size, 0,
+ widget->allocation.width - paned->priv->button_box_size -
+ paned->priv->handle_size);
+ break;
+- case MOO_PANE_POS_TOP:
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ size = CLAMP (size, 0,
+ widget->allocation.height - paned->priv->button_box_size -
+ paned->priv->handle_size);
+@@ -2179,18 +2179,18 @@
+
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
+ rect.x += paned->priv->button_box_size;
+ rect.width -= paned->priv->button_box_size;
+ break;
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ rect.width -= paned->priv->button_box_size;
+ break;
+- case MOO_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_TOP:
+ rect.y += paned->priv->button_box_size;
+ rect.height -= paned->priv->button_box_size;
+ break;
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ rect.height -= paned->priv->button_box_size;
+ break;
+ }
+@@ -2200,7 +2200,7 @@
+
+
+ void
+-moo_paned_set_pane_size (MooPaned *paned,
++moo_paned_set_pane_size (MooInternalPaned *paned,
+ int size)
+ {
+ g_return_if_fail (MOO_IS_PANED (paned));
+@@ -2209,7 +2209,7 @@
+
+
+ static void
+-button_box_visible_notify (MooPaned *paned)
++button_box_visible_notify (MooInternalPaned *paned)
+ {
+ gboolean visible = GTK_WIDGET_VISIBLE (paned->button_box);
+
+@@ -2225,8 +2225,8 @@
+
+
+ void
+-_moo_paned_insert_pane (MooPaned *paned,
+- MooPane *pane,
++_moo_paned_insert_pane (MooInternalPaned *paned,
++ MooInternalPane *pane,
+ int position)
+ {
+ GtkWidget *handle, *small_handle;
+@@ -2273,8 +2273,8 @@
+ }
+
+ void
+-_moo_paned_reorder_child (MooPaned *paned,
+- MooPane *pane,
++_moo_paned_reorder_child (MooInternalPaned *paned,
++ MooInternalPane *pane,
+ int position)
+ {
+ g_return_if_fail (MOO_IS_PANED (paned));
+@@ -2289,13 +2289,13 @@
+ }
+
+
+-MooPane *
+-moo_paned_insert_pane (MooPaned *paned,
++MooInternalPane *
++moo_paned_insert_pane (MooInternalPaned *paned,
+ GtkWidget *pane_widget,
+- MooPaneLabel *pane_label,
++ MooInternalPaneLabel *pane_label,
+ int position)
+ {
+- MooPane *pane;
++ MooInternalPane *pane;
+
+ g_return_val_if_fail (MOO_IS_PANED (paned), NULL);
+ g_return_val_if_fail (GTK_IS_WIDGET (pane_widget), NULL);
+@@ -2310,11 +2310,11 @@
+
+
+ gboolean
+-moo_paned_remove_pane (MooPaned *paned,
++moo_paned_remove_pane (MooInternalPaned *paned,
+ GtkWidget *pane_widget)
+ {
+ GtkWidget *handle, *small_handle;
+- MooPane *pane;
++ MooInternalPane *pane;
+ int index;
+
+ g_return_val_if_fail (MOO_IS_PANED (paned), FALSE);
+@@ -2391,7 +2391,7 @@
+
+
+ guint
+-moo_paned_n_panes (MooPaned *paned)
++moo_paned_n_panes (MooInternalPaned *paned)
+ {
+ g_return_val_if_fail (MOO_IS_PANED (paned), 0);
+ return g_slist_length (paned->priv->panes);
+@@ -2421,7 +2421,7 @@
+
+
+ static GtkWidget *
+-find_focus_child (MooPaned *paned)
++find_focus_child (MooInternalPaned *paned)
+ {
+ return find_focus (GTK_BIN(paned)->child);
+ }
+@@ -2431,10 +2431,10 @@
+ moo_paned_set_focus_child (GtkContainer *container,
+ GtkWidget *widget)
+ {
+- MooPaned *paned = MOO_PANED (container);
++ MooInternalPaned *paned = MOO_INTERNAL_PANED (container);
+ FocusPosition new_focus = FOCUS_NONE;
+- MooPane *new_focus_pane = NULL;
+- MooPane *old_focus_pane = paned->priv->focus_pane;
++ MooInternalPane *new_focus_pane = NULL;
++ MooInternalPane *old_focus_pane = paned->priv->focus_pane;
+ GSList *l;
+
+ if (widget)
+@@ -2448,7 +2448,7 @@
+ {
+ for (l = paned->priv->panes; l != NULL; l = l->next)
+ {
+- MooPane *pane = l->data;
++ MooInternalPane *pane = l->data;
+
+ if (widget == _moo_pane_get_frame (pane))
+ {
+@@ -2517,7 +2517,7 @@
+
+
+ static gboolean
+-focus_to_child (MooPaned *paned,
++focus_to_child (MooInternalPaned *paned,
+ GtkDirectionType direction)
+ {
+ return GTK_BIN(paned)->child &&
+@@ -2526,10 +2526,10 @@
+
+
+ static gboolean
+-focus_to_pane (MooPaned *paned,
++focus_to_pane (MooInternalPaned *paned,
+ GtkDirectionType direction)
+ {
+- MooPane *pane = paned->priv->current_pane;
++ MooInternalPane *pane = paned->priv->current_pane;
+
+ if (!pane)
+ return FALSE;
+@@ -2542,7 +2542,7 @@
+
+
+ static gboolean
+-focus_to_button (MooPaned *paned,
++focus_to_button (MooInternalPaned *paned,
+ GtkDirectionType direction)
+ {
+ if (gtk_widget_child_focus (paned->button_box, direction))
+@@ -2558,7 +2558,7 @@
+
+
+ static gboolean
+-moo_left_paned_focus (MooPaned *paned,
++moo_left_paned_focus (MooInternalPaned *paned,
+ GtkDirectionType direction)
+ {
+ switch (paned->priv->focus)
+@@ -2625,7 +2625,7 @@
+
+
+ static gboolean
+-moo_left_paned_tab_focus (MooPaned *paned,
++moo_left_paned_tab_focus (MooInternalPaned *paned,
+ gboolean forward,
+ GtkDirectionType direction)
+ {
+@@ -2669,7 +2669,7 @@
+
+
+ static gboolean
+-moo_top_paned_tab_focus (MooPaned *paned,
++moo_top_paned_tab_focus (MooInternalPaned *paned,
+ GtkDirectionType direction)
+ {
+ switch (paned->priv->focus)
+@@ -2696,7 +2696,7 @@
+ moo_paned_focus (GtkWidget *widget,
+ GtkDirectionType direction)
+ {
+- MooPaned *paned = MOO_PANED (widget);
++ MooInternalPaned *paned = MOO_INTERNAL_PANED (widget);
+ gboolean invert = FALSE;
+ gboolean flip = FALSE;
+
+@@ -2707,31 +2707,31 @@
+ {
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ return moo_left_paned_tab_focus (paned, direction != GTK_DIR_TAB_FORWARD,
+ direction);
+- case MOO_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
+ return moo_left_paned_tab_focus (paned, direction == GTK_DIR_TAB_FORWARD,
+ direction);
+
+- case MOO_PANE_POS_BOTTOM:
+- case MOO_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_TOP:
+ return moo_top_paned_tab_focus (paned, direction);
+ }
+ }
+
+ switch (paned->priv->pane_position)
+ {
+- case MOO_PANE_POS_RIGHT:
++ case MOO_INTERNAL_PANE_POS_RIGHT:
+ invert = TRUE;
+ /* fall through */
+- case MOO_PANE_POS_LEFT:
++ case MOO_INTERNAL_PANE_POS_LEFT:
+ break;
+
+- case MOO_PANE_POS_BOTTOM:
++ case MOO_INTERNAL_PANE_POS_BOTTOM:
+ invert = TRUE;
+ /* fall through */
+- case MOO_PANE_POS_TOP:
++ case MOO_INTERNAL_PANE_POS_TOP:
+ flip = TRUE;
+ break;
+ }
+@@ -2783,8 +2783,8 @@
+
+
+ void
+-moo_paned_present_pane (MooPaned *paned,
+- MooPane *pane)
++moo_paned_present_pane (MooInternalPaned *paned,
++ MooInternalPane *pane)
+ {
+ g_return_if_fail (MOO_IS_PANED (paned));
+ g_return_if_fail (MOO_IS_PANE (pane));
+@@ -2821,10 +2821,10 @@
+
+
+ static void
+-moo_paned_open_pane_real (MooPaned *paned,
++moo_paned_open_pane_real (MooInternalPaned *paned,
+ guint index)
+ {
+- MooPane *pane;
++ MooInternalPane *pane;
+ FocusPosition old_focus;
+
+ g_return_if_fail (index < moo_paned_n_panes (paned));
+@@ -2839,7 +2839,7 @@
+
+ if (paned->priv->current_pane)
+ {
+- MooPane *old_pane = paned->priv->current_pane;
++ MooInternalPane *old_pane = paned->priv->current_pane;
+ paned->priv->current_pane = NULL;
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (_moo_pane_get_button (old_pane)), FALSE);
+ gtk_widget_hide (_moo_pane_get_frame (old_pane));
+@@ -2888,7 +2888,7 @@
+
+ /* XXX invalidate space under the pane */
+ static void
+-moo_paned_hide_pane_real (MooPaned *paned)
++moo_paned_hide_pane_real (MooInternalPaned *paned)
+ {
+ GtkWidget *button;
+ FocusPosition old_focus;
+@@ -2941,9 +2941,9 @@
+
+ static void
+ pane_button_toggled (GtkToggleButton *button,
+- MooPaned *paned)
++ MooInternalPaned *paned)
+ {
+- MooPane *pane;
++ MooInternalPane *pane;
+
+ pane = g_object_get_data (G_OBJECT (button), "moo-pane");
+ g_return_if_fail (MOO_IS_PANE (pane));
+@@ -2961,7 +2961,7 @@
+
+
+ void
+-moo_paned_hide_pane (MooPaned *paned)
++moo_paned_hide_pane (MooInternalPaned *paned)
+ {
+ g_return_if_fail (MOO_IS_PANED (paned));
+ moo_paned_hide_pane_real (paned);
+@@ -2969,8 +2969,8 @@
+
+
+ void
+-moo_paned_open_pane (MooPaned *paned,
+- MooPane *pane)
++moo_paned_open_pane (MooInternalPaned *paned,
++ MooInternalPane *pane)
+ {
+ g_return_if_fail (MOO_IS_PANED (paned));
+ g_return_if_fail (MOO_IS_PANE (pane));
+@@ -2980,23 +2980,23 @@
+
+
+ static int
+-pane_index (MooPaned *paned,
+- MooPane *pane)
++pane_index (MooInternalPaned *paned,
++ MooInternalPane *pane)
+ {
+ return g_slist_index (paned->priv->panes, pane);
+ }
+
+
+-static MooPane *
+-get_nth_pane (MooPaned *paned,
++static MooInternalPane *
++get_nth_pane (MooInternalPaned *paned,
+ guint index_)
+ {
+ return g_slist_nth_data (paned->priv->panes, index_);
+ }
+
+
+-MooPane *
+-moo_paned_get_open_pane (MooPaned *paned)
++MooInternalPane *
++moo_paned_get_open_pane (MooInternalPaned *paned)
+ {
+ g_return_val_if_fail (MOO_IS_PANED (paned), NULL);
+ return paned->priv->current_pane;
+@@ -3004,7 +3004,7 @@
+
+
+ gboolean
+-moo_paned_is_open (MooPaned *paned)
++moo_paned_is_open (MooInternalPaned *paned)
+ {
+ g_return_val_if_fail (MOO_IS_PANED (paned), FALSE);
+ return paned->priv->current_pane != NULL;
+@@ -3019,13 +3019,13 @@
+ if (G_UNLIKELY (!type))
+ {
+ static const GEnumValue values[] = {
+- { MOO_PANE_POS_LEFT, (char*) "MOO_PANE_POS_LEFT", (char*) "left" },
+- { MOO_PANE_POS_RIGHT, (char*) "MOO_PANE_POS_RIGHT", (char*) "right" },
+- { MOO_PANE_POS_TOP, (char*) "MOO_PANE_POS_TOP", (char*) "top" },
+- { MOO_PANE_POS_BOTTOM, (char*) "MOO_PANE_POS_BOTTOM", (char*) "bottom" },
++ { MOO_INTERNAL_PANE_POS_LEFT, (char*) "MOO_INTERNAL_PANE_POS_LEFT", (char*) "left" },
++ { MOO_INTERNAL_PANE_POS_RIGHT, (char*) "MOO_INTERNAL_PANE_POS_RIGHT", (char*) "right" },
++ { MOO_INTERNAL_PANE_POS_TOP, (char*) "MOO_INTERNAL_PANE_POS_TOP", (char*) "top" },
++ { MOO_INTERNAL_PANE_POS_BOTTOM, (char*) "MOO_INTERNAL_PANE_POS_BOTTOM", (char*) "bottom" },
+ { 0, NULL, NULL }
+ };
+- type = g_enum_register_static ("MooPanePosition", values);
++ type = g_enum_register_static ("MooInternalPanePosition", values);
+ }
+
+ return type;
+@@ -3033,7 +3033,7 @@
+
+
+ GSList *
+-moo_paned_list_panes (MooPaned *paned)
++moo_paned_list_panes (MooInternalPaned *paned)
+ {
+ g_return_val_if_fail (MOO_IS_PANED (paned), NULL);
+ return g_slist_copy (paned->priv->panes);
+@@ -3043,7 +3043,7 @@
+ static gboolean
+ handle_button_press (GtkWidget *widget,
+ GdkEventButton *event,
+- MooPaned *paned)
++ MooInternalPaned *paned)
+ {
+ #if 1
+ GdkCursor *cursor;
+@@ -3076,9 +3076,9 @@
+ static gboolean
+ handle_motion (GtkWidget *widget,
+ GdkEventMotion *event,
+- MooPaned *paned)
++ MooInternalPaned *paned)
+ {
+- MooPane *pane;
++ MooInternalPane *pane;
+ GtkWidget *child;
+
+ if (!paned->priv->handle_button_pressed)
+@@ -3108,7 +3108,7 @@
+
+
+ static void
+-finish_handle_drag (MooPaned *paned,
++finish_handle_drag (MooInternalPaned *paned,
+ GtkWidget *child,
+ gboolean drop)
+ {
+@@ -3126,9 +3126,9 @@
+ static gboolean
+ handle_button_release (GtkWidget *widget,
+ G_GNUC_UNUSED GdkEventButton *event,
+- MooPaned *paned)
++ MooInternalPaned *paned)
+ {
+- MooPane *pane;
++ MooInternalPane *pane;
+ GtkWidget *child;
+
+ if (paned->priv->handle_button_pressed)
+@@ -3154,7 +3154,7 @@
+ static gboolean
+ handle_expose (GtkWidget *widget,
+ GdkEventExpose *event,
+- MooPaned *paned)
++ MooInternalPaned *paned)
+ {
+ int height;
+
+@@ -3181,14 +3181,14 @@
+
+ static void
+ handle_realize (G_GNUC_UNUSED GtkWidget *widget,
+- MooPaned *paned)
++ MooInternalPaned *paned)
+ {
+ #if 0
+ GdkCursor *cursor;
+ #endif
+
+ g_return_if_fail (MOO_IS_PANED (paned));
+- g_return_if_fail (MOO_PANED(paned)->priv->bin_window != NULL);
++ g_return_if_fail (MOO_INTERNAL_PANED(paned)->priv->bin_window != NULL);
+
+ if (!paned->priv->enable_handle_drag)
+ return;
+@@ -3203,7 +3203,7 @@
+
+
+ static void
+-moo_paned_set_handle_cursor_type (MooPaned *paned,
++moo_paned_set_handle_cursor_type (MooInternalPaned *paned,
+ GdkCursorType cursor_type,
+ gboolean set)
+ {
+@@ -3215,13 +3215,13 @@
+ }
+
+
+-MooPaneLabel *
++MooInternalPaneLabel *
+ moo_pane_label_new (const char *icon_stock_id,
+ GdkPixbuf *pixbuf,
+ const char *text,
+ const char *window_title)
+ {
+- MooPaneLabel *label = g_new0 (MooPaneLabel, 1);
++ MooInternalPaneLabel *label = g_new0 (MooInternalPaneLabel, 1);
+
+ label->icon_stock_id = g_strdup (icon_stock_id);
+ label->label = g_strdup (text);
+@@ -3234,14 +3234,14 @@
+ }
+
+
+-MooPaneLabel*
+-moo_pane_label_copy (MooPaneLabel *label)
++MooInternalPaneLabel*
++moo_pane_label_copy (MooInternalPaneLabel *label)
+ {
+- MooPaneLabel *copy;
++ MooInternalPaneLabel *copy;
+
+ g_return_val_if_fail (label != NULL, NULL);
+
+- copy = g_new0 (MooPaneLabel, 1);
++ copy = g_new0 (MooInternalPaneLabel, 1);
+
+ copy->icon_stock_id = g_strdup (label->icon_stock_id);
+ copy->label = g_strdup (label->label);
+@@ -3255,7 +3255,7 @@
+
+
+ void
+-moo_pane_label_free (MooPaneLabel *label)
++moo_pane_label_free (MooInternalPaneLabel *label)
+ {
+ if (label)
+ {
+@@ -3272,8 +3272,8 @@
+
+
+ void
+-moo_paned_detach_pane (MooPaned *paned,
+- MooPane *pane)
++moo_paned_detach_pane (MooInternalPaned *paned,
++ MooInternalPane *pane)
+ {
+ g_return_if_fail (MOO_IS_PANED (paned));
+ g_return_if_fail (MOO_IS_PANE (pane));
+@@ -3291,8 +3291,8 @@
+
+
+ void
+-moo_paned_attach_pane (MooPaned *paned,
+- MooPane *pane)
++moo_paned_attach_pane (MooInternalPaned *paned,
++ MooInternalPane *pane)
+ {
+ g_return_if_fail (MOO_IS_PANED (paned));
+ g_return_if_fail (MOO_IS_PANE (pane));
+@@ -3307,7 +3307,7 @@
+
+
+ static void
+-moo_paned_set_enable_detaching (MooPaned *paned,
++moo_paned_set_enable_detaching (MooInternalPaned *paned,
+ gboolean enable)
+ {
+ if (paned->priv->enable_detaching != enable)
+@@ -3319,8 +3319,8 @@
+
+
+ void
+-_moo_paned_attach_pane (MooPaned *paned,
+- MooPane *pane)
++_moo_paned_attach_pane (MooInternalPaned *paned,
++ MooInternalPane *pane)
+ {
+ GtkWidget *focus_child;
+
+@@ -3341,15 +3341,15 @@
+ }
+
+
+-MooPaneParams *
++MooInternalPaneParams *
+ moo_pane_params_new (GdkRectangle *window_position,
+ gboolean detached,
+ gboolean maximized,
+ gboolean keep_on_top)
+ {
+- MooPaneParams *p;
++ MooInternalPaneParams *p;
+
+- p = g_new0 (MooPaneParams, 1);
++ p = g_new0 (MooInternalPaneParams, 1);
+ if (window_position)
+ p->window_position = *window_position;
+ else
+@@ -3362,15 +3362,15 @@
+ }
+
+
+-MooPaneParams*
+-moo_pane_params_copy (MooPaneParams *params)
++MooInternalPaneParams*
++moo_pane_params_copy (MooInternalPaneParams *params)
+ {
+ return g_memdup (params, sizeof *params);
+ }
+
+
+ void
+-moo_pane_params_free (MooPaneParams *params)
++moo_pane_params_free (MooInternalPaneParams *params)
+ {
+ g_free (params);
+ }
+@@ -3382,7 +3382,7 @@
+ static GType type = 0;
+
+ if (G_UNLIKELY (!type))
+- type = g_boxed_type_register_static ("MooPaneLabel",
++ type = g_boxed_type_register_static ("MooInternalPaneLabel",
+ (GBoxedCopyFunc) moo_pane_label_copy,
+ (GBoxedFreeFunc) moo_pane_label_free);
+
+@@ -3396,7 +3396,7 @@
+ static GType type = 0;
+
+ if (G_UNLIKELY (!type))
+- type = g_boxed_type_register_static ("MooPaneParams",
++ type = g_boxed_type_register_static ("MooInternalPaneParams",
+ (GBoxedCopyFunc) moo_pane_params_copy,
+ (GBoxedFreeFunc) moo_pane_params_free);
+
+@@ -3417,7 +3417,7 @@
+ static int delta = 5;
+ int add = 0;
+ guint mask = ACCEL_MODS_MASK;
+- MooPaned *paned = MOO_PANED (widget);
++ MooInternalPaned *paned = MOO_INTERNAL_PANED (widget);
+
+ if (paned->priv->handle_in_drag &&
+ event->keyval == GDK_Escape)
+@@ -3432,30 +3432,30 @@
+ {
+ case GDK_Up:
+ case GDK_KP_Up:
+- if (paned->priv->pane_position == MOO_PANE_POS_TOP)
++ if (paned->priv->pane_position == MOO_INTERNAL_PANE_POS_TOP)
+ add = -delta;
+- else if (paned->priv->pane_position == MOO_PANE_POS_BOTTOM)
++ else if (paned->priv->pane_position == MOO_INTERNAL_PANE_POS_BOTTOM)
+ add = delta;
+ break;
+ case GDK_Down:
+ case GDK_KP_Down:
+- if (paned->priv->pane_position == MOO_PANE_POS_TOP)
++ if (paned->priv->pane_position == MOO_INTERNAL_PANE_POS_TOP)
+ add = delta;
+- else if (paned->priv->pane_position == MOO_PANE_POS_BOTTOM)
++ else if (paned->priv->pane_position == MOO_INTERNAL_PANE_POS_BOTTOM)
+ add = -delta;
+ break;
+ case GDK_Left:
+ case GDK_KP_Left:
+- if (paned->priv->pane_position == MOO_PANE_POS_LEFT)
++ if (paned->priv->pane_position == MOO_INTERNAL_PANE_POS_LEFT)
+ add = -delta;
+- else if (paned->priv->pane_position == MOO_PANE_POS_RIGHT)
++ else if (paned->priv->pane_position == MOO_INTERNAL_PANE_POS_RIGHT)
+ add = delta;
+ break;
+ case GDK_Right:
+ case GDK_KP_Right:
+- if (paned->priv->pane_position == MOO_PANE_POS_LEFT)
++ if (paned->priv->pane_position == MOO_INTERNAL_PANE_POS_LEFT)
+ add = delta;
+- else if (paned->priv->pane_position == MOO_PANE_POS_RIGHT)
++ else if (paned->priv->pane_position == MOO_INTERNAL_PANE_POS_RIGHT)
+ add = -delta;
+ break;
+ }
+diff -ru pida.orig/contrib/moo/moopaned.defs pida/contrib/moo/moopaned.defs
+--- pida.orig/contrib/moo/moopaned.defs 2011-04-24 12:08:25.000000000 -0400
++++ pida/contrib/moo/moopaned.defs 2011-04-24 12:20:57.000000000 -0400
+@@ -1,42 +1,42 @@
+ ;; -*- scheme -*-
+
+-(define-object BigPaned
++(define-object InternalBigPaned
+ (in-module "Moo")
+ (parent "GtkFrame")
+- (c-name "MooBigPaned")
+- (gtype-id "MOO_TYPE_BIG_PANED")
++ (c-name "MooInternalBigPaned")
++ (gtype-id "MOO_TYPE_INTERNAL_BIG_PANED")
+ )
+
+-(define-object Paned
++(define-object InternalPaned
+ (in-module "Moo")
+ (parent "GtkBin")
+- (c-name "MooPaned")
+- (gtype-id "MOO_TYPE_PANED")
++ (c-name "MooInternalPaned")
++ (gtype-id "MOO_TYPE_INTERNAL_PANED")
+ (fields
+ '("GtkWidget*" "button_box")
+ )
+ )
+
+-(define-object Pane
++(define-object InternalPane
+ (in-module "Moo")
+ (parent "GtkObject")
+- (c-name "MooPane")
+- (gtype-id "MOO_TYPE_PANE")
++ (c-name "MooInternalPane")
++ (gtype-id "MOO_TYPE_INTERNAL_PANE")
+ )
+
+-(define-boxed PaneLabel
++(define-boxed InternalPaneLabel
+ (in-module "Moo")
+- (c-name "MooPaneLabel")
+- (gtype-id "MOO_TYPE_PANE_LABEL")
++ (c-name "MooInternalPaneLabel")
++ (gtype-id "MOO_TYPE_INTERNAL_PANE_LABEL")
+ (copy-func "moo_pane_label_copy")
+ (release-func "moo_pane_label_free")
+ (docstring "PaneLabel(icon_stock_id=None, icon_pixbuf=None, icon_widget=None, label_text=None, window_title=None).")
+ )
+
+-(define-boxed PaneParams
++(define-boxed InternalPaneParams
+ (in-module "Moo")
+- (c-name "MooPaneParams")
+- (gtype-id "MOO_TYPE_PANE_PARAMS")
++ (c-name "MooInternalPaneParams")
++ (gtype-id "MOO_TYPE_INTERNAL_PANE_PARAMS")
+ (copy-func "moo_pane_params_copy")
+ (release-func "moo_pane_params_free")
+ (fields
+@@ -51,33 +51,33 @@
+ "means the position is not set.")
+ )
+
+-(define-enum PanePosition
++(define-enum InternalPanePosition
+ (in-module "Moo")
+- (c-name "MooPanePosition")
+- (gtype-id "MOO_TYPE_PANE_POSITION")
++ (c-name "MooInternalPanePosition")
++ (gtype-id "MOO_TYPE_INTERNAL_PANE_POSITION")
+ )
+
+ ;; From ./moo/mooutils/moobigpaned.h
+
+ (define-function moo_big_paned_new
+ (c-name "moo_big_paned_new")
+- (is-constructor-of "MooBigPaned")
++ (is-constructor-of "MooInternalBigPaned")
+ (return-type "GtkWidget*")
+ )
+
+ (define-method find_pane
+- (of-object "MooBigPaned")
++ (of-object "MooInternalBigPaned")
+ (c-name "moo_big_paned_find_pane")
+- (return-type "MooPane*")
++ (return-type "MooInternalPane*")
+ (parameters
+ '("GtkWidget*" "pane_widget")
+- '("MooPaned**" "child_paned")
++ '("MooInternalPaned**" "child_paned")
+ )
+ (docstring "find_pane(pane_widget) -> (pane, paned) or None.")
+ )
+
+ ; (define-method set_pane_order
+-; (of-object "MooBigPaned")
++; (of-object "MooInternalBigPaned")
+ ; (c-name "moo_big_paned_set_pane_order")
+ ; (return-type "none")
+ ; (parameters
+@@ -86,7 +86,7 @@
+ ; )
+
+ (define-method add_child
+- (of-object "MooBigPaned")
++ (of-object "MooInternalBigPaned")
+ (c-name "moo_big_paned_add_child")
+ (return-type "none")
+ (parameters
+@@ -98,7 +98,7 @@
+ )
+
+ (define-method remove_child
+- (of-object "MooBigPaned")
++ (of-object "MooInternalBigPaned")
+ (c-name "moo_big_paned_remove_child")
+ (return-type "none")
+ (docstring "remove_child() -> None.\n"
+@@ -107,7 +107,7 @@
+ )
+
+ (define-method get_child
+- (of-object "MooBigPaned")
++ (of-object "MooInternalBigPaned")
+ (c-name "moo_big_paned_get_child")
+ (return-type "GtkWidget*")
+ (docstring "get_child() -> gtk.Widget.\n"
+@@ -116,11 +116,11 @@
+ )
+
+ (define-method get_paned
+- (of-object "MooBigPaned")
++ (of-object "MooInternalBigPaned")
+ (c-name "moo_big_paned_get_paned")
+- (return-type "MooPaned*")
++ (return-type "MooInternalPaned*")
+ (parameters
+- '("MooPanePosition" "position")
++ '("MooInternalPanePosition" "position")
+ )
+ (docstring "get_paned(pos) -> Paned.\n"
+ "\n"
+@@ -128,14 +128,14 @@
+ )
+
+ (define-method insert_pane
+- (of-object "MooBigPaned")
++ (of-object "MooInternalBigPaned")
+ (c-name "moo_big_paned_insert_pane")
+- (return-type "MooPane*")
++ (return-type "MooInternalPane*")
+ (parameters
+ '("GtkWidget*" "pane_widget")
+ '("const-char*" "pane_id" (null-ok))
+- '("MooPaneLabel*" "pane_label")
+- '("MooPanePosition" "position")
++ '("MooInternalPaneLabel*" "pane_label")
++ '("MooInternalPanePosition" "position")
+ '("int" "index_")
+ )
+ (docstring "insert_pane(pane_widget, pane_id, pane_label, position, index) -> Pane.\n"
+@@ -144,7 +144,7 @@
+ )
+
+ (define-method remove_pane
+- (of-object "MooBigPaned")
++ (of-object "MooInternalBigPaned")
+ (c-name "moo_big_paned_remove_pane")
+ (return-type "gboolean")
+ (parameters
+@@ -156,9 +156,9 @@
+ )
+
+ (define-method lookup_pane
+- (of-object "MooBigPaned")
++ (of-object "MooInternalBigPaned")
+ (c-name "moo_big_paned_lookup_pane")
+- (return-type "MooPane*")
++ (return-type "MooInternalPane*")
+ (parameters
+ '("const-char*" "pane_id")
+ )
+@@ -168,7 +168,7 @@
+ )
+
+ (define-method set_config
+- (of-object "MooBigPaned")
++ (of-object "MooInternalBigPaned")
+ (c-name "moo_big_paned_set_config")
+ (parameters
+ '("const-char*" "config")
+@@ -181,7 +181,7 @@
+ )
+
+ (define-method get_config
+- (of-object "MooBigPaned")
++ (of-object "MooInternalBigPaned")
+ (c-name "moo_big_paned_get_config")
+ (return-type "char*")
+ (docstring "get_config(config) -> str.\n"
+@@ -191,18 +191,18 @@
+ )
+
+ (define-method get_pane
+- (of-object "MooBigPaned")
++ (of-object "MooInternalBigPaned")
+ (c-name "moo_big_paned_get_pane")
+ (return-type "GtkWidget*")
+ (parameters
+- '("MooPanePosition" "position")
++ '("MooInternalPanePosition" "position")
+ '("int" "index_")
+ )
+ (docstring "get_pane(position, index) -> gtk.Widget.")
+ )
+
+ (define-method open_pane
+- (of-object "MooBigPaned")
++ (of-object "MooInternalBigPaned")
+ (c-name "moo_big_paned_open_pane")
+ (return-type "none")
+ (parameters
+@@ -212,7 +212,7 @@
+ )
+
+ (define-method hide_pane
+- (of-object "MooBigPaned")
++ (of-object "MooInternalBigPaned")
+ (c-name "moo_big_paned_hide_pane")
+ (return-type "none")
+ (parameters
+@@ -222,7 +222,7 @@
+ )
+
+ (define-method present_pane
+- (of-object "MooBigPaned")
++ (of-object "MooInternalBigPaned")
+ (c-name "moo_big_paned_present_pane")
+ (return-type "none")
+ (parameters
+@@ -234,7 +234,7 @@
+ )
+
+ (define-method attach_pane
+- (of-object "MooBigPaned")
++ (of-object "MooInternalBigPaned")
+ (c-name "moo_big_paned_attach_pane")
+ (return-type "none")
+ (parameters
+@@ -244,7 +244,7 @@
+ )
+
+ (define-method detach_pane
+- (of-object "MooBigPaned")
++ (of-object "MooInternalBigPaned")
+ (c-name "moo_big_paned_detach_pane")
+ (return-type "none")
+ (parameters
+@@ -259,7 +259,7 @@
+ (ifndef pygtk-2.6
+ (define-function moo_paned_new
+ (c-name "moo_paned_new")
+- (is-constructor-of "MooPaned")
++ (is-constructor-of "MooInternalPaned")
+ (return-type "GtkWidget*")
+ (properties
+ '("pane_position" (optional))
+@@ -268,18 +268,18 @@
+ )
+
+ (define-method insert_pane
+- (of-object "MooPaned")
++ (of-object "MooInternalPaned")
+ (c-name "moo_paned_insert_pane")
+- (return-type "MooPane*")
++ (return-type "MooInternalPane*")
+ (parameters
+ '("GtkWidget*" "pane_widget")
+- '("MooPaneLabel*" "pane_label")
++ '("MooInternalPaneLabel*" "pane_label")
+ '("int" "position")
+ )
+ )
+
+ (define-method remove_pane
+- (of-object "MooPaned")
++ (of-object "MooInternalPaned")
+ (c-name "moo_paned_remove_pane")
+ (return-type "gboolean")
+ (parameters
+@@ -288,28 +288,28 @@
+ )
+
+ (define-method n_panes
+- (of-object "MooPaned")
++ (of-object "MooInternalPaned")
+ (c-name "moo_paned_n_panes")
+ (return-type "guint")
+ )
+
+ (define-method list_panes
+- (of-object "MooPaned")
++ (of-object "MooInternalPaned")
+ (c-name "moo_paned_list_panes")
+ (return-type "no-ref-object-slist")
+ )
+
+ (define-method get_nth_pane
+- (of-object "MooPaned")
++ (of-object "MooInternalPaned")
+ (c-name "moo_paned_get_nth_pane")
+- (return-type "MooPane*")
++ (return-type "MooInternalPane*")
+ (parameters
+ '("guint" "n")
+ )
+ )
+
+ (define-method get_pane_num
+- (of-object "MooPaned")
++ (of-object "MooInternalPaned")
+ (c-name "moo_paned_get_pane_num")
+ (return-type "int")
+ (parameters
+@@ -318,7 +318,7 @@
+ )
+
+ (define-method set_sticky_pane
+- (of-object "MooPaned")
++ (of-object "MooInternalPaned")
+ (c-name "moo_paned_set_sticky_pane")
+ (return-type "none")
+ (parameters
+@@ -327,7 +327,7 @@
+ )
+
+ (define-method set_pane_size
+- (of-object "MooPaned")
++ (of-object "MooInternalPaned")
+ (c-name "moo_paned_set_pane_size")
+ (return-type "none")
+ (parameters
+@@ -336,75 +336,75 @@
+ )
+
+ (define-method get_pane_size
+- (of-object "MooPaned")
++ (of-object "MooInternalPaned")
+ (c-name "moo_paned_get_pane_size")
+ (return-type "int")
+ )
+
+ (define-method get_button_box_size
+- (of-object "MooPaned")
++ (of-object "MooInternalPaned")
+ (c-name "moo_paned_get_button_box_size")
+ (return-type "int")
+ )
+
+ (define-method get_open_pane
+- (of-object "MooPaned")
++ (of-object "MooInternalPaned")
+ (c-name "moo_paned_get_open_pane")
+- (return-type "MooPane*")
++ (return-type "MooInternalPane*")
+ )
+
+ (define-method is_open
+- (of-object "MooPaned")
++ (of-object "MooInternalPaned")
+ (c-name "moo_paned_is_open")
+ (return-type "gboolean")
+ )
+
+ (define-method open_pane
+- (of-object "MooPaned")
++ (of-object "MooInternalPaned")
+ (c-name "moo_paned_open_pane")
+ (return-type "none")
+ (parameters
+- '("MooPane*" "pane")
++ '("MooInternalPane*" "pane")
+ )
+ )
+
+ (define-method present_pane
+- (of-object "MooPaned")
++ (of-object "MooInternalPaned")
+ (c-name "moo_paned_present_pane")
+ (return-type "none")
+ (parameters
+- '("MooPane*" "pane")
++ '("MooInternalPane*" "pane")
+ )
+ )
+
+ (define-method hide_pane
+- (of-object "MooPaned")
++ (of-object "MooInternalPaned")
+ (c-name "moo_paned_hide_pane")
+ (return-type "none")
+ )
+
+ (define-method detach_pane
+- (of-object "MooPaned")
++ (of-object "MooInternalPaned")
+ (c-name "moo_paned_detach_pane")
+ (return-type "none")
+ (parameters
+- '("MooPane*" "pane")
++ '("MooInternalPane*" "pane")
+ )
+ )
+
+ (define-method attach_pane
+- (of-object "MooPaned")
++ (of-object "MooInternalPaned")
+ (c-name "moo_paned_attach_pane")
+ (return-type "none")
+ (parameters
+- '("MooPane*" "pane")
++ '("MooInternalPane*" "pane")
+ )
+ )
+
+ (define-function moo_pane_params_new
+ (c-name "moo_pane_params_new")
+- (is-constructor-of "MooPaneParams")
+- (return-type "MooPaneParams*")
++ (is-constructor-of "MooInternalPaneParams")
++ (return-type "MooInternalPaneParams*")
+ (parameters
+ '("GdkRectangle*" "window_position" (null-ok) (default "NULL"))
+ '("gboolean" "detached" (null-ok) (default "FALSE"))
+@@ -414,15 +414,15 @@
+ )
+
+ (define-method copy
+- (of-object "MooPaneParams")
++ (of-object "MooInternalPaneParams")
+ (c-name "moo_pane_params_copy")
+- (return-type "MooPaneParams*")
++ (return-type "MooInternalPaneParams*")
+ )
+
+ (define-function moo_pane_label_new
+ (c-name "moo_pane_label_new")
+- (is-constructor-of "MooPaneLabel")
+- (return-type "MooPaneLabel*")
++ (is-constructor-of "MooInternalPaneLabel")
++ (return-type "MooInternalPaneLabel*")
+ (parameters
+ '("const-char*" "icon_name" (null-ok) (default "NULL"))
+ '("GdkPixbuf*" "icon_pixbuf" (null-ok) (default "NULL"))
+@@ -432,13 +432,13 @@
+ )
+
+ (define-method copy
+- (of-object "MooPaneLabel")
++ (of-object "MooInternalPaneLabel")
+ (c-name "moo_pane_label_copy")
+- (return-type "MooPaneLabel*")
++ (return-type "MooInternalPaneLabel*")
+ )
+
+ (define-method free
+- (of-object "MooPaneLabel")
++ (of-object "MooInternalPaneLabel")
+ (c-name "moo_pane_label_free")
+ (return-type "none")
+ )
+@@ -446,22 +446,22 @@
+ ;; From /home/muntyan/projects/moo/moo/mooutils/moopane.h
+
+ (define-method set_label
+- (of-object "MooPane")
++ (of-object "MooInternalPane")
+ (c-name "moo_pane_set_label")
+ (return-type "none")
+ (parameters
+- '("MooPaneLabel*" "label")
++ '("MooInternalPaneLabel*" "label")
+ )
+ )
+
+ (define-method get_label
+- (of-object "MooPane")
++ (of-object "MooInternalPane")
+ (c-name "moo_pane_get_label")
+- (return-type "MooPaneLabel*")
++ (return-type "MooInternalPaneLabel*")
+ )
+
+ (define-method set_frame_markup
+- (of-object "MooPane")
++ (of-object "MooInternalPane")
+ (c-name "moo_pane_set_frame_markup")
+ (return-type "none")
+ (parameters
+@@ -470,7 +470,7 @@
+ )
+
+ (define-method set_frame_text
+- (of-object "MooPane")
++ (of-object "MooInternalPane")
+ (c-name "moo_pane_set_frame_text")
+ (return-type "none")
+ (parameters
+@@ -479,22 +479,22 @@
+ )
+
+ (define-method set_params
+- (of-object "MooPane")
++ (of-object "MooInternalPane")
+ (c-name "moo_pane_set_params")
+ (return-type "none")
+ (parameters
+- '("MooPaneParams*" "params")
++ '("MooInternalPaneParams*" "params")
+ )
+ )
+
+ (define-method get_params
+- (of-object "MooPane")
++ (of-object "MooInternalPane")
+ (c-name "moo_pane_get_params")
+- (return-type "MooPaneParams*")
++ (return-type "MooInternalPaneParams*")
+ )
+
+ (define-method set_detachable
+- (of-object "MooPane")
++ (of-object "MooInternalPane")
+ (c-name "moo_pane_set_detachable")
+ (return-type "none")
+ (parameters
+@@ -503,13 +503,13 @@
+ )
+
+ (define-method get_detachable
+- (of-object "MooPane")
++ (of-object "MooInternalPane")
+ (c-name "moo_pane_get_detachable")
+ (return-type "gboolean")
+ )
+
+ (define-method set_removable
+- (of-object "MooPane")
++ (of-object "MooInternalPane")
+ (c-name "moo_pane_set_removable")
+ (return-type "none")
+ (parameters
+@@ -518,43 +518,43 @@
+ )
+
+ (define-method get_removable
+- (of-object "MooPane")
++ (of-object "MooInternalPane")
+ (c-name "moo_pane_get_removable")
+ (return-type "gboolean")
+ )
+
+ (define-method get_child
+- (of-object "MooPane")
++ (of-object "MooInternalPane")
+ (c-name "moo_pane_get_child")
+ (return-type "GtkWidget*")
+ )
+
+ (define-method get_index
+- (of-object "MooPane")
++ (of-object "MooInternalPane")
+ (c-name "moo_pane_get_index")
+ (return-type "int")
+ )
+
+ (define-method open
+- (of-object "MooPane")
++ (of-object "MooInternalPane")
+ (c-name "moo_pane_open")
+ (return-type "none")
+ )
+
+ (define-method present
+- (of-object "MooPane")
++ (of-object "MooInternalPane")
+ (c-name "moo_pane_present")
+ (return-type "none")
+ )
+
+ (define-method attach
+- (of-object "MooPane")
++ (of-object "MooInternalPane")
+ (c-name "moo_pane_attach")
+ (return-type "none")
+ )
+
+ (define-method detach
+- (of-object "MooPane")
++ (of-object "MooInternalPane")
+ (c-name "moo_pane_detach")
+ (return-type "none")
+ )
+diff -ru pida.orig/contrib/moo/moopaned.h pida/contrib/moo/moopaned.h
+--- pida.orig/contrib/moo/moopaned.h 2011-04-24 12:08:25.000000000 -0400
++++ pida/contrib/moo/moopaned.h 2011-04-24 12:28:29.000000000 -0400
+@@ -13,8 +13,8 @@
+ * License along with medit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+-#ifndef MOO_PANED_H
+-#define MOO_PANED_H
++#ifndef MOO_INTERNAL_PANED_H
++#define MOO_INTERNAL_PANED_H
+
+ #include "moopane.h"
+ #include <gtk/gtkbin.h>
+@@ -22,49 +22,49 @@
+ G_BEGIN_DECLS
+
+
+-#define MOO_TYPE_PANED (moo_paned_get_type ())
+-#define MOO_PANED(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), MOO_TYPE_PANED, MooPaned))
+-#define MOO_PANED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MOO_TYPE_PANED, MooPanedClass))
+-#define MOO_IS_PANED(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), MOO_TYPE_PANED))
+-#define MOO_IS_PANED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MOO_TYPE_PANED))
+-#define MOO_PANED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MOO_TYPE_PANED, MooPanedClass))
+-
+-#define MOO_TYPE_PANE_POSITION (moo_pane_position_get_type ())
+-
+-typedef struct _MooPaned MooPaned;
+-typedef struct _MooPanedPrivate MooPanedPrivate;
+-typedef struct _MooPanedClass MooPanedClass;
++#define MOO_TYPE_INTERNAL_PANED (moo_paned_get_type ())
++#define MOO_INTERNAL_PANED(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), MOO_TYPE_INTERNAL_PANED, MooInternalPaned))
++#define MOO_INTERNAL_PANED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MOO_TYPE_INTERNAL_PANED, MooInternalPanedClass))
++#define MOO_IS_PANED(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), MOO_TYPE_INTERNAL_PANED))
++#define MOO_IS_PANED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MOO_TYPE_INTERNAL_PANED))
++#define MOO_INTERNAL_PANED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MOO_TYPE_INTERNAL_PANED, MooInternalPanedClass))
++
++#define MOO_TYPE_INTERNAL_PANE_POSITION (moo_pane_position_get_type ())
++
++typedef struct _MooInternalPaned MooInternalPaned;
++typedef struct _MooInternalPanedPrivate MooInternalPanedPrivate;
++typedef struct _MooInternalPanedClass MooInternalPanedClass;
+
+ typedef enum {
+- MOO_PANE_POS_LEFT = 0,
+- MOO_PANE_POS_RIGHT,
+- MOO_PANE_POS_TOP,
+- MOO_PANE_POS_BOTTOM
+-} MooPanePosition;
++ MOO_INTERNAL_PANE_POS_LEFT = 0,
++ MOO_INTERNAL_PANE_POS_RIGHT,
++ MOO_INTERNAL_PANE_POS_TOP,
++ MOO_INTERNAL_PANE_POS_BOTTOM
++} MooInternalPanePosition;
+
+-struct _MooPaned
++struct _MooInternalPaned
+ {
+ GtkBin bin;
+ GtkWidget *button_box;
+- MooPanedPrivate *priv;
++ MooInternalPanedPrivate *priv;
+ };
+
+-struct _MooPanedClass
++struct _MooInternalPanedClass
+ {
+ GtkBinClass bin_class;
+
+- void (*set_pane_size) (MooPaned *paned,
++ void (*set_pane_size) (MooInternalPaned *paned,
+ int size);
+
+- void (*handle_drag_start) (MooPaned *paned,
++ void (*handle_drag_start) (MooInternalPaned *paned,
+ GtkWidget *pane_widget);
+- void (*handle_drag_motion) (MooPaned *paned,
++ void (*handle_drag_motion) (MooInternalPaned *paned,
+ GtkWidget *pane_widget);
+- void (*handle_drag_end) (MooPaned *paned,
++ void (*handle_drag_end) (MooInternalPaned *paned,
+ GtkWidget *pane_widget,
+ gboolean drop);
+
+- void (*pane_params_changed) (MooPaned *paned,
++ void (*pane_params_changed) (MooInternalPaned *paned,
+ guint index_);
+ };
+
+@@ -72,65 +72,65 @@
+ GType moo_paned_get_type (void) G_GNUC_CONST;
+ GType moo_pane_position_get_type (void) G_GNUC_CONST;
+
+-GtkWidget *moo_paned_new (MooPanePosition pane_position);
++GtkWidget *moo_paned_new (MooInternalPanePosition pane_position);
+
+-MooPane *moo_paned_insert_pane (MooPaned *paned,
++MooInternalPane *moo_paned_insert_pane (MooInternalPaned *paned,
+ GtkWidget *pane_widget,
+- MooPaneLabel *pane_label,
++ MooInternalPaneLabel *pane_label,
+ int position);
+-gboolean moo_paned_remove_pane (MooPaned *paned,
++gboolean moo_paned_remove_pane (MooInternalPaned *paned,
+ GtkWidget *pane_widget);
+
+-guint moo_paned_n_panes (MooPaned *paned);
+-GSList *moo_paned_list_panes (MooPaned *paned);
+-MooPane *moo_paned_get_nth_pane (MooPaned *paned,
++guint moo_paned_n_panes (MooInternalPaned *paned);
++GSList *moo_paned_list_panes (MooInternalPaned *paned);
++MooInternalPane *moo_paned_get_nth_pane (MooInternalPaned *paned,
+ guint n);
+-int moo_paned_get_pane_num (MooPaned *paned,
++int moo_paned_get_pane_num (MooInternalPaned *paned,
+ GtkWidget *widget);
+-MooPane *moo_paned_get_pane (MooPaned *paned,
++MooInternalPane *moo_paned_get_pane (MooInternalPaned *paned,
+ GtkWidget *widget);
+
+-void moo_paned_set_sticky_pane (MooPaned *paned,
++void moo_paned_set_sticky_pane (MooInternalPaned *paned,
+ gboolean sticky);
+
+-void moo_paned_set_pane_size (MooPaned *paned,
++void moo_paned_set_pane_size (MooInternalPaned *paned,
+ int size);
+-int moo_paned_get_pane_size (MooPaned *paned);
+-int moo_paned_get_button_box_size (MooPaned *paned);
++int moo_paned_get_pane_size (MooInternalPaned *paned);
++int moo_paned_get_button_box_size (MooInternalPaned *paned);
+
+-MooPane *moo_paned_get_open_pane (MooPaned *paned);
+-gboolean moo_paned_is_open (MooPaned *paned);
++MooInternalPane *moo_paned_get_open_pane (MooInternalPaned *paned);
++gboolean moo_paned_is_open (MooInternalPaned *paned);
+
+-void moo_paned_open_pane (MooPaned *paned,
+- MooPane *pane);
+-void moo_paned_present_pane (MooPaned *paned,
+- MooPane *pane);
+-void moo_paned_hide_pane (MooPaned *paned);
+-void moo_paned_attach_pane (MooPaned *paned,
+- MooPane *pane);
+-void moo_paned_detach_pane (MooPaned *paned,
+- MooPane *pane);
+-
+-MooPanePosition _moo_paned_get_position (MooPaned *paned);
+-void _moo_paned_attach_pane (MooPaned *paned,
+- MooPane *pane);
+-void _moo_paned_insert_pane (MooPaned *paned,
+- MooPane *pane,
++void moo_paned_open_pane (MooInternalPaned *paned,
++ MooInternalPane *pane);
++void moo_paned_present_pane (MooInternalPaned *paned,
++ MooInternalPane *pane);
++void moo_paned_hide_pane (MooInternalPaned *paned);
++void moo_paned_attach_pane (MooInternalPaned *paned,
++ MooInternalPane *pane);
++void moo_paned_detach_pane (MooInternalPaned *paned,
++ MooInternalPane *pane);
++
++MooInternalPanePosition _moo_paned_get_position (MooInternalPaned *paned);
++void _moo_paned_attach_pane (MooInternalPaned *paned,
++ MooInternalPane *pane);
++void _moo_paned_insert_pane (MooInternalPaned *paned,
++ MooInternalPane *pane,
+ int position);
+-void _moo_paned_reorder_child (MooPaned *paned,
+- MooPane *pane,
++void _moo_paned_reorder_child (MooInternalPaned *paned,
++ MooInternalPane *pane,
+ int position);
+-void _moo_paned_get_button_position (MooPaned *paned,
++void _moo_paned_get_button_position (MooInternalPaned *paned,
+ int index,
+ GdkRectangle *rect,
+ GdkWindow *reference);
+-int _moo_paned_get_button (MooPaned *paned,
++int _moo_paned_get_button (MooInternalPaned *paned,
+ int x,
+ int y,
+ GdkWindow *reference);
+-int _moo_paned_get_open_pane_index (MooPaned *paned);
++int _moo_paned_get_open_pane_index (MooInternalPaned *paned);
+
+
+ G_END_DECLS
+
+-#endif /* MOO_PANED_H */
++#endif /* MOO_INTERNAL_PANED_H */
+diff -ru pida.orig/contrib/moo/moopaned.override pida/contrib/moo/moopaned.override
+--- pida.orig/contrib/moo/moopaned.override 2011-04-24 12:08:25.000000000 -0400
++++ pida/contrib/moo/moopaned.override 2011-04-24 12:19:48.000000000 -0400
+@@ -20,16 +20,16 @@
+ {
+ static char *kwlist[] = { "pane_widget", NULL };
+ PyGObject *widget;
+- MooPaned *child;
++ MooInternalPaned *child;
+ PyObject *ret;
+- MooPane *pane;
++ MooInternalPane *pane;
+
+ if (!PyArg_ParseTupleAndKeywords (args, kwargs,
+- "O!:MooBigPaned.find_pane", kwlist,
++ "O!:MooInternalBigPaned.find_pane", kwlist,
+ &PyGtkWidget_Type, &widget))
+ return NULL;
+
+- pane = moo_big_paned_find_pane (MOO_BIG_PANED (self->obj), GTK_WIDGET (widget->obj), &child);
++ pane = moo_big_paned_find_pane (MOO_INTERNAL_BIG_PANED (self->obj), GTK_WIDGET (widget->obj), &child);
+
+ if (!pane)
+ {
diff --git a/nodrm.patch b/nodrm.patch
new file mode 100644
index 000000000000..a78c26433979
--- /dev/null
+++ b/nodrm.patch
@@ -0,0 +1,13 @@
+--- pida-build/pida/core/application.py.orig 2010-04-25 16:15:17.000000000 -0400
++++ pida-build/pida/core/application.py 2010-04-25 16:15:40.000000000 -0400
+@@ -59,8 +59,8 @@
+
+
+ # Prevent PIDA from being run as root.
+-if os.getuid() == 0:
+- die_gui("Pida should not be run as root", "Pida is dying")
++#if os.getuid() == 0:
++# die_gui("Pida should not be run as root", "Pida is dying")
+
+ # This can test if PIDA is installed
+ # also we have to import pdbus here so it gets initialized very early
diff --git a/pida.desktop b/pida.desktop
new file mode 100644
index 000000000000..38799f1bf6f2
--- /dev/null
+++ b/pida.desktop
@@ -0,0 +1,9 @@
+[Desktop Entry]
+Name=Pida
+Comment=Python Integrated Development Application
+Icon=pida
+Exec=pida %F
+Terminal=false
+Type=Application
+Encoding=UTF-8
+Categories=Application;Development;IDE;
diff --git a/pida.install b/pida.install
new file mode 100644
index 000000000000..e9c1f3407395
--- /dev/null
+++ b/pida.install
@@ -0,0 +1,13 @@
+post_install() {
+ cat << EOF
+==> Install either medit-full, gvim or emacs to act as the editor in PIDA
+EOF
+}
+
+post_upgrade() {
+ post_install $1
+}
+
+op=$1
+shift
+$op $*