# Bazaar merge directive format 2 (Bazaar 0.90)
# revision_id: proycon@anaproy.nl-20120922150605-srvpzc61j51tywd4
# target_branch: bzr+ssh://bazaar.launchpad.net/%2Bbranch/scribes/
# testament_sha1: 6ab45ce7bcb642bfe2982d3688028ec4f6728ccf
# timestamp: 2012-09-22 17:12:58 +0200
# base_revision_id: mystilleef@gmail.com-20111118163400-\
# g4ldqge3dg50i90o
#
# Begin patch
=== added directory 'LanguagePlugins/CPPSymbolBrowser'
=== added file 'LanguagePlugins/CPPSymbolBrowser/Manager.py'
--- LanguagePlugins/CPPSymbolBrowser/Manager.py 1970-01-01 00:00:00 +0000
+++ LanguagePlugins/CPPSymbolBrowser/Manager.py 2012-04-25 20:06:11 +0000
@@ -0,0 +1,63 @@
+from gobject import GObject, SIGNAL_RUN_LAST, TYPE_NONE
+from gobject import TYPE_PYOBJECT
+
+class Manager(GObject):
+
+ __gsignals__ = {
+ "destroy": (SIGNAL_RUN_LAST, TYPE_NONE, ()),
+ "update": (SIGNAL_RUN_LAST, TYPE_NONE, (TYPE_PYOBJECT,)),
+ "show-window": (SIGNAL_RUN_LAST, TYPE_NONE, ()),
+ "hide-window": (SIGNAL_RUN_LAST, TYPE_NONE, ()),
+ }
+
+ def __init__(self, editor):
+ GObject.__init__(self)
+ self.__init_attributes(editor)
+ from Updater import Updater
+ Updater(editor, self)
+ from TreeView import TreeView
+ TreeView(editor, self)
+ from Window import Window
+ Window(editor, self)
+
+ def __init_attributes(self, editor):
+ self.__editor = editor
+ from os.path import join, split
+ current_folder = split(globals()["__file__"])[0]
+ glade_file = join(current_folder, "SymbolBrowser.glade")
+ from gtk.gdk import pixbuf_new_from_file
+ class_pixbuf = join(current_folder, "class.png")
+ self.__class_pixbuf = pixbuf_new_from_file(class_pixbuf)
+ function_pixbuf = join(current_folder, "function.png")
+ self.__function_pixbuf = pixbuf_new_from_file(function_pixbuf)
+ method_pixbuf = join(current_folder, "method.png")
+ self.__method_pixbuf = pixbuf_new_from_file(method_pixbuf)
+ from gtk.glade import XML
+ self.__glade = XML(glade_file, "Window", "scribes")
+ return
+
+ def __get_glade(self):
+ return self.__glade
+
+ def __get_class_pixbuf(self):
+ return self.__class_pixbuf
+
+ def __get_function_pixbuf(self):
+ return self.__function_pixbuf
+
+ def __get_method_pixbuf(self):
+ return self.__method_pixbuf
+
+ glade = property(__get_glade)
+ class_pixbuf = property(__get_class_pixbuf)
+ function_pixbuf = property(__get_function_pixbuf)
+ method_pixbuf = property(__get_method_pixbuf)
+
+ def show_browser(self):
+ self.emit("show-window")
+ return
+
+ def destroy(self):
+ self.emit("destroy")
+ del self
+ return
=== added file 'LanguagePlugins/CPPSymbolBrowser/SymbolBrowser.glade'
--- LanguagePlugins/CPPSymbolBrowser/SymbolBrowser.glade 1970-01-01 00:00:00 +0000
+++ LanguagePlugins/CPPSymbolBrowser/SymbolBrowser.glade 2012-04-25 20:06:11 +0000
@@ -0,0 +1,44 @@
+
+
+
+
+
+ 10
+ Classes and Functions
+ ScribesSymbolBrowser
+ center-on-parent
+ 350
+ 400
+ True
+ scribes
+ dialog
+ True
+ True
+ True
+ static
+ ScribesSymbolBrowser
+
+
+ True
+ True
+ never
+ automatic
+ in
+
+
+ True
+ False
+ True
+ True
+ True
+ False
+ True
+ 1
+ True
+ 2
+
+
+
+
+
+
=== added file 'LanguagePlugins/CPPSymbolBrowser/TreeView.py'
--- LanguagePlugins/CPPSymbolBrowser/TreeView.py 1970-01-01 00:00:00 +0000
+++ LanguagePlugins/CPPSymbolBrowser/TreeView.py 2012-09-22 15:06:05 +0000
@@ -0,0 +1,186 @@
+class TreeView(object):
+
+ def __init__(self, editor, manager):
+ self.__init_attributes(editor, manager)
+ self.__set_properties()
+ self.__sigid1 = self.__manager.connect("destroy", self.__destroy_cb)
+ self.__sigid2 = self.__manager.connect("update", self.__update_cb)
+ self.__sigid3 = self.__treeview.connect("row-activated", self.__row_activated_cb)
+ self.__sigid4 = self.__treeview.connect("cursor-changed", self.__cursor_changed)
+ from gobject import idle_add
+ idle_add(self.__precompile_method, priority=9999)
+
+ def __init_attributes(self, editor, manager):
+ self.__manager = manager
+ self.__symbols = None
+ self.__parent = None
+ self.__editor = editor
+ self.__treeview = manager.glade.get_widget("TreeView")
+ self.__model = self.__create_model()
+ self.__column = self.__create_column()
+ self.__depth_level_iter = None
+ return
+
+ def __set_properties(self):
+ self.__treeview.append_column(self.__column)
+ self.__treeview.map()
+ return
+
+ def __create_model(self):
+ from gtk import TreeStore
+ from gtk.gdk import Pixbuf
+ model = TreeStore(int, str, str, int, Pixbuf)
+ return model
+
+ def __create_column(self):
+ from gtk import TreeViewColumn, CellRendererText, CellRendererPixbuf
+ from gtk import TREE_VIEW_COLUMN_FIXED
+ column = TreeViewColumn()
+ pixbuf_renderer = CellRendererPixbuf()
+ text_renderer = CellRendererText()
+ column.pack_start(pixbuf_renderer, False)
+ column.pack_start(text_renderer, False)
+ column.set_sizing(TREE_VIEW_COLUMN_FIXED)
+ column.set_resizable(False)
+ column.set_attributes(text_renderer, text=1)
+ column.set_attributes(pixbuf_renderer, pixbuf=4)
+ return column
+
+ def __populate_model(self, symbols):
+ self.__treeview.set_property("sensitive", False)
+ if self.__symbols != symbols:
+ self.__treeview.window.freeze_updates()
+ from copy import copy
+ self.__symbols = copy(symbols)
+ self.__treeview.set_model(None)
+ self.__model.clear()
+ indentation = self.__get_indentation_levels(symbols)
+ append = self.__append_symbols
+ for item in symbols:
+ append(item, indentation)
+ self.__treeview.set_model(self.__model)
+ self.__treeview.window.thaw_updates()
+ #self.__treeview.expand_all()
+ self.__select_row()
+ self.__treeview.set_property("sensitive", True)
+ self.__treeview.grab_focus()
+ return False
+
+ def __select_row(self):
+ current_line = self.__editor.cursor.get_line() + 1
+ get_line = lambda x: x[0]
+ lines = sorted([get_line(symbol) for symbol in self.__symbols])
+ lines.reverse()
+ found_line = False
+ for line in lines:
+ if not (current_line == line or current_line > line): continue
+ found_line = True
+ current_line = line
+ break
+ if found_line:
+ self.__select_line_in_treeview(current_line)
+ else:
+ self.__editor.select_row(self.__treeview)
+ return
+
+ def __select_line_in_treeview(self, line):
+ iterator = self.__model.get_iter_root()
+ while True:
+ if self.__model.get_value(iterator, 0) == line: break
+ if self.__model.iter_has_child(iterator):
+ parent_iterator = iterator
+ found_line = False
+ for index in xrange(self.__model.iter_n_children(iterator)):
+ iterator = self.__model.iter_nth_child(parent_iterator, index)
+ if not (self.__model.get_value(iterator, 0) == line): continue
+ found_line = True
+ break
+ if found_line: break
+ iterator = parent_iterator
+ iterator = self.__model.iter_next(iterator)
+ if iterator is None: break
+# try:
+ path = self.__model.get_path(iterator)
+ self.__treeview.expand_to_path(path)
+ self.__treeview.get_selection().select_iter(iterator)
+ self.__treeview.set_cursor(path)
+ self.__treeview.scroll_to_cell(path, use_align=True, row_align=0.5)
+# except TypeError:
+# pass
+ return
+
+ def __get_indentation_levels(self, symbols):
+ get_indentation = lambda x: x[-2]
+ indentations = [get_indentation(symbol) for symbol in symbols]
+ indentation_levels = list(set(indentations))
+ indentation_levels.sort()
+ return indentation_levels
+
+ def __append_symbols(self, item, indentation):
+ index = indentation.index(item[-2])
+ parent = self.__find_parent(index)
+ self.__depth_level_iter = self.__model.append(parent, item)
+ return
+
+ def __find_parent(self, index):
+ if not index: return None
+ depth = self.__model.iter_depth(self.__depth_level_iter)
+ if index == depth:
+ parent = self.__model.iter_parent(self.__depth_level_iter)
+ elif index < depth:
+ self.__depth_level_iter = self.__model.iter_parent(self.__depth_level_iter)
+ parent = self.__find_parent(index)
+ elif index > depth:
+ parent = self.__depth_level_iter
+ return parent
+
+ def __select_symbol(self, line, name):
+ begin = self.__editor.textbuffer.get_iter_at_line(line - 1)
+ end = self.__editor.forward_to_line_end(begin.copy())
+ from gtk import TEXT_SEARCH_TEXT_ONLY
+ x, y = begin.forward_search(name, TEXT_SEARCH_TEXT_ONLY, end)
+ self.__editor.textbuffer.select_range(x, y)
+ self.__editor.move_view_to_cursor(True)
+ return False
+
+ def __forward_to_line_end(self, iterator):
+ if iterator.ends_line(): return iterator
+ iterator.forward_to_line_end()
+ return iterator
+
+ def __destroy_cb(self, manager):
+ self.__editor.disconnect_signal(self.__sigid1, self.__manager)
+ self.__editor.disconnect_signal(self.__sigid2, self.__manager)
+ self.__editor.disconnect_signal(self.__sigid3, self.__treeview)
+ self.__treeview.destroy()
+ del self
+ return
+
+ def __row_activated_cb(self, treeview, path, column):
+ iterator = self.__model.get_iter(path)
+ self.__manager.emit("hide-window")
+ self.__treeview.set_property("sensitive", False)
+ line = self.__model.get_value(iterator, 0)
+ name = self.__model.get_value(iterator, 1)
+ self.__select_symbol(line, name)
+ return True
+
+ def __cursor_changed(self, treeview):
+ cursor = treeview.get_cursor()
+ if cursor != None:
+ path = cursor[0]
+ iterator = self.__model.get_iter(path)
+ line = self.__model.get_value(iterator, 0)
+ name = self.__model.get_value(iterator, 1)
+ self.__select_symbol(line, name)
+
+ def __update_cb(self, manager, symbols):
+ from gobject import idle_add
+ idle_add(self.__populate_model, symbols, priority=9999)
+ return False
+
+ def __precompile_method(self):
+ methods = [self.__select_symbol, self.__row_activated_cb,
+ self.__populate_model]
+ self.__editor.optimize(methods)
+ return False
=== added file 'LanguagePlugins/CPPSymbolBrowser/Trigger.py'
--- LanguagePlugins/CPPSymbolBrowser/Trigger.py 1970-01-01 00:00:00 +0000
+++ LanguagePlugins/CPPSymbolBrowser/Trigger.py 2012-04-25 20:06:11 +0000
@@ -0,0 +1,39 @@
+from SCRIBES.SignalConnectionManager import SignalManager
+from SCRIBES.TriggerManager import TriggerManager
+from gettext import gettext as _
+
+class Trigger(SignalManager, TriggerManager):
+
+ def __init__(self, editor):
+ SignalManager.__init__(self)
+ TriggerManager.__init__(self, editor)
+ self.__init_attributes(editor)
+ self.connect(self.__trigger, "activate", self.__activate_cb)
+
+ def __init_attributes(self, editor):
+ self.__editor = editor
+ self.__manager = None
+ name, shortcut, description, category = (
+ "show-python-symbol-brower",
+ "F5",
+ _("Show classes, methods and functions"),
+ _("Python")
+ )
+ self.__trigger = self.create_trigger(name, shortcut, description, category)
+ return
+
+ def __activate_cb(self, *args):
+ try:
+ self.__manager.show_browser()
+ except AttributeError:
+ from Manager import Manager
+ self.__manager = Manager(self.__editor)
+ self.__manager.show_browser()
+ return
+
+ def destroy(self):
+ self.disconnect()
+ self.remove_triggers()
+ if self.__manager: self.__manager.destroy()
+ del self
+ return
=== added file 'LanguagePlugins/CPPSymbolBrowser/Updater.py'
--- LanguagePlugins/CPPSymbolBrowser/Updater.py 1970-01-01 00:00:00 +0000
+++ LanguagePlugins/CPPSymbolBrowser/Updater.py 2012-09-22 15:06:05 +0000
@@ -0,0 +1,175 @@
+class Updater(object):
+
+ def __init__(self, editor, manager):
+ self.__init_attributes(editor, manager)
+ self.__sigid1 = manager.connect("show-window", self.__show_window_cb)
+ from gobject import idle_add
+ idle_add(self.__precompile_methods, priority=9999)
+
+ def __init_attributes(self, editor, manager):
+ self.__editor = editor
+ self.__manager = manager
+ from collections import deque
+ # symbols has the format [(line_number, name, type), ...]
+ self.__symbols = deque([])
+ self.__depth = 0
+ self.__inside_class = False
+ self.__class_depth = 0
+ self.__function_depth = 0
+ return
+
+ def __get_symbols(self):
+ try:
+ self.__symbols.clear()
+ f = open('/tmp/scribes.symbolbrowser','w')
+ f.write(self.__editor.text)
+ f.close()
+ from os import system
+ lang = self.__editor.language
+ langmap = {
+ 'cpp': 'C++',
+ 'chdr': 'C++',
+ 'c': 'C',
+ 'php': 'PHP',
+ 'java': 'Java',
+ 'perl': 'Perl',
+ 'js': 'JavaScript',
+ 'lua': 'Lua',
+ 'lisp': 'Lisp',
+ 'pascal': 'Pascal',
+ 'sh': 'Sh',
+ }
+ if lang in langmap:
+ lang = langmap[lang]
+ else:
+ lang = 'C++' #pretend C++
+ system('ctags -f /tmp/tags --language-force=' + lang + ' --fields=afmikKlnsStz /tmp/scribes.symbolbrowser')
+ self.__extract_symbols('/tmp/tags')
+ self.__manager.emit("update", self.__symbols)
+ except SyntaxError:
+ pass
+ return False
+
+ def __extract_symbols(self, filename):
+ classes = {} #classes
+ classchildren = {} #methods pertaining to classes (None key for classless functions)
+
+ f = open(filename)
+ for line in f:
+ line = line.strip()
+ if not line or line[0] == '!':
+ continue
+ #print "DEBUG: PARSING LINE: ", line
+ fields = line.split('\t')
+ #if not len(fields) >= 3:
+ # print "CPPSymbolBrowser unparsable ctags line: ", line
+ name = fields[0]
+ filename = fields[1]
+ attribs = {}
+ for x in fields[3:]:
+ x = x.split(':',1)
+ if len(x) == 2:
+ attribs[x[0]] = x[1]
+ if 'line' in attribs:
+ lineno = int(attribs['line'])
+ else:
+ continue
+ if 'kind' in attribs and attribs['kind'] == 'class':
+ cls = name
+ classes[cls] = (name,filename,lineno,attribs)
+ continue
+ elif 'kind' in attribs and (attribs['kind'] == 'variable' or attribs['kind'] == 'enumerator' or attribs['kind'] == 'macro' or attribs['kind'] == 'define'):
+ continue #skip these
+ elif 'class' in attribs:
+ cls = attribs['class']
+ else:
+ cls = None
+
+ if not cls in classchildren:
+ classchildren[cls] = []
+
+ #print "DEBUG: Found: ", repr((name, filename, lineno, attribs))
+ insertpos = 0
+ for i, (_,_,lineno2,_) in enumerate(classchildren[cls]):
+ if lineno > lineno2:
+ insertpos = i+1
+ classchildren[cls].insert( insertpos, (name, filename, lineno, attribs) )
+ f.close()
+
+
+ #order symbols first
+ classorder = []
+ for cls in set(set(classchildren.keys()) | set(classes.keys())):
+ if cls != None:
+ if cls in classes:
+ firstline = classes[cls][2]
+ elif cls in classchildren:
+ firstline = None
+ for _,_,lineno,_ in classchildren[cls]:
+ if firstline == None or lineno < firstline:
+ firstline = lineno
+
+ insertpos = 0
+ for i, cls2 in enumerate(classorder):
+ if cls2 != None:
+ if cls2 in classes:
+ firstline2= classes[cls2][2]
+ elif cls2 in classchildren:
+ firstline2 = None
+ for _,_,lineno,_ in classchildren[cls]:
+ if firstline2 == None or lineno < firstline:
+ firstline2 = lineno
+ if firstline > firstline2:
+ insertpos = i+1
+
+ classorder.insert(insertpos, cls)
+
+ if None in classchildren:
+ classorder.append( None) #classless always last
+
+
+ for cls in classorder:
+ if cls != None:
+ if cls in classes:
+ name = classes[cls][0]
+ lineno = classes[cls][2]
+ elif cls in classchildren:
+ lineno = 0
+ for name,filename,line,attribs in classchildren[cls]:
+ if name == cls:
+ lineno = line
+ break
+ if lineno:
+ self.__symbols.append( (lineno, name, 'Class', 0, self.__manager.class_pixbuf) )
+ depth = 1
+ else:
+ depth = 0
+ else:
+ insertpos = 0
+ depth = 0
+
+ if cls in classchildren:
+ for name,filename,line,attribs in classchildren[cls]:
+ if depth == 0:
+ type = 'Function'
+ pixbuf = self.__manager.function_pixbuf
+ else:
+ type = 'Method'
+ pixbuf = self.__manager.method_pixbuf
+
+ self.__symbols.append( (line, name, type, depth, pixbuf) )
+
+
+
+ return
+
+
+ def __precompile_methods(self):
+ methods = (self.__extract_symbols, self.__get_symbols,)
+ self.__editor.optimize(methods)
+ return False
+
+ def __show_window_cb(self, *args):
+ from gobject import idle_add
+ idle_add(self.__get_symbols, priority=9999)
+ return
=== added file 'LanguagePlugins/CPPSymbolBrowser/Window.py'
--- LanguagePlugins/CPPSymbolBrowser/Window.py 1970-01-01 00:00:00 +0000
+++ LanguagePlugins/CPPSymbolBrowser/Window.py 2012-04-25 20:06:11 +0000
@@ -0,0 +1,68 @@
+class Window(object):
+
+ def __init__(self, editor, manager):
+ self.__init_attributes(editor, manager)
+ self.__set_properties()
+ self.__sigid1 = manager.connect("destroy", self.__destroy_cb)
+ self.__sigid2 = manager.connect("show-window", self.__show_window_cb)
+ self.__sigid3 = manager.connect("hide-window", self.__hide_window_cb)
+ self.__sigid4 = self.__window.connect("delete-event", self.__delete_event_cb)
+ self.__sigid5 = self.__window.connect("key-press-event", self.__key_press_event_cb)
+ self.__window.set_property("sensitive", True)
+
+ def __init_attributes(self, editor, manager):
+ self.__manager = manager
+ self.__editor = editor
+ self.__window = manager.glade.get_widget("Window")
+ return
+
+ def __set_properties(self):
+ self.__window.set_transient_for(self.__editor.window)
+ return
+
+ def __show(self):
+ self.__editor.busy()
+ message = "C/C++ symbols"
+ self.__editor.set_message(message, "yes")
+ self.__window.show_all()
+ return False
+
+ def __hide(self):
+ self.__editor.busy(False)
+ message = "C/C++ symbols"
+ self.__editor.unset_message(message, "yes")
+ self.__window.hide()
+ return False
+
+ def __destroy(self):
+ self.__editor.disconnect_signal(self.__sigid1, self.__manager)
+ self.__editor.disconnect_signal(self.__sigid2, self.__manager)
+ self.__editor.disconnect_signal(self.__sigid3, self.__manager)
+ self.__editor.disconnect_signal(self.__sigid4, self.__window)
+ self.__editor.disconnect_signal(self.__sigid5, self.__window)
+ self.__window.destroy()
+ del self
+ self = None
+ return
+
+ def __destroy_cb(self, *args):
+ self.__destroy()
+ return
+
+ def __hide_window_cb(self, *args):
+ self.__hide()
+ return
+
+ def __show_window_cb(self, *args):
+ self.__show()
+ return
+
+ def __delete_event_cb(self, *args):
+ self.__hide()
+ return True
+
+ def __key_press_event_cb(self, window, event):
+ from gtk import keysyms
+ if event.keyval != keysyms.Escape: return False
+ self.__hide()
+ return True
=== added file 'LanguagePlugins/CPPSymbolBrowser/__init__.py'
=== added file 'LanguagePlugins/CPPSymbolBrowser/class.png'
Binary files LanguagePlugins/CPPSymbolBrowser/class.png 1970-01-01 00:00:00 +0000 and LanguagePlugins/CPPSymbolBrowser/class.png 2012-04-25 20:06:11 +0000 differ
=== added file 'LanguagePlugins/CPPSymbolBrowser/function.png'
Binary files LanguagePlugins/CPPSymbolBrowser/function.png 1970-01-01 00:00:00 +0000 and LanguagePlugins/CPPSymbolBrowser/function.png 2012-04-25 20:06:11 +0000 differ
=== added file 'LanguagePlugins/CPPSymbolBrowser/method.png'
Binary files LanguagePlugins/CPPSymbolBrowser/method.png 1970-01-01 00:00:00 +0000 and LanguagePlugins/CPPSymbolBrowser/method.png 2012-04-25 20:06:11 +0000 differ
=== added file 'LanguagePlugins/PluginCPPSymbrolBrowser.py'
--- LanguagePlugins/PluginCPPSymbrolBrowser.py 1970-01-01 00:00:00 +0000
+++ LanguagePlugins/PluginCPPSymbrolBrowser.py 2012-09-22 15:06:05 +0000
@@ -0,0 +1,23 @@
+name = "Symbol Browser"
+authors = ["Maarten van Gompel (proycon) " ,"Lateef Alabi-Oki ",]
+languages = ["c","cpp","chdr","java","perl","php","lua","js","lisp","pascal","go"]
+version = 0.2
+autoload = True
+class_name = "CPPSymbolBrowserPlugin"
+short_description = "Show symbols in C++ source code."
+long_description = """This plugin allows users to view all symbols in source code and navigate easily. It is initially written for C++ but as it uses ctags it also works for most other languages. Press F5 to show the symbol browser."""
+
+class CPPSymbolBrowserPlugin(object):
+
+ def __init__(self, editor):
+ self.__editor = editor
+ self.__trigger = None
+
+ def load(self):
+ from CPPSymbolBrowser.Trigger import Trigger
+ self.__trigger = Trigger(self.__editor)
+ return
+
+ def unload(self):
+ self.__trigger.destroy()
+ return
=== modified file 'LanguagePlugins/PythonSymbolBrowser/TreeView.py'
--- LanguagePlugins/PythonSymbolBrowser/TreeView.py 2010-11-14 02:01:01 +0000
+++ LanguagePlugins/PythonSymbolBrowser/TreeView.py 2012-09-22 15:06:05 +0000
@@ -6,6 +6,7 @@
self.__sigid1 = self.__manager.connect("destroy", self.__destroy_cb)
self.__sigid2 = self.__manager.connect("update", self.__update_cb)
self.__sigid3 = self.__treeview.connect("row-activated", self.__row_activated_cb)
+ self.__sigid4 = self.__treeview.connect("cursor-changed", self.__cursor_changed)
from gobject import idle_add
idle_add(self.__precompile_method, priority=9999)
@@ -162,6 +163,15 @@
name = self.__model.get_value(iterator, 1)
self.__select_symbol(line, name)
return True
+
+ def __cursor_changed(self, treeview):
+ cursor = treeview.get_cursor()
+ if cursor != None:
+ path = cursor[0]
+ iterator = self.__model.get_iter(path)
+ line = self.__model.get_value(iterator, 0)
+ name = self.__model.get_value(iterator, 1)
+ self.__select_symbol(line, name)
def __update_cb(self, manager, symbols):
from gobject import idle_add
=== modified file 'SCRIBES/Globals.py'
--- SCRIBES/Globals.py 2011-11-10 15:09:01 +0000
+++ SCRIBES/Globals.py 2012-04-25 20:06:11 +0000
@@ -33,8 +33,8 @@
root_plugin_folder = join(library_path, "scribes")
core_plugin_folder = core_generic_plugin_folder = join(root_plugin_folder, "GenericPlugins")
core_language_plugin_folder = join(root_plugin_folder, "LanguagePlugins")
-python_path = "/usr/lib/python2.7/site-packages"
-version = "0.4-dev-build1038"
+python_path = "/usr/lib/python2.7/dist-packages"
+version = "0.4-dev-build1052"
author = ["Author:", "\tLateef Alabi-Oki \n",
"Contributors:",
"\tIb Lundgren ",
=== modified file 'po/Makefile.in'
--- po/Makefile.in 2011-11-10 15:09:01 +0000
+++ po/Makefile.in 2012-04-25 20:06:11 +0000
@@ -19,9 +19,9 @@
GETTEXT_PACKAGE = scribes
PACKAGE = scribes
-VERSION = 0.4-dev-build1038
+VERSION = 0.4-dev-build1052
-SHELL = /bin/sh
+SHELL = /bin/bash
srcdir = .
top_srcdir = ..
@@ -36,7 +36,7 @@
DATADIRNAME = share
itlocaledir = $(prefix)/$(DATADIRNAME)/locale
subdir = po
-install_sh = ${SHELL} /home/lateef/Dropbox/scribes/install-sh
+install_sh = ${SHELL} /home/proycon/scribes/install-sh
# Automake >= 1.8 provides /bin/mkdir -p.
# Until it can be supposed, use the safe fallback:
mkdir_p = $(install_sh) -d
# Begin bundle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