def create_toolbar( self):
self.toolbar_box = gtk.HandleBox()
toolbar = gnutr_widgets.GnutrToolbar()
tooltips = gtk.Tooltips()
self.toolbar_box.add( toolbar)
self.save_button = toolbar.append_button( 'gtk-save', 'Save', tooltips, 'Save meal plan')
sep = gtk.SeparatorToolItem()
toolbar.insert(sep, -1)
self.add_button = toolbar.append_button( 'gtk-add', 'Add', tooltips, 'Add food or recipe')
self.edit_button = toolbar.append_button( 'gtk-undo', 'Edit', tooltips, 'Edit recipe or food')
self.delete_button = toolbar.append_button( 'gtk-remove', 'Delete', tooltips, 'Delete selected recipe or food')
sep = gtk.SeparatorToolItem()
toolbar.insert(sep, -1)
self.compute_button = toolbar.append_button( 'gtk-execute', 'Compute', tooltips, 'Compute nutritient composition')
# icon6 = gtk.Image()
# icon6.set_from_stock( 'gtk-execute', gtk.ICON_SIZE_LARGE_TOOLBAR)
# self.graph_button = toolbar.append_item( 'Graph',
# 'Graph of nutrient composition', None, icon6, None, None)
# icon7 = gtk.Image()
# icon7.set_from_stock( 'gtk-execute', gtk.ICON_SIZE_LARGE_TOOLBAR)
# self.graph_button = toolbar.append_item( 'Variation',
# 'Graph of variation of nutrient composition', None, icon7,
# None, None)
self.toolbar_box.show_all()
def __init__(self):
gtk.Window.__init__(self)
self.connect('destroy', self.exitt)
self.set_position(gtk.WIN_POS_CENTER)
self.set_size_request(900, 500)
self.set_title('Edna')
self.set_icon_from_file('edna.svg')
# Widget#########################
hdlbox = gtk.HandleBox()
hdlbox.add(self.create_menu())
self.vbox1 = gtk.VBox(False, 5)
self.hpannel1 = gtk.HBox(True,5)
self.hpannel1.set_border_width(5)
self.cel = []
self.cel.append(edna_gui.listen_cell(0, self.return_path_cell))
self.cel.append(edna_gui.listen_cell(1, self.return_path_cell))
self.set_focus(self.cel[0].treeview)
self.foc_c = True
#################################
#BOX############################
for i in xrange(2):
self.hpannel1.pack_start(self.cel[i])
self.vbox1.pack_start(hdlbox, False)
self.vbox1.pack_start(self.hpannel1)
################################
#self.connect('key-release-event', self.key_c)
#self.connect('key-press-event', self.key_c)
self.add(self.vbox1)
self.foc = self.is_focus()
self.connect('focus', self.focuss)
def create_toolbar(self):
self.toolbar_box = gtk.HandleBox()
toolbar = gnutr_widgets.GnutrToolbar()
tooltips = gtk.Tooltips()
self.toolbar_box.add(toolbar)
self.clear_button = toolbar.append_button('gtk-clear', 'Clear', tooltips, 'Clear food data')
sep = gtk.SeparatorToolItem()
toolbar.insert(sep, -1)
self.select_button = toolbar.append_button('gtk-find', 'Select', tooltips, 'Select food from database')
self.compute_button = toolbar.append_button('gtk-execute', 'Compute', tooltips, 'Compute nutrition composition')
sep = gtk.SeparatorToolItem()
toolbar.insert(sep, -1)
self.pref_button = toolbar.append_button('gtk-preferences', 'Goals', tooltips, 'Nutritient goal')
# icon5 = gtk.Image()
# icon5.set_from_stock('gtk-execute', gtk.ICON_SIZE_LARGE_TOOLBAR)
# self.graph_button = toolbar.append_item('Graph',
# 'Graph of nutrient composition', None, icon5, None, None)
self.toolbar_box.show_all()
def __init__(self, quit_cb=None):
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
self.set_size_request(470, 300)
self.connect("delete_event", self.file_exit)
self.quit_cb = quit_cb
self.vbox = gtk.VBox()
self.add(self.vbox)
self.vbox.show()
hdlbox = gtk.HandleBox()
self.vbox.pack_start(hdlbox, expand=False)
hdlbox.show()
self.menubar, self.toolbar = self.create_menu()
hdlbox.add(self.menubar)
self.menubar.show()
self.vbox.pack_start(self.toolbar, expand=False)
self.scrolledwin = gtk.ScrolledWindow()
self.scrolledwin.show()
self.vbox.pack_start(self.scrolledwin)
self.text = gtk.TextView()
self.text.set_editable(True)
self.scrolledwin.add(self.text)
self.text.show()
self.buffer = self.text.get_buffer()
self.dirty = 0
self.file_new()
self.text.grab_focus()
self.clipboard = gtk.Clipboard(selection='CLIPBOARD')
self.dirname = None
self.search_string = None
self.last_search_iter = None
return
def Main():
global AppWin, Graph
AppWin = gtk.Window(gtk.WINDOW_TOPLEVEL)
AppWin.set_title("Lybniz")
AppWin.set_default_size(800, 600)
AppWin.connect("delete-event", QuitDlg)
AppWin.AccelGroup = gtk.AccelGroup()
AppWin.add_accel_group(AppWin.AccelGroup)
AppWin.VBox = gtk.VBox(False, 1)
AppWin.VBox.set_border_width(1)
AppWin.add(AppWin.VBox)
AppWin.StatusBar = gtk.Statusbar()
AppWin.StatusBar.ContextId = AppWin.StatusBar.get_context_id("Dummy")
MenuToolbarCreate()
AppWin.VBox.pack_start(AppWin.MenuMain, False, True, 0)
HandleBox = gtk.HandleBox()
HandleBox.add(AppWin.ToolBar)
AppWin.VBox.pack_start(HandleBox, False, True, 0)
AppWin.VBox.pack_start(ParameterEntriesCreate(), False, True, 4)
Graph = GraphClass()
AppWin.VBox.pack_start(Graph.DrawingArea, True, True, 0)
AppWin.VBox.pack_start(AppWin.StatusBar, False, True, 0)
AppWin.show_all()
gtk.main()
def create_toolbar( self):
self.toolbar_box = gtk.HandleBox()
toolbar = gnutr_widgets.GnutrToolbar()
tooltips = gtk.Tooltips()
self.toolbar_box.add( toolbar)
self.open_button = toolbar.append_button( 'gtk-open', "Open", tooltips, "Open recipe from database")
self.save_button = toolbar.append_button( 'gtk-save', "Save", tooltips, "Save recipe to database")
self.clear_button = toolbar.append_button( 'gtk-refresh', "Clear", tooltips, "Clear recipe")
sep = gtk.SeparatorToolItem()
toolbar.insert( sep, -1)
self.add_button = toolbar.append_button( 'gtk-add', "Add", tooltips, "Add food to recipe")
self.delete_button = toolbar.append_button( 'gtk-remove', "Delete", tooltips, "Delete food from recipe")
self.edit_button = toolbar.append_button( 'gtk-undo', "Edit", tooltips, "Edit food in recipe")
sep = gtk.SeparatorToolItem()
toolbar.insert( sep, -1)
self.nutr_button = toolbar.append_button( 'gtk-execute', "Nutrients", tooltips, "Display recipe nutrient totals")
self.goal_button = toolbar.append_button( 'gtk-properties', "Goals", tooltips, "Nutrition goals")
# icon9 = gtk.Image()
# icon9.set_from_stock( 'gtk-execute', gtk.ICON_SIZE_LARGE_TOOLBAR)
# self.graph_button = toolbar.append_item( "Graph",
# "Display graph of recipe nutrient totals", None, icon9,
# None, None)
self.toolbar_box.show_all()
def create_menubar(self):
self.menubar_box = gtk.HandleBox()
menubar = gtk.MenuBar()
self.menubar_box.add(menubar)
file_menu_item = gtk.MenuItem('_File')
edit_menu_item = gtk.MenuItem('_Edit')
view_menu_item = gtk.MenuItem('_View')
settings_menu_item = gtk.MenuItem('_Settings')
help_menu_item = gtk.MenuItem('_Help')
file_menu = gtk.Menu()
self.save_item = MyImageMenuItem('_Save', 'gtk-save')
separator1 = gtk.SeparatorMenuItem()
self.exit_item = MyImageMenuItem('_Quit', 'gtk-quit')
file_menu.add(self.save_item)
file_menu.add(separator1)
file_menu.add(self.exit_item)
file_menu_item.set_submenu(file_menu)
edit_menu = gtk.Menu()
self.add_item = MyImageMenuItem('_Add', 'gtk-add')
self.edit_item = MyImageMenuItem('_Edit', 'gtk-edit')
self.delete_item = MyImageMenuItem('_Delete', 'gtk-delete')
edit_menu.add(self.add_item)
edit_menu.add(self.edit_item)
edit_menu.add(self.delete_item)
edit_menu_item.set_submenu(edit_menu)
view_menu = gtk.Menu()
self.plan_view_item = MyImageMenuItem('_Plan', 'gnutr-plan')
self.recipe_view_item = MyImageMenuItem('_Recipe', 'gnutr-recipe')
self.food_view_item = MyImageMenuItem('_Food', 'gnutr-food')
view_menu.add(self.plan_view_item)
view_menu.add(self.recipe_view_item)
view_menu.add(self.food_view_item)
view_menu_item.set_submenu(view_menu)
settings_menu = gtk.Menu()
self.nutr_goal_item = MyImageMenuItem('Nutrient _Goal',
'gtk-properties')
settings_menu.add(self.nutr_goal_item)
settings_menu_item.set_submenu(settings_menu)
help_menu = gtk.Menu()
self.manual_item = MyImageMenuItem('_Contents', 'gtk-help')
self.about_item = MyImageMenuItem('_About', 'gtk-about')
help_menu.add(self.manual_item)
help_menu.add(self.about_item)
help_menu_item.set_submenu(help_menu)
menubar.add(file_menu_item)
menubar.add(edit_menu_item)
menubar.add(view_menu_item)
menubar.add(settings_menu_item)
menubar.add(help_menu_item)
self.menubar_box.show_all()
def __init__(self):
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
self.connect("destroy", self.quit)
self.connect("delete_event", self.quit)
self.set_title("Python")
self.set_size_request(475, 325)
self.main_box = gtk.VBox()
self.add(self.main_box)
self.main_box.show()
hdlbox = gtk.HandleBox()
self.main_box.pack_start(hdlbox, expand=False)
hdlbox.show()
actions = [
('FileMenu', None, '_File'),
('FileNew', gtk.STOCK_NEW, None, None, None, self.file_new),
('FileOpen', gtk.STOCK_OPEN, None, None, None, self.file_open),
('FileExit', gtk.STOCK_QUIT, None, None, None, self.file_exit),
('EditMenu', None, '_Edit'),
('EditCopy', gtk.STOCK_COPY, None, None, None, self.edit_copy),
('EditPaste', gtk.STOCK_PASTE, None, None, None, self.edit_paste),
('EditClear', gtk.STOCK_REMOVE, 'C_lear', None, None,
self.edit_clear),
('HelpMenu', gtk.STOCK_HELP),
('HelpAbout', None, 'A_bout', None, None, self.help_about),
]
python_actions = [
('PythonMenu', None, '_Python'),
('PythonReload', None, '_Reload Module...', None, None,
self.python_reload),
('PythonRun', None, 'R_un...', None, None, self.python_run),
('PythonDebug', None, '_Debug...', None, None, self.python_debug),
('PythonProfile', None, 'Pro_file...', None, None,
self.python_prof),
]
self.ag = gtk.ActionGroup('ide')
self.ag.add_actions(actions)
self.ag.add_actions(python_actions)
self.ui = gtk.UIManager()
self.ui.insert_action_group(self.ag, 0)
self.ui.add_ui_from_string(ui_string)
self.ui.add_ui_from_string(pythonmenu_uistring)
self.add_accel_group(self.ui.get_accel_group())
hdlbox.add(self.ui.get_widget('/menubar'))
#self.ui.get_widget('/menubar').show()
self.interp = gtkcons.Console(namespace={
'__builtins__': __builtins__,
'__name__': '__main__',
'__doc__': None
},
quit_cb=self.quit)
self.main_box.pack_start(self.interp)
self.interp.show()
self.interp.init()
self.editwins = []
return
def main():
global app_win, graph, configFile, config
app_win = gtk.Window(gtk.WINDOW_TOPLEVEL)
app_win.set_title("Lybniz")
app_win.connect("delete-event", quit_dlg)
try:
app_win.set_icon_from_file(icon_file)
except:
print "Icon not found at", icon_file
#configFile = os.path.expanduser('~/.lybniz.cfg')
#config = ConfigParser.ConfigParser()
if config.read([
configFile,
]) == []:
config.add_section("MainWindow")
app_win.set_default_size(800, 600)
if config.has_option("MainWindow", "width"):
app_win.resize(config.getint("MainWindow", "width"),
config.getint("MainWindow", "height"))
if config.has_option("MainWindow", "x"):
app_win.move(config.getint("MainWindow", "x"),
config.getint("MainWindow", "y"))
else:
app_win.set_position(gtk.WIN_POS_CENTER)
app_win.accel_group = gtk.AccelGroup()
app_win.add_accel_group(app_win.accel_group)
app_win.v_box = gtk.VBox(False, 1)
app_win.v_box.set_border_width(1)
app_win.add(app_win.v_box)
app_win.status_bar = gtk.Statusbar()
menu_toolbar_create()
app_win.v_box.pack_start(app_win.menu_main, False, True, 0)
handle_box = gtk.HandleBox()
handle_box.add(app_win.tool_bar)
app_win.v_box.pack_start(handle_box, False, True, 0)
app_win.v_box.pack_start(parameter_entries_create(), False, True, 4)
graph = GraphClass()
app_win.v_box.pack_start(graph.drawing_area, True, True, 0)
app_win.v_box.pack_start(app_win.status_bar, False, True, 0)
app_win.show_all()
app_win.scale_box.hide()
gtk.main()
def __init__(self):
gtk.Window.__init__(self)
self.__set_window_properties_from_configfile__()
self.set_title(edna_builtin['project name'])
try:
self.set_icon_from_file('%s/share/pixmaps/edna.svg' % sys.prefix)
except:
pass
self.hdlbox = gtk.HandleBox()
self.hdlbox.add(self.create_menu())
self.__container_init__()
self.__container_pack__()
def __init__(self, application):
gtk.VBox.__init__(self)
handle = gtk.HandleBox()
handle.set_handle_position(gtk.POS_LEFT)
self.pack_start(handle, False, False)
toolbar = gtk.Toolbar()
toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
#toolbar.set_style(gtk.TOOLBAR_ICONS)
toolbar.set_style(gtk.TOOLBAR_BOTH_HORIZ)
toolbar.set_icon_size(gtk.ICON_SIZE_MENU)
handle.add(toolbar)
position = 0
button = gtk.ToolButton(gtk.STOCK_MEDIA_PLAY)
button.connect("clicked", self.run)
toolbar.insert(button, position)
position += 1
button = gtk.ToolButton(gtk.STOCK_MEDIA_STOP)
toolbar.insert(button, position)
panel = gtk.HPaned()
panel.set_position(75) # TODO calculate
self.add(panel)
self.editor = SourcePad(application)
panel.pack1(self.editor, True, False)
view = gtk.ScrolledWindow()
view.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
panel.pack2(view, False, True)
output = gtk.TextView()
font = pango.FontDescription('monospace')
output.modify_font(font)
self.buffer = gtk.TextBuffer()
self.buffer.connect_after('insert-text', self.text_inserted, view)
output.set_buffer(self.buffer)
view.add(output)
self.tags = []
self.buffer.create_tag("normal",
editable=False,
wrap_mode=gtk.WRAP_WORD_CHAR)
self.buffer.create_tag("error",
foreground="#f00",
weight=pango.WEIGHT_BOLD,
style=pango.STYLE_ITALIC)
self.tags.append('normal')
def __init__(self):
""" GTKServer Main Function
Initialise framework and draw main window """
self.form_dialog = None
gtk.Window.__init__(self)
# initialize flag
self.flag = FlagFramework.Flag()
FlagFramework.GLOBAL_FLAG_OBJ = self.flag
self.flag.ui = GTKUI.GTKUI
# set some window properties
self.set_title('PyFLAG')
self.set_icon_from_file('%s/pyflag_logo.png' % config.IMAGEDIR)
self.set_default_size(800, 600)
self.connect('destroy', lambda x: gtk.main_quit())
# these are the MAIN ELEMENTS of the GTKServer
self.vbox = gtk.VBox()
self.uimanager = gtk.UIManager()
self.toolhandlebox = gtk.HandleBox()
self.toolhbox = gtk.HBox()
self.toolhandlebox.add(self.toolhbox)
self.ftoolbar = FlagServerToolbar(self.toolhbox)
self.notebook = FlagServerNotebook(
self.flag.ui(server=self, ftoolbar=self.ftoolbar))
## have to build the ui at this point...
self.build_flag_menu()
self.menubar = self.uimanager.get_widget('/Menubar')
self.statusbar = gtk.Statusbar()
# pack these to arrange the UI
self.add_accel_group(self.uimanager.get_accel_group())
self.add(self.vbox)
self.vbox.pack_start(self.menubar, False)
# put the toolbar in a HBox with a case selector
hbox = gtk.HBox()
self.case_selector_combo = self.case_selector()
hbox.pack_start(self.case_selector_combo, False)
hbox.pack_start(self.toolhandlebox)
self.toolhbox.show_all()
self.vbox.pack_start(hbox, False)
self.vbox.pack_start(self.notebook, True, True)
self.vbox.pack_end(self.statusbar, False)
self.show_all()
def _pack_topbar(self, menubar, toolbar):
self.__toolarea = gtk.VBox()
self.__toolarea.show()
menubar.show()
self.__mainbox.pack_start(self.__toolarea, expand=False)
self.__toolarea.pack_start(menubar, expand=False)
toolbar.show()
toolbar_handle = gtk.HandleBox()
toolbar_handle.add(toolbar)
toolbar_handle.show()
self.__toolarea.pack_start(toolbar_handle, expand=False)
self.__menubar = menubar
self.__toolbar = toolbar
def _buildToolBar(self):
"""
Builds The IDE toolbar
Returns The toolbar.
"""
handlebox = gtk.HandleBox()
self.toolbar = gtk.Toolbar()
self.toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
self.toolbar.set_style(gtk.TOOLBAR_BOTH)
self.toolbar.set_border_width(5)
self._addToolbarStock(self.toolbar,
gtk.STOCK_NEW,
_("New"),
_("Create New File"),
callback=None)
self._addToolbarStock(self.toolbar,
gtk.STOCK_OPEN,
_("Open"),
_("Open File"),
callback=None)
self._addToolbarStock(self.toolbar,
gtk.STOCK_SAVE,
_("Save"),
_("Save File"),
callback=None)
self.toolbar.insert(gtk.SeparatorToolItem(), -1)
self._addToolbarStock(self.toolbar,
gtk.STOCK_EXECUTE,
_("Compile"),
_("Compile"),
callback=None)
self._addToolbarStock(self.toolbar,
gtk.STOCK_GO_UP,
_("Upload"),
_("Upload"),
callback=None)
handlebox.add(self.toolbar)
return handlebox
def createView(self):
self.uiManager.ensure_update()
toolbar = self.uiManager.get_widget("/MainToolBar")
self.ensureVisible(toolbar)
self.widget = gtk.HandleBox()
self.widget.add(toolbar)
toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
progressBarGUI = self.subguis[0]
if progressBarGUI.shouldShow():
progressBar = progressBarGUI.createView()
width = 7 # Looks good, same as gtk.Paned border width
alignment = gtk.Alignment()
alignment.set(1.0, 1.0, 1.0, 1.0)
alignment.set_padding(width, width, 1, width)
alignment.add(progressBar)
toolItem = gtk.ToolItem()
toolItem.add(alignment)
toolItem.set_expand(True)
toolbar.insert(toolItem, -1)
self.widget.show_all()
return self.widget
def __init__(self):
dialog = gtk.Dialog()
dialog.connect("delete-event", gtk.main_quit)
dialog.set_size_request(450, -1)
dialog.set_resizable(True)
# to make it nice we'll put the toolbar into the handle box,
# so that it can be detached from the main window
handlebox = gtk.HandleBox()
dialog.vbox.pack_start(handlebox, False, False, 5)
# toolbar will be horizontal, with both icons and text, and
# with 5pxl spaces between items and finally,
# we'll also put it into our handlebox
toolbar = gtk.Toolbar()
toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
toolbar.set_style(gtk.TOOLBAR_BOTH)
toolbar.set_border_width(5)
handlebox.add(toolbar)
self.buttons = []
for a in range(0, 5):
if a == 0:
#first button with none group
widget = None
else:
#additional buttons with belong to the group of the first button
widget = but
but = gtk.RadioToolButton(group=widget, stock_id=gtk.STOCK_APPLY)
but.set_label("button %d" % a)
but.connect("clicked", self.radio_event, a)
toolbar.insert(but, a)
self.buttons.append(but)
dialog.show_all()
def __init__(self):
dialog = gtk.Dialog()
dialog.set_title("GTK Toolbar Tutorial")
dialog.set_size_request(650,\
250)
dialog.set_resizable(True)
dialog.connect("delete-event",\
self.delete_event)
handlebox = gtk.HandleBox()
dialog.vbox.pack_start(handlebox,\
False,\
False,\
5)
toolbar = gtk.Toolbar()
toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
toolbar.set_style(gtk.TOOLBAR_BOTH)
toolbar.set_border_width(5)
handlebox.add(toolbar)
iconw = gtk.Image()
iconw.set_from_file("/usr/share/app-install/icons/gtkhash.xpm")
close_button=toolbar.append_item("Close",\
"Closes this app",\
"Private",\
iconw,\
self.delete_event)
toolbar.append_space()
iconw = gtk.Image()
iconw.set_from_file("/usr/share/app-install/icons/gtkhash.xpm")
icon_button=toolbar.append_element(gtk.TOOLBAR_CHILD_RADIOBUTTON,\
None,\
"Icon",\
"Only icons in toolbar",\
"Private",\
iconw,\
self.radio_event,\
toolbar)
toolbar.append_space()
self.icon_button = icon_button
iconw = gtk.Image()
iconw.set_from_file("/usr/share/app-install/icons/gtkhash.xpm")
text_button=toolbar.append_element(gtk.TOOLBAR_CHILD_RADIOBUTTON,\
icon_button,\
"Text",\
"Only texts in toolbar",\
"Private",\
iconw,\
self.radio_event,\
toolbar)
toolbar.append_space()
self.text_button = text_button
iconw = gtk.Image()
iconw.set_from_file("/usr/share/app-install/icons/gtkhash.xpm")
both_button=toolbar.append_element(gtk.TOOLBAR_CHILD_RADIOBUTTON,\
text_button,\
"Both",\
"Icon and text in toolbar",\
"Private",\
iconw,\
self.radio_event,\
toolbar)
toolbar.append_space()
self.both_button = both_button
both_button.set_active(True)
iconw = gtk.Image()
iconw.set_from_file("/usr/share/app-install/icons/gtkhash.xpm")
tooltip_button=toolbar.append_element(gtk.TOOLBAR_CHILD_TOGGLEBUTTON,\
None,\
"Tooltips",\
"Toolbar with or without tooltips",\
"Private",\
iconw,\
self.toggle_event,\
toolbar)
toolbar.append_space()
self.tooltip_button = tooltip_button
tooltip_button.set_active(True)
entry = gtk.Entry()
toolbar.append_widget(entry,\
"This is just an entry",\
"Private")
entry.show()
toolbar.show()
handlebox.show()
dialog.show()
def __init__(self):
# #################################################################################################################################
# # Load and apply gtkrc
# #################################################################
# # No exception control because rc_parse doesn't throw exception on fail... sad but true ;)
# ORIGDIR = os.getcwd()
# os.chdir('lib/ui/data/Brave/gtk-2.0/')
# gtk.rc_parse('gtkrc')
# os.chdir(ORIGDIR)
# Load Output Manager
self.gom = om.OutputManager('gui')
#################################################################################################################################
# Create a new window
#################################################################
splash.push(("Creatin main window..."))
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_focus = True
# self.window.connect("destroy", lambda w: gtk.main_quit())
self.window.connect("delete_event", self.quit)
splash.push(("Loading..."))
gtk.settings_get_default().set_long_property("gtk-button-images", True, "main")
# Title
self.window.set_title(MAINTITLE)
# Positions
self.window.resize(800, 600)
self.window.move(25, 25)
# Maximize window
self.window.maximize()
#################################################################################################################################
# Load core...
#################################################################
#Initialize KB
splash.push(("Loading KB..."))
self.uicore = core.UIcore()
self.uicore.add_local_asn()
self.gom.set_core(self.uicore)
# Check module window prefs
setattr(self.uicore, 'SHOW_MODULE_WIN', config.SHOW_MODULE_WIN)
self.uicore.set_om(self.gom)
#################################################################################################################################
# Main VBox
#################################################################
mainvbox = gtk.VBox(False, 1)
mainvbox.set_border_width(1)
self.window.add(mainvbox)
mainvbox.show()
#################################################################################################################################
# Tool Bars HBox
#################################################################
tbhbox = gtk.HBox(False, 1)
mainvbox.pack_start(tbhbox, False, False, 1)
tbhbox.show()
#################################################################################################################################
# UIManager for MAP Toolbar
#################################################################
# to make it nice we'll put the toolbar into the handle box,
# so that it can be detached from the main window
self.handlebox = gtk.HandleBox()
tbhbox.pack_start(self.handlebox, True, True, 1)
# Create a UIManager instance
splash.push(("Creating menu and toolbar..."))
uimanager = gtk.UIManager()
accelgroup = uimanager.get_accel_group()
self.window.add_accel_group(accelgroup)
self._actiongroup = actiongroup = gtk.ActionGroup('UIManager')
# Create actions
actiongroup.add_actions([
# xml_name, icon, real_menu_text, accelerator, tooltip, callback
('Load', gtk.STOCK_OPEN, ('Load'), None, (''), self.loadKB),
('Save', gtk.STOCK_SAVE, ('Save'), None, (''), self.saveKB),
('Import', gtk.STOCK_CONVERT, ('Import'), None, (''), self.importScan),
('Edit', gtk.STOCK_EDIT, ('Edit'), None, (''), self.loadEditor),
('Proxy', gtk.STOCK_CONNECT, ('Proxy'), None, (''), gtk.main_quit),
('Web Server', gtk.STOCK_EXECUTE, ('Web'), None, ('Web'), gtk.main_quit),
#('Sniffer', gtk.STOCK_NETWORK, ('Sniffer'), None, (''), gtk.main_quit),
('Sniffer', gtk.STOCK_NETWORK, ('Sniffer'), None, (''), self.run_sniffer),
('Scapy', gtk.STOCK_HELP, ('Scapy'), None, (''), self.show_term),
('Add Target', gtk.STOCK_ADD, ('Add Target'), None, (''), self.addTarget),
('Preferences', gtk.STOCK_PREFERENCES, ('Preferences'), None, (''), self.showPref),
('Show Log', gtk.STOCK_DND, ('Show Log'), None, (''), self.show_log),
('Show KB', gtk.STOCK_DND, ('Show KB'), None, (''), self.show_kb),
('Report', gtk.STOCK_DND, ('Report'), None, (''), self.report),
('Quit', gtk.STOCK_QUIT, ('Quit'), None, (''), gtk.main_quit),
])
# Add the actiongroup to the uimanager
uimanager.insert_action_group(actiongroup, 0)
uimanager.add_ui_from_string(ui_menu)
# Toolbar
toolbar = uimanager.get_widget('/Toolbar')
toolbar.set_style(gtk.TOOLBAR_BOTH)
# Disabled until I get them working
button_proxy = uimanager.get_widget('/Toolbar/Proxy')
button_proxy.set_sensitive(False)
button_web = uimanager.get_widget('/Toolbar/Web Server')
button_web.set_sensitive(False)
# Disable if not GtkSourceView2
if not config.HAS_SOURCEVIEW:
button_edit = uimanager.get_widget('/Toolbar/Edit')
button_edit.set_sensitive(False)
# Disable if not Vte
if not config.HAS_VTE:
button_sniffer = uimanager.get_widget('/Toolbar/Sniffer')
button_sniffer.set_sensitive(False)
button_scapy = uimanager.get_widget('/Toolbar/Scapy')
button_scapy.set_sensitive(False)
self.handlebox.add(toolbar)
toolbar.show()
self.handlebox.show()
#################################################################################################################################
# Map tab
#################################################################
# Will contain on top the notebook and on bottom log window
self.vpaned = gtk.VPaned()
# Will contain xdot widget and kb window
self.hpaned = gtk.HPaned()
#################################################################
# KB Textview
#################################################################
self.textview = kbwin.KBwindow()
#self.gom.set_kbwin(self.textview)
#################################################################
# KB TreeView
#################################################################
self.treeview = kbtree.KBtree()
self.tree = self.treeview.createTree()
self.treeview.updateTree()
self.gom.set_kbwin(self.treeview)
self.tree.show()
#################################################################
# xdot map
#################################################################
from . import inxdot
# self.context = cmenu.contextMenu()
# self.context.createMenus(self.textview, self.gom)
#
# self.xdotw = inxdot.MyDotWidget(self.context, self.uicore)
# nodeMenu initialization stuff
self.uiman = nodeMenu.UIManager(self.gom, self.uicore, config)
self.uiman.set_data(None)
accel = self.uiman.get_accel_group()
self.window.add_accel_group(accel)
# graphMenu initialization stuff
self.graph_uiman = graphMenu.UIManager(self.gom, self.uicore)
#self.graph_uiman.set_data(None)
graph_accel = self.graph_uiman.get_accel_group()
self.window.add_accel_group(graph_accel)
self.xdotw = inxdot.MyDotWidget(self.uiman, self.graph_uiman, self.uicore)
setattr(self.graph_uiman, 'xdot', self.xdotw)
self.xdotw.set_size_request(900,450)
self.gom.set_map(self.xdotw)
setattr(self.uicore, 'xdot', self.xdotw)
self.uicore.getDot(doASN=False)
self.xdotw.set_dotcode( self.uicore.get_kbfield('dotcode') )
self.xdotw.zoom_image(1.0)
#################################################################
# Graph Menu
#################################################################
gmenu = graphTBar.GraphMenu(self.xdotw, self.uicore)
#################################################################
# HBox for Map and GraphMenu
#################################################################
menubox = gtk.HBox()
menubox.pack_start(self.xdotw, True, True)
menubox.pack_start(gmenu, False, False)
# Show elements
gmenu.show()
menubox.show()
#################################################################
# Scrolled Window
#################################################################
self.scrolled_window = gtk.ScrolledWindow()
self.scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.scrolled_window.set_size_request(100,100)
# Add Textview to Scrolled Window
#self.scrolled_window.add_with_viewport(self.textview)
self.scrolled_window.add_with_viewport(self.tree)
#################################################################
# Map Iface
#################################################################
bufferf = "Map"
frame = gtk.Frame(bufferf)
frame.set_border_width(5)
frame.show()
label = gtk.Label('Map')
# Test XDOT MAP
frame.add(self.hpaned)
#self.hpaned.add1(self.xdotw)
self.hpaned.add1(menubox)
self.hpaned.add2(self.scrolled_window)
self.textview.show()
# Check visibility on config preferences
if config.SHOW_KBTREE:
self.scrolled_window.show()
self.scrolled_window.is_visible = True
else:
self.scrolled_window.is_visible = False
self.hpaned.show()
self.xdotw.show()
label = gtk.Label('Map')
label.set_angle(90)
b_factory = gtk.VBox
b = b_factory(spacing=1)
i = gtk.Image()
i.set_from_stock(gtk.STOCK_NETWORK, gtk.ICON_SIZE_SMALL_TOOLBAR)
b.pack_start(label)
b.pack_start(i)
b.show_all()
#################################################################
# Notebook
#################################################################
self.notebook = gtk.Notebook()
self.notebook.set_tab_pos(gtk.POS_LEFT)
#notebook.append_page(frame, label)
self.notebook.append_page(frame, b)
self.notebook.connect("switch_page", self.onSwitch)
#################################################################################################################################
# Consoles Tab
#################################################################
label = gtk.Label('Term')
label.set_angle(90)
b_factory = gtk.VBox
b = b_factory(spacing=1)
i = gtk.Image()
i.set_from_stock(gtk.STOCK_EXECUTE, gtk.ICON_SIZE_SMALL_TOOLBAR)
b.pack_start(label)
b.pack_start(i)
b.show_all()
term_box = gtk.VBox()
term_button = gtk.Button("New Tab")
# Disable if VTE not available
if not config.HAS_VTE:
term_button.set_sensitive(False)
term_box.pack_start(term_button,False)
self.term_notebook = libTerminal.TerminalNotebook()
#term_button.connect("clicked", term_notebook.new_tab)
term_button.connect("clicked", self.new_tab)
term_box.pack_start(self.term_notebook)
setattr(self.uiman, 'termnb', self.term_notebook)
setattr(self.uiman, 'mainnb', self.notebook)
self.notebook.append_page(term_box, b)
term_box.show_all()
#################################################################################################################################
# RCE Iface
#################################################################
# xdot rce
import xdot
self.xdotr = xdot.DotWidget()
self.xdotr.set_size_request(600,512)
self.xdotr.show()
bufferf = "RCE"
frame = gtk.Frame(bufferf)
frame.set_border_width(5)
frame.set_size_request(400, 400)
label = gtk.Label('RCE')
label.set_angle(90)
b_factory = gtk.VBox
b = b_factory(spacing=1)
i = gtk.Image()
i.set_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_SMALL_TOOLBAR)
b.pack_start(label)
b.pack_start(i)
b.show_all()
self.notebook.append_page(frame, b)
# RCE graph menu
self.rmenu = rceTBar.RceMenu(self.xdotr, rcecore)
self.dasmenu = rceTBar.DasmMenu()
#################################################################################################################################
# UIManager for RCE Toolbar
#################################################################
# to make it nice we'll put the toolbar into the handle box,
# so that it can be detached from the main window
self.rcehb = gtk.HandleBox()
tbhbox.pack_start(self.rcehb, True, True, 1)
# Create a UIManager instance
rceuiman = gtk.UIManager()
rceaccelgroup = rceuiman.get_accel_group()
self.window.add_accel_group(rceaccelgroup)
self._actiongroup = actiongroup = gtk.ActionGroup('UIManager')
# Create actions
actiongroup.add_actions([
# xml_name, icon, real_menu_text, accelerator, tooltip, callback
('New', gtk.STOCK_NEW, ('New'), None, (''), self.newBin),
('Load', gtk.STOCK_OPEN, ('Load'), None, (''), self.loadBin),
('Show Log', gtk.STOCK_DND, ('Show Log'), None, (''), self.show_log),
#('Debugger', gtk.STOCK_EXECUTE, ('Debugger'), None, (''), gtk.main_quit),
('Debugger', gtk.STOCK_EXECUTE, ('Debugger'), None, (''), self.run_debugger),
#('Report', gtk.STOCK_DND, ('Report'), None, (''), gtk.main_quit),
('Quit', gtk.STOCK_QUIT, ('Quit'), None, (''), gtk.main_quit),
])
# Add the actiongroup to the rceuiman
rceuiman.insert_action_group(actiongroup, 0)
rceuiman.add_ui_from_string(rce_menu)
# Toolbar
rcetoolbar = rceuiman.get_widget('/RceToolbar')
self.rcehb.add(rcetoolbar)
self.rcehb.hide()
#################################################################
# RCE HBox and VBoxes
#################################################################
rcepaned = gtk.HPaned()
lrcevb = gtk.VBox(False, 1)
rrcevb = gtk.VBox(False, 1)
rcepaned.add1(lrcevb)
rcepaned.add2(rrcevb)
lrcevb.pack_start(self.rmenu, False, False, 1)
rrcevb.pack_start(self.dasmenu, False, False, 1)
rcepaned.show_all()
#################################################################
# Textview RCE
#################################################################
rcetv = gtk.TextView(buffer=None)
rcetv.set_wrap_mode(gtk.WRAP_NONE)
rcetv.set_editable(False)
fontdesc = pango.FontDescription("MonoSpace 10")
#fontdesc = pango.FontDescription("Purisa 10")
rcetv.modify_font(fontdesc)
rcetv.show()
self.textbuffer = rcetv.get_buffer()
# Scrolled Window
rce_scrolled_window = gtk.ScrolledWindow()
rce_scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
rce_scrolled_window.show()
# Add Textview to Scrolled Window
rce_scrolled_window.add_with_viewport(rcetv)
# Add xdotr and textview to rcehbox
lrcevb.pack_start(self.xdotr, True, True, 2)
rrcevb.pack_start(rce_scrolled_window, True, True, 2)
frame.add(rcepaned)
frame.show()
rcepaned.show()
#################################################################################################################################
# Xploit Iface
#################################################################
bufferf = "Exploit"
frame = gtk.Frame(bufferf)
frame.set_border_width(5)
frame.show()
label = gtk.Label('Exploit')
frame.add(label)
label.show()
label = gtk.Label('Exploit')
label.set_angle(90)
b_factory = gtk.VBox
b = b_factory(spacing=1)
i = gtk.Image()
i.set_from_stock(gtk.STOCK_PREFERENCES, gtk.ICON_SIZE_SMALL_TOOLBAR)
b.pack_start(label)
b.pack_start(i)
b.show_all()
self.exploitsInst = exploits.Exploits(config, self.term_notebook)
exploitsGui = self.exploitsInst.get_widget()
exploitsGui.show_all()
self.notebook.append_page(exploitsGui, b)
#mainvbox.pack_start(notebook, True, True, 1)
self.vpaned.add1(self.notebook)
self.notebook.show()
#################################################################################################################################
# Log Window
#################################################################
self.logtext = gtk.TextView(buffer=None)
self.logtext.set_wrap_mode(gtk.WRAP_NONE)
self.logtext.set_editable(False)
#self.logtext.set_size_request(40,40)
self.logbuffer = self.logtext.get_buffer()
self.logbuffer.set_text('Loading Inguma...\n')
self.logtext.show()
#################################################################
# Log Scrolled Window
#################################################################
self.log_scrolled_window = gtk.ScrolledWindow()
self.log_scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
self.log_scrolled_window.is_visible = True
#Always on bottom on change
self.vajd = self.log_scrolled_window.get_vadjustment()
self.vajd.connect('changed', lambda a, s=self.log_scrolled_window: self.rescroll(a,s))
#self.log_scrolled_window.set_size_request(40,40)
#self.logtext.set_size_request(20,20)
# Add Textview to Scrolled Window
self.log_scrolled_window.add_with_viewport(self.logtext)
# Set logtext as output for gui
self.gom.set_gui(self.logbuffer)
# Add Scrolled Log Window to Bottom Notebook
############################################
# Notebook for bottom panel
self.bottom_nb = gtk.Notebook()
self.bottom_nb.set_tab_pos(gtk.POS_LEFT)
# Icon and label for Logs tab
label = gtk.Label('Logs')
label.set_angle(90)
b_factory = gtk.VBox
b = b_factory(spacing=1)
i = gtk.Image()
i.set_from_stock(gtk.STOCK_JUSTIFY_FILL, gtk.ICON_SIZE_SMALL_TOOLBAR)
b.pack_start(label)
b.pack_start(i)
b.show_all()
self.bottom_nb.append_page(self.log_scrolled_window, b)
# Icon and label for Actions tab
label = gtk.Label('Actions')
label.set_angle(90)
b_factory = gtk.VBox
b = b_factory(spacing=1)
i = gtk.Image()
i.set_from_stock(gtk.STOCK_EXECUTE, gtk.ICON_SIZE_SMALL_TOOLBAR)
b.pack_start(label)
b.pack_start(i)
b.show_all()
# Add Threads TreeView
self.threadsInst = threadstv.ThreadsTv()
threadsGui = self.threadsInst.get_widget()
setattr(self.threadsInst, 'uicore', self.uicore)
threadsGui.show_all()
self.bottom_nb.append_page(threadsGui, b)
#self.bottom_nb.set_scrollable(True)
self.bottom_nb.set_current_page(0)
# Check visibility on config preferences
if config.SHOW_LOG:
self.bottom_nb.is_visible = True
self.bottom_nb.show()
else:
self.bottom_nb.is_visible = False
self.vpaned.add2(self.bottom_nb)
mainvbox.pack_start(self.vpaned, True, True, 1)
self.log_scrolled_window.show()
# Add threadtv to core
self.uicore.set_threadtv(self.threadsInst)
setattr(self.graph_uiman, 'threadtv', self.threadsInst)
# #################################################################################################################################
# # Progress Bar
# #################################################################
# self.progressbar = pbar.PBar()
# self.progressbar.set_stopped()
# mainvbox.pack_start(self.progressbar, False, False, 1)
#################################################################################################################################
#StatusBar
#################################################################
statusbar = gtk.Statusbar()
mainvbox.pack_end(statusbar, False, False, 1)
context_id = statusbar.get_context_id("Inguma 0.2")
message_id = statusbar.push(context_id, 'Inguma 0.2')
statusbar.show()
#################################################################################################################################
# finish it
#################################################################
self.vpaned.show()
self.window.show()
splash.destroy()
# Check for autosaved KB and ask for loading
libAutosave.checkDir()
if not libAutosave.checkKB():
print "Autosaved KB not found, skipping..."
else:
toload = libAutosave.askDialog()
if toload:
kbpath = libAutosave.getKbPath()
self.uicore.loadKB(kbpath)
libAutosave.removeKB()
# Update KB textview
self.textview.updateWin()
self.treeview.updateTree()
# Adding text to Log window
self.gom.echo( 'Loaded' , False)
else:
libAutosave.removeKB()
# Update Map
self.xdotw.set_dotcode( self.uicore.get_kbfield('dotcode') )
self.xdotw.zoom_image(1.0)
gtk.main()
def create_menubar( self):
self.menubar_box = gtk.HandleBox()
menubar = gtk.MenuBar()
self.menubar_box.add( menubar)
file_menu_item = gtk.MenuItem( '_File')
file_menu = gtk.Menu()
file_menu.set_accel_path( '<main>/File')
self.clear_item = MyImageMenuItem( '_Clear', 'gtk-clear')
self.open_item = MyImageMenuItem( '_Open', 'gtk-open')
self.save_item = MyImageMenuItem( '_Save', 'gtk-save')
self.save_as_item = MyImageMenuItem( 'E_xport...', 'gtk-save-as')
separator = gtk.SeparatorMenuItem()
self.exit_item = MyImageMenuItem( '_Quit', 'gtk-quit')
file_menu.add( self.clear_item)
file_menu.add( self.open_item)
file_menu.add( self.save_item)
file_menu.add( self.save_as_item)
file_menu.add( separator)
file_menu.add( self.exit_item)
file_menu_item.set_submenu( file_menu)
edit_menu_item = gtk.MenuItem( '_Edit')
edit_menu = gtk.Menu()
self.add_food_item = MyImageMenuItem( '_Add Food', 'gtk-add')
self.edit_food_item = MyImageMenuItem( '_Edit Food', 'gtk-edit')
self.delete_food_item = MyImageMenuItem( '_Delete Food', 'gtk-delete')
edit_menu.add( self.add_food_item)
edit_menu.add( self.edit_food_item)
edit_menu.add( self.delete_food_item)
edit_menu_item.set_submenu( edit_menu)
view_menu_item = gtk.MenuItem( '_View')
view_menu = gtk.Menu()
self.plan_item = MyImageMenuItem( '_Plan', 'gnutr-plan')
self.recipe_item = MyImageMenuItem( '_Recipe', 'gnutr-recipe')
self.food_item = MyImageMenuItem( '_Food', 'gnutr-food')
view_menu.add( self.recipe_item)
view_menu.add( self.plan_item)
view_menu.add( self.food_item)
view_menu_item.set_submenu( view_menu)
settings_menu_item = gtk.MenuItem( '_Settings')
settings_menu = gtk.Menu()
self.nutrient_goal_item = MyImageMenuItem( 'Nutrient _Goal',
'gtk-properties')
self.hide_instr_item = gtk.CheckMenuItem( 'Hide Recipe _Instructions')
settings_menu.add( self.nutrient_goal_item)
settings_menu.add( self.hide_instr_item)
settings_menu_item.set_submenu( settings_menu)
help_menu_item = gtk.MenuItem( '_Help')
help_menu = gtk.Menu()
self.manual_item = MyImageMenuItem( '_Contents', 'gtk-help')
self.about_item = MyImageMenuItem( '_About', 'gtk-about')
help_menu.add( self.manual_item)
help_menu.add( self.about_item)
help_menu_item.set_submenu( help_menu)
menubar.add( file_menu_item)
menubar.add( edit_menu_item)
menubar.add( view_menu_item)
menubar.add( settings_menu_item)
menubar.add( help_menu_item)
self.menubar_box.show_all()
def __init__(self, application):
gtk.VBox.__init__(self)
Signalizable.__init__(self)
handle = gtk.HandleBox()
handle.set_handle_position(gtk.POS_LEFT)
self.pack_start(handle, False, False)
toolbar = gtk.Toolbar()
toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
#toolbar.set_style(gtk.TOOLBAR_ICONS)
toolbar.set_style(gtk.TOOLBAR_BOTH_HORIZ)
toolbar.set_icon_size(gtk.ICON_SIZE_MENU)
handle.add(toolbar)
position = 0
button = gtk.ToolButton(gtk.STOCK_BOLD)
toolbar.insert(button, position)
position += 1
button = gtk.ToolButton(gtk.STOCK_ITALIC)
toolbar.insert(button, position)
position += 1
button = gtk.ToolButton(gtk.STOCK_UNDERLINE)
toolbar.insert(button, position)
position += 1
button = gtk.ToolButton(gtk.STOCK_STRIKETHROUGH)
toolbar.insert(button, position)
position += 1
separator = gtk.SeparatorToolItem()
toolbar.insert(separator, position)
position += 1
button = gtk.ToolButton(gtk.STOCK_JUSTIFY_LEFT)
toolbar.insert(button, position)
position += 1
button = gtk.ToolButton(gtk.STOCK_JUSTIFY_RIGHT)
toolbar.insert(button, position)
position += 1
button = gtk.ToolButton(gtk.STOCK_JUSTIFY_CENTER)
toolbar.insert(button, position)
position += 1
button = gtk.ToolButton(gtk.STOCK_JUSTIFY_FILL)
toolbar.insert(button, position)
position += 1
separator = gtk.SeparatorToolItem()
toolbar.insert(separator, position)
position += 1
button = gtk.ToolButton(gtk.STOCK_INDENT)
toolbar.insert(button, position)
position += 1
button = gtk.ToolButton(gtk.STOCK_UNINDENT)
toolbar.insert(button, position)
area = gtk.ScrolledWindow()
area.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
adjustment = area.get_vadjustment()
adjustment.need_scroll = True
adjustment.connect("changed", self.update_adjustment)
adjustment.connect("value-changed", self.update_value)
entry = gtk.TextView()
entry.connect_after("move-cursor", self.move)
entry.connect("focus-in-event", self.focus_in)
entry.connect("focus-out-event", self.focus_out)
entry.set_size_request(-1, 100)
self.buffer = entry.get_buffer()
#self.disconnect_handler = buffer.connect("changed", self.changed)
self.buffer.connect("insert-text", self.update_scroll, entry)
self.buffer.connect("changed", self.changed)
#area.add_with_viewport(entry)
area.add(entry)
#entry.set_wrap_mode(gtk.WRAP_WORD_CHAR)
entry.set_wrap_mode(gtk.WRAP_CHAR)
self.add(area)
# from application import Application
# self.application = Application()
self.application = application
self.install_signal("cursor-moved")
def __init__(self):
# Here is our main window (a dialog) and a handle for the handlebox
# Ok, we need a toolbar, an icon with a mask (one for all of
# the buttons) and an icon widget to put this icon in (but
# we'll create a separate widget for each button)
# create a new window with a given title, and nice size
dialog = gtk.Dialog()
dialog.set_title("GTKToolbar Tutorial")
dialog.set_size_request(450, 250)
dialog.set_resizable(True)
# typically we quit if someone tries to close us
dialog.connect("delete_event", self.delete_event)
# to make it nice we'll put the toolbar into the handle box,
# so that it can be detached from the main window
handlebox = gtk.HandleBox()
dialog.vbox.pack_start(handlebox, False, False, 5)
# toolbar will be horizontal, with both icons and text, and
# with 5pxl spaces between items and finally,
# we'll also put it into our handlebox
toolbar = gtk.Toolbar()
toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
toolbar.set_style(gtk.TOOLBAR_BOTH)
toolbar.set_border_width(5)
handlebox.add(toolbar)
# our first item is <close> button
iconw = gtk.Image() # icon widget
iconw.set_from_file("gtk.xpm")
close_button = toolbar.append_item(
"Close", # button label
"Closes this app", # this button's tooltip
"Private", # tooltip private info
iconw, # icon widget
self.delete_event) # a signal
toolbar.append_space() # space after item
# now, let's make our radio buttons group...
iconw = gtk.Image() # icon widget
iconw.set_from_file("gtk.xpm")
icon_button = toolbar.append_element(
gtk.TOOLBAR_CHILD_RADIOBUTTON, # type of element
None, # widget
"Icon", # label
"Only icons in toolbar", # tooltip
"Private", # tooltip private string
iconw, # icon
self.radio_event, # signal
toolbar) # data for signal
toolbar.append_space()
self.icon_button = icon_button
# following radio buttons refer to previous ones
iconw = gtk.Image() # icon widget
iconw.set_from_file("gtk.xpm")
text_button = toolbar.append_element(
gtk.TOOLBAR_CHILD_RADIOBUTTON,
icon_button,
"Text",
"Only texts in toolbar",
"Private",
iconw,
self.radio_event,
toolbar)
toolbar.append_space()
self.text_button = text_button
iconw = gtk.Image() # icon widget
iconw.set_from_file("gtk.xpm")
both_button = toolbar.append_element(
gtk.TOOLBAR_CHILD_RADIOBUTTON,
text_button,
"Both",
"Icons and text in toolbar",
"Private",
iconw,
self.radio_event,
toolbar)
toolbar.append_space()
self.both_button = both_button
both_button.set_active(True)
# here we have just a simple toggle button
iconw = gtk.Image() # icon widget
iconw.set_from_file("gtk.xpm")
tooltips_button = toolbar.append_element(
gtk.TOOLBAR_CHILD_TOGGLEBUTTON,
None,
"Tooltips",
"Toolbar with or without tips",
"Private",
iconw,
self.toggle_event,
toolbar)
toolbar.append_space()
tooltips_button.set_active(True)
# to pack a widget into toolbar, we only have to
# create it and append it with an appropriate tooltip
entry = gtk.Entry()
toolbar.append_widget(entry, "This is just an entry", "Private")
# well, it isn't created within the toolbar, so we must still show it
entry.show()
# that's it ! let's show everything.
toolbar.show()
handlebox.show()
dialog.show()
def __init__(self):
self.cur_filename=''
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.connect("destroy", self.destroy)
self.window.set_title("python Mozhi")
self.window.set_border_width(2)
self.window.set_size_request(600, 400)
#-----------------------------------#
# file Selection window #
#-----------------------------------#
self.filew = gtk.FileSelection("File selection")
self.filew.ok_button.connect("clicked", self.save_dialog_ok_click)
self.filew.cancel_button.connect("clicked",lambda w: self.filew.destroy())
self.filew.set_filename("mozhi.moz")
#-----------------------------------#
box=gtk.VBox(False,0)
#--------------------------#
# menu bar #
#--------------------------#
menubar = self.get_main_menu()
box.pack_start(menubar, False, True, 0)
menubar.show()
#--------------------------#
#--------------------------#
# Toolbar #
#--------------------------#
handlebox = gtk.HandleBox()
box.pack_start(handlebox, False, False, 5)
toolbar = gtk.Toolbar()
toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
toolbar.set_style(gtk.TOOLBAR_BOTH)
toolbar.set_border_width(5)
handlebox.add(toolbar)
iconw = gtk.Image() # icon widget
iconw.set_from_file("img/exit.png")
close_button = toolbar.append_item(
"Close", # button label
"Closes this app", # this button's tooltip
"Private", # tooltip private info
iconw, # icon widget
self.destroy) # a signal
toolbar.append_space() # space after item
iconw = gtk.Image() # icon widget
iconw.set_from_file("img/save.png")
tooltips_button = toolbar.append_item(
"Save","Save the Translation",
"Private",iconw,self.save_trans)
toolbar.show()
handlebox.show()
#-----------------------------------#
#--------------------------#
# TextView #
# to show the translated #
# malayalam text #
#--------------------------#
sw_mal = gtk.ScrolledWindow()
sw_mal.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self.textmal = gtk.TextView()
self.textmalbuffer = self.textmal.get_buffer()
self.textmal.set_editable(False)
self.textmal.set_wrap_mode(gtk.WRAP_WORD)
self.textmal.set_border_width(2)
self.textmal.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(200,192,93))
sw_mal.add(self.textmal)
self.textmal.show()
box.pack_start(sw_mal)
sw_mal.show()
self.sw_mal=sw_mal
#--------------------------#
seperator=gtk.HSeparator()
box.pack_start(seperator,False,True,5)
seperator.show()
#--------------------------#
# TextView #
# for the input of #
# manglish text #
#--------------------------#
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self.texteng = gtk.TextView()
self.textengbuffer = self.texteng.get_buffer()
self.texteng.connect("key_release_event",self.txt_keypress)
self.texteng.set_wrap_mode(gtk.WRAP_WORD)
sw.add(self.texteng)
self.texteng.show()
box.pack_start(sw)
sw.show()
self.texteng.grab_focus()
#--------------------------#
# This packs the box into the window (a GTK container).
self.window.add(box)
box.show()
# The final step is to display this newly created widget.
self.window.show()
def __init__(self, plugin=None, quit_cb=None):
gtk.EventBox.__init__(self)
self.search_string = None
self.last_search_iter = None
self.completion_win = None
self.insert_string = None
self.cursor_iter = None
self.plugin = plugin
self.wins = []
self.current_word = ""
self.wl = []
self.ac_w = None
self.set_size_request(470, 300)
self.connect("delete_event", self.file_exit)
self.quit_cb = quit_cb
self.vbox = gtk.VBox()
self.add(self.vbox)
self.vbox.show()
self.menubar, self.toolbar = self.create_menu()
hdlbox = gtk.HandleBox()
self.vbox.pack_start(hdlbox, expand=False)
hdlbox.show()
hdlbox.add(self.menubar)
self.menubar.show()
hdlbox = gtk.HandleBox()
self.vbox.pack_start(hdlbox, expand=False)
hdlbox.show()
hdlbox.add(self.toolbar)
self.toolbar.show()
self.vpaned = gtk.VPaned()
self.vbox.pack_start(self.vpaned, expand=True, fill=True)
self.vpaned.show()
self.vbox1 = gtk.VBox()
self.vpaned.add1(self.vbox1)
self.vbox.show()
self.vbox1.show()
self.hpaned = gtk.HPaned()
self.vbox1.pack_start(self.hpaned, True, True)
self.hpaned.set_border_width(5)
self.hpaned.show()
# the gtksourceview
lm = gtksourceview.SourceLanguagesManager()
buff = CulebraBuffer()
self.new = True
buff.set_data('languages-manager', lm)
# self.editor = gtksourceview.SourceView(buff)
self.editor = CulebraView(buff)
self.plugin.pida.mainwindow.connect('delete-event', self.file_exit)
font_desc = pango.FontDescription('monospace 10')
if font_desc:
self.editor.modify_font(font_desc)
buff.connect('insert-text', self.insert_at_cursor_cb)
buff.set_data("save", False)
manager = buff.get_data('languages-manager')
language = manager.get_language_from_mime_type("text/x-python")
buff.set_highlight(True)
buff.set_language(language)
scrolledwin2 = gtk.ScrolledWindow()
scrolledwin2.add(self.editor)
self.editor.set_auto_indent(True)
self.editor.set_show_line_numbers(True)
self.editor.set_show_line_markers(True)
self.editor.set_tabs_width(4)
self.editor.connect('key-press-event', self.text_key_press_event_cb)
self.editor.connect('move-cursor', self.move_cursor)
self.editor.set_margin(80)
self.editor.set_show_margin(True)
self.editor.set_smart_home_end(True)
self.editor.set_highlight_current_line(True)
scrolledwin2.show()
self.editor.show()
self.editor.grab_focus()
buff.set_data('filename', "untitled.py")
self.wins.append([buff, "untitled.py"])
self.current_buffer = 0
self.hpaned.add2(scrolledwin2)
self.hpaned.set_position(200)
self.dirty = 0
self.clipboard = gtk.Clipboard(selection='CLIPBOARD')
self.dirname = "."
# sorry, ugly
self.filetypes = {}
return
