def __init__(self, applet):
self.applet = applet
applet.tooltip.set("Pandora")
self.dialog = applet.dialog.new("main")
self.moz = gtkmozembed.MozEmbed()
try:
pandurl = self.applet.settings["url"]
except:
pandurl = self.returnurl()
self.applet.settings["url"] = pandurl
self.moz.set_size_request(640, 250)
try:
site = urllib2.urlopen(pandurl)
meta = site.info()
if meta['Content-Type'] == 'application/x-shockwave-flash':
self.moz.load_url(pandurl)
else:
return Error
except:
pandurl = self.returnurl()
self.applet.settings["url"] = pandurl
self.moz.load_url(pandurl)
self.dialog.add(self.moz)
self.setup_context_menu()
applet.connect("button-press-event", self.button_press_event_cb)
def __init__(self):
gtk.Window.__init__(self)
self.connect("destroy", gtk.main_quit)
split = gtk.HPaned()
self.add(split)
self.movies = gtk.TreeView(gtk.ListStore(str, str))
self.movies.append_column(
gtk.TreeViewColumn("Movies", gtk.CellRendererText(), text=0))
self.movies.connect("row-activated", self.on_row_activated)
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scroll.add(self.movies)
searchbox = gtk.HBox()
txtsearch = gtk.Entry()
searchbox.pack_start(txtsearch, True, True)
btnsearch = gtk.Button("Search")
searchbox.pack_start(btnsearch, False)
btnsearch.connect("clicked",
lambda b: self.query(txtsearch.get_text()))
leftside = gtk.VBox()
leftside.pack_start(searchbox, False)
leftside.pack_start(scroll, True)
split.add1(leftside)
self.browse = gtkmozembed.MozEmbed()
split.add2(self.browse)
self.show_all()
def __init__(self):
self.moz = gtkmozembed.MozEmbed()
win = gtk.Window()
win.add(self.moz)
win.show_all()
self.moz.load_url('http://www.pygtk.org')
def __init__(self, urls, screen, thumbnail, delay, outfile):
self.parent = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.parent.set_border_width(10)
self.urls = urls
self.delay = delay
# Get resoltion information
(x,y) = screen.split('x')
x = int(x)
y = int(y)
(t_x, t_y) = thumbnail.split('x')
t_x = int(t_x)
t_y = int(t_y)
# Calculate the x scale factor
scale_x = float(t_x) / x
scale_y = float(t_y) / y
self.t_x = t_x
self.t_y = t_y
self.scale = scale_x
self.widget = gtkmozembed.MozEmbed()
self.widget.set_size_request(x + 18, y)
# Connect signal
self.widget.connect("net_stop", self.on_net_stop)
if outfile:
(self.outfile_base, ignore) = outfile.split('.png')
else:
self.outfile_base = None
self.parent.add(self.widget)
self.url_num = 0
self.load_next_url()
self.parent.show_all()
def post_show_init(self, widget):
if utils.RUNNING_HILDON:
logging.debug("Hildon: Not using ajax view")
self._USING_AJAX = False
else:
self._USING_AJAX = True
if utils.HAS_GCONF:
try:
import gconf
except:
from gnome import gconf
self._conf = gconf.client_get_default()
self._conf.notify_add('/desktop/gnome/interface/font_name',self._gconf_reset_moz_font)
self._reset_moz_font()
utils.init_gtkmozembed()
gtkmozembed.set_profile_path(self._home, 'gecko')
gtkmozembed.push_startup()
self._moz = gtkmozembed.MozEmbed()
self._moz.connect("new-window", self._new_window)
self._moz.connect("link-message", self._link_message)
self._moz.connect("open-uri", self._link_clicked)
self._moz.connect("realize", self._realize, True)
self._moz.connect("unrealize", self._realize, False)
self._moz.connect("js-status", self._console_message)
widget.add_with_viewport(self._moz)
self._moz.show()
def show_browser(self):
"""Embed Mozilla widget into Druid."""
widget = gtkmozembed.MozEmbed()
widget.load_url("http://www.gnome.org/")
widget.get_location()
self.main_window.get_widget('vbox1').add(widget)
widget.show()
def __init__(self, w3af, parentView):
'''Make MozRenderingView object.'''
super(MozRenderingView, self).__init__(w3af, parentView)
self._renderingWidget = gtkmozembed.MozEmbed()
print self._renderingWidget
swRenderedHTML = gtk.ScrolledWindow()
swRenderedHTML.add(self._renderingWidget)
swRenderedHTML.show_all()
self.pack_start(swRenderedHTML)
def __init__(self):
self._embed_widget = None
print "browser using: %s" % EW_BACKEND
if EW_BACKEND == "webkit":
self._embed_widget = webkit.WebView()
#disable flash to stop segfault on destroy
self._embed_widget.get_settings().props.enable_plugins = False
elif EW_BACKEND == "gtkmozembed":
self._embed_widget = gtkmozembed.MozEmbed()
def __init__(self, w3af, parentView):
"""Make MozRenderingView object."""
super(MozRenderingView, self).__init__(w3af, parentView)
self._renderingWidget = gtkmozembed.MozEmbed()
sw_rendered_html = gtk.ScrolledWindow()
sw_rendered_html.add(self._renderingWidget)
sw_rendered_html.show_all()
self.pack_start(sw_rendered_html)
def __init__(self):
self.moz = gtkmozembed.MozEmbed()
win = gtk.Window()
win.set_default_size(800, 800)
win.add(self.moz)
gtkmozembed.set_profile_path("/tmp", "foobar")
win.show_all()
self.moz.load_url('http://hatfull12.bio.pitt.edu:8080')
data = '<html><head><title>Hello</title></head><body>pygtk dev</body></html>'
self.moz.render_data(data, long(len(data)), 'file:///', 'text/html')
def create_mozilla_control(self):
webview = gtkmozembed.MozEmbed()
print ">>>>>>>>>>>>>> MozEmbed::::", str(webview.__dict__)
# webview.set_full_content_zoom(True)
# webview.connect_after("populate-popup", self.create_webview_popup)
# Open in new browser handler (this intercepts all requests)
# webview.connect("hovering-over-link", self.hover_link)
webview.connect('title', self.title_changed_mozilla)
return webview
def start(self):
def on_destroy(mozembed):
gtk.main_quit()
def on_resize(mozembed):
size = self.win.get_size()
width = size[0]
height = size[1]
if self.site_config.has_key("width") and self.site_config["width"] == width and self.site_config.has_key("height") and self.site_config["height"] == height:
return
self.site_config["width"] = width
self.site_config["height"] = height
config.save_site_config(self.site_config, None)
def on_open_uri(mozembed, uri):
print "Requested URI: " + uri
return False
def on_new_window(mozembed, retval, chromemask):
url = mozembed.get_link_message()
if not url:
print "ERROR: new-window without URL"
return None
print "Calling default web browser: " + url
webbrowser.open(url)
return None
site_dir = config.get_site_dir(self.site)
print "Starting site: " + site_dir
self.updateSelf()
gtkmozembed.set_profile_path(site_dir, "profile")
self.mozembed = gtkmozembed.MozEmbed()
self.mozembed.load_url(self.url)
self.mozembed.connect("open-uri", on_open_uri)
self.mozembed.connect("new-window", on_new_window)
self.mozembed.show()
self.win = gtk.Window()
self.win.set_title(self.title)
self.win.set_default_size(self.width, self.height)
self.win.set_position(gtk.WIN_POS_CENTER)
icon_path = config.get_site_icon_path(self.site)
if icon_path:
self.win.set_icon_from_file(icon_path)
self.win.set_icon_name(config.get_site_icon_name(self.site))
self.win.add(self.mozembed)
self.win.connect("destroy", on_destroy)
self.win.connect('check-resize', on_resize)
self.win.show_all()
gtk.main()
def init_gecko_browser(self):
""" Initialize a Gecko web browser
Python GtkMozembed Reference Manual:
http://www.pygtk.org/pygtkmozembed/index.html
"""
import gtkmozembed
if hasattr(gtkmozembed, 'set_profile_path'):
gtkmozembed.set_profile_path(self.get_screenlet_dir(), self.gecko_browser_profile)
else:
gtkmozembed.gtk_moz_embed_set_profile_path(self.get_screenlet_dir(), self.gecko_browser_profile)
self.gecko_browser = gtkmozembed.MozEmbed()
def __init__(self):
self.moz = gtkmozembed.MozEmbed()
win = gtk.Window()
win.set_title('Abelo')
win.set_position(gtk.WIN_POS_CENTER)
win.connect('destroy', destroy)
win.add(self.moz)
win.show_all()
b = self.moz.load_url('http://localhost:3000')
self.moz.set_size_request(800, 600)
Popen(["/home/smurf/projetos/abelo/lib/pyro_deamon/pyro_server.py"])
def show_browser(self):
"""Embed Mozilla widget into a vbox."""
widget = gtkmozembed.MozEmbed()
local_uri = os.path.join(PATH, 'htmldocs/', self.distro, 'index.html')
try:
widget.load_url("file://" + local_uri)
except:
widget.load_url("http://www.ubuntulinux.org/")
widget.get_location()
self.browser_vbox.add(widget)
widget.show()
def show_browser(self):
"""Embed Mozilla widget into Druid."""
widget = gtkmozembed.MozEmbed()
try:
widget.load_url("file://" + PATH + '/htmldocs/' + self.distro +
'/index.html')
except:
widget.load_url("http://www.ubuntulinux.org/")
widget.get_location()
self.browser_vbox.add(widget)
widget.show()
def __init__(self):
Renderer.__init__(self)
if hasattr(gtkmozembed, 'set_profile_path'):
set_profile_path = gtkmozembed.set_profile_path
else:
set_profile_path = gtkmozembed.gtk_moz_embed_set_profile_path
set_profile_path(MOZEMBED_PATH, MOZEMBED_SUBPATH)
self.__set_mozembed_proxy()
self.window = gtkmozembed.MozEmbed()
self.browser = MOZILLA
self.title = None
self.handler = self.window.connect("net-stop", self.page_loaded)
self.window.connect("title", self.get_title)
self.fct = None
def __init__(self,url=None,w=800,h=600,title="",fullscreen=False, headless=False,transparent=False,embedIn=None): Browser.__init__(self,url,w,h,title,fullscreen,headless,transparent,embedIn) self._url=None self.browser=gtkmozembed.MozEmbed() # Fun with GTK window=gtk.ScrolledWindow() box=gtk.VBox(homogeneous=False,spacing=0) window.add(box) box.pack_start(self.browser,expand=True,fill=True,padding=0) window.set_default_size(w,h) window.show_all() gtk.gdk.threads_init() thread.start_new_thread(gtk.main,()) if url is not None: self.url=url
def setup_ui (self):
"""
Hold a source box, a mozilla browser and a destination box
"""
self.can_translate = False
# Source box
hbox = gtk.HBox (spacing=6)
label = gtk.Label ("URL:")
label.show ()
hbox.pack_start (label, False)
self.source_url = gtk.Entry ()
self.source_url.connect ('changed', self.on_source_url_changed)
self.entry_activate_handler = self.source_url.connect ('activate', lambda *args: self.translate_button.clicked ())
self.source_url.handler_block (self.entry_activate_handler)
self.source_url.show ()
hbox.pack_start (self.source_url)
hbox.pack_start (self.source_url_buttons (), False)
hbox.show ()
self.layout.pack_start (hbox, False)
# Browser
self.browser = gtkmozembed.MozEmbed ()
self.browser.connect ('net-stop', self.on_browser_net_stop)
self.browser.show ()
self.layout.pack_start (self.browser)
# Destination box
self.dest_url_box = gtk.EventBox ()
self.dest_url_box.set_visible_window (False)
self.dest_url_box.modify_bg (gtk.STATE_NORMAL, self.DESTINATION_COLOR)
self.dest_url_box.set_sensitive (False)
hbox = gtk.HBox (spacing=6)
self.dest_url_box.add (hbox)
self.dest_url = gtk.LinkButton ("", "Translated URL")
self.dest_url.show ()
gtk.link_button_set_uri_hook (self.dest_url_hook)
hbox.pack_start (self.dest_url)
hbox.pack_start (self.dest_url_buttons (), False)
hbox.show ()
self.layout.pack_start (self.dest_url_box, False)
def __init__(self):
xml = gtk.glade.XML("/usr/share/lemurae/lemurae.glade", "appw")
xml.signal_autoconnect(self)
# Widgets
self.word = xml.get_widget("Palabra")
self.frame = xml.get_widget("Marco")
self.appw = xml.get_widget("appw")
self.back_button = xml.get_widget("bAtras")
self.next_button = xml.get_widget("bAdelante")
self.statusbar = xml.get_widget("statusbar")
self.web_control = gtkmozembed.MozEmbed()
self.__set_widgets()
self.appw.show_all()
def build_widget(self):
w = gtkmozembed.MozEmbed()
# A profile must be initialized, cf
# http://www.async.com.br/faq/pygtk/index.py?req=show&file=faq19.018.htp
gtkmozembed.set_profile_path("/tmp", "foobar")
def update_location(c):
if self.notify:
self.notify(url=self.get_url())
return False
def update_label(c):
if self.notify:
self.notify(label=c.get_link_message())
return False
w.connect('location', update_location)
w.connect('link-message', update_label)
self.component = w
return w
def show_browser(self):
"""Embed Mozilla widget into a vbox."""
import gtkmozembed
widget = gtkmozembed.MozEmbed()
local_uri = os.path.join(PATH, 'htmldocs/', self.distro, 'index.html')
# Loading branding if htmldocs/ brand exists. In other hand Ubuntu Project
# website is loaded
try:
widget.load_url("file://" + local_uri)
except:
widget.load_url("http://www.ubuntulinux.org/")
widget.get_location()
self.browser_vbox.add(widget)
widget.show()
# Setting Normal mouse cursor
self.live_installer.window.set_cursor(None)
def __init__(self, parent=None):
gtk.Window.__init__(self)
self.moz = gtkmozembed.MozEmbed()
self.dtb = amiscore.Dtb()
try:
self.set_screen(parent.get_screen())
except AttributeError:
self.connect('destroy', lambda *w: gtk.main_quit())
self.set_title("AMIS")
vbox = gtk.VBox(False, 0)
self.add(vbox)
filemenulist = gtk.Menu()
open = gtk.MenuItem("open")
quit = gtk.MenuItem("quit")
filemenulist.append(open)
filemenulist.append(quit)
file = gtk.MenuItem("file")
file.set_submenu(filemenulist)
menubar = gtk.MenuBar()
menubar.append(file)
vbox.pack_start(menubar, expand=False)
hpaned = gtk.HPaned()
model = gtk.TreeStore(gobject.TYPE_PYOBJECT, gobject.TYPE_STRING)
treeitem = {"hello": "hi"}
iter = model.insert_before(None, None)
model.set_value(iter, 0, treeitem)
treeview = gtk.TreeView(model)
hpaned.add1(treeview)
hpaned.add2(self.moz)
vbox.pack_end(hpaned)
self.show_all()
open_book(self, None)
def __init__(self):
self.moz = gtkmozembed.MozEmbed()
box = gtk.VBox(False, 0)
win = gtk.Window()
win.add(box)
hbox = gtk.HBox(False, 0)
box.pack_start(hbox, False, False)
hbox.show()
box.pack_start(self.moz, True, True, 0)
self.moz.show()
self.moz.load_url(homedir)
self.moz.set_size_request(650, 550)
title = self.moz.get_title()
win.set_title("RGB/HEX Color Picker")
win.show_all()
def __init__(self, urls, screen, thumbnail, delay, outfile, path, allow_javascript):
self.parent = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.parent.set_border_width(0)
self.panel = gtk.VPaned()
self.top_panel = gtk.VPaned()
self.urlbar = gtk.Label()
self.titlebar = gtk.Label()
self.top_panel.add1(self.titlebar)
self.top_panel.add2(self.urlbar)
self.panel.add1(self.top_panel)
self.parent.add(self.panel)
self.urls = urls
self.delay = delay
self.path = path
self.thumbnail_resolution = thumbnail
self.allow_javascript = allow_javascript
# Get resoltion information
(x,y) = screen.split('x')
x = int(x)
y = int(y)
self.widget = gtkmozembed.MozEmbed()
self.widget.set_size_request(x-20, y-20)
self.widget.set_chrome_mask(gtkmozembed.FLAG_ALLCHROME-gtkmozembed.FLAG_SCROLLBARSON)
# Connect signal
self.widget.connect("net_stop", self.on_net_stop)
self.widget.connect("title", self.update_titlebar)
if outfile:
(self.outfile_base, ignore) = outfile.split('.png')
else:
self.outfile_base = None
self.panel.add2(self.widget)
if screen == get_screen_resolution():
self.parent.fullscreen()
self.parent.show_all()
self.url_num = 0
self.load_next_url()
def __init__(self, URL=None, parent=None):
if parent == None:
self.parent = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.parent.set_border_width(10)
else:
self.parent = parent
# Initialize the widgets...
self.widget = gtkmoz.MozEmbed()
self.widget.set_size_request(816, 600)
# Connect signals
self.widget.connect("net_stop", self.on_net_stop)
self.widget.connect("progress", self.on_progress)
self.parent.add(self.widget)
if URL != None:
self.widget.load_url(URL)
self.parent.show_all()
self.countdown = 3
def setup_ui(self):
accelgroup = gtk.AccelGroup()
self.window.add_accel_group(accelgroup)
accelgroup.connect_group(gtk.keysyms.g, gtk.gdk.MOD1_MASK,
gtk.ACCEL_VISIBLE, self.on_g_accel)
accelgroup.connect_group(gtk.keysyms.n, gtk.gdk.MOD1_MASK,
gtk.ACCEL_VISIBLE, self.on_n_accel)
accelgroup.connect_group(gtk.keysyms.i, gtk.gdk.MOD1_MASK,
gtk.ACCEL_VISIBLE, self.on_i_accel)
accelgroup.connect_group(gtk.keysyms.F1, 0, gtk.ACCEL_VISIBLE,
self.on_f1_accel)
accelgroup.connect_group(gtk.keysyms.F1, gtk.gdk.SHIFT_MASK,
gtk.ACCEL_VISIBLE, self.on_shift_f1_accel)
accelgroup.connect_group(gtk.keysyms.c, gtk.gdk.MOD1_MASK,
gtk.ACCEL_VISIBLE, self.on_c_accel)
accelgroup.connect_group(gtk.keysyms.a, gtk.gdk.MOD1_MASK,
gtk.ACCEL_VISIBLE, self.on_a_accel)
accelgroup.connect_group(gtk.keysyms.e, gtk.gdk.MOD1_MASK,
gtk.ACCEL_VISIBLE, self.on_e_accel)
if have_mozembed:
self.mozembed = gtkmozembed.MozEmbed()
self.mozembed.load_url("file://" + mfeconst.helpfile +
"#using-cli")
self.optsscrolled.add_with_viewport(self.mozembed)
self.mozembed.show()
self.mozembed.connect("location", self.location_changed)
# ensure buttons have images...
settings = gtk.settings_get_default()
settings.set_long_property("gtk-button-images", True, "mfe")
text = self.aboutlabel.get_text() % (
mfeconst.infoheader, mfeutil.get_med_version(self.runner.mednafen))
self.aboutlabel.set_markup(text)
try:
self.snapchooser.set_current_folder(
os.path.expanduser(self.config["snap_path"]))
except:
pass
try:
self.savechooser.set_current_folder(
os.path.expanduser(self.config["save_path"]))
except:
pass
try:
self.statechooser.set_current_folder(
os.path.expanduser(self.config["state_path"]))
except:
pass
try:
self.moviechooser.set_current_folder(
os.path.expanduser(self.config["movie_path"]))
except:
pass
try:
self.cheatchooser.set_current_folder(
os.path.expanduser(self.config["cheat_path"]))
except:
pass
try:
self.palettechooser.set_current_folder(
os.path.expanduser(self.config["palette_path"]))
except:
pass
self.snapcheck.set_active(self.config["snap_path_sar"])
self.savecheck.set_active(self.config["save_path_sar"])
self.statecheck.set_active(self.config["state_path_sar"])
self.moviecheck.set_active(self.config["movie_path_sar"])
self.cheatcheck.set_active(self.config["cheat_path_sar"])
self.palettecheck.set_active(self.config["palette_path_sar"])
self.on_snapcheck_toggled(self.snapcheck)
self.on_savecheck_toggled(self.savecheck)
self.on_statecheck_toggled(self.statecheck)
self.on_moviecheck_toggled(self.moviecheck)
self.on_cheatcheck_toggled(self.cheatcheck)
self.on_palettecheck_toggled(self.palettecheck)
self.fscheck.set_active(self.config["fullscreen"])
self.soundcheck.set_active(self.config["sound"])
self.cheatscheck.set_active(self.config["cheats"])
self.glcheck.set_active(self.config["opengl"])
self.vsynccheck.set_active(self.config["vsync"])
# self.priorityspin.set_value(self.config["priority"])
self.autosavecheck.set_active(self.config["autosave"])
self.manualoptsentry.set_text(self.config["options"])
self.monocheck.set_active(self.config["mono"])
self.sratecombo.set_active(self.config["srate"])
self.sdrivercombo.set_active(self.config["sdriver"])
self.volumescale.set_value(self.config["volume"])
self.on_soundcheck_toggled(self.soundcheck)
self.on_glcheck_toggled(self.glcheck)
self.on_fscheck_toggled(self.fscheck)
self.xscalespin.set_value(self.config["xscale"])
self.yscalespin.set_value(self.config["yscale"])
self.xresspin.set_value(self.config["xres"])
self.yresspin.set_value(self.config["yres"])
self.stretchcheck.set_active(self.config["stretch"])
self.bilinearcheck.set_active(self.config["interpolate"])
self.scanlinespin.set_value(self.config["scanlines"])
# self.vblurcheck.set_active(self.config["vblur"])
# self.accumulatecheck.set_active(self.config["accumulate"])
self.amountspin.set_value(self.config["amount"])
self.filtercombo.set_active(self.config["filter"])
self.shadercombo.set_active(self.config["shader"])
# self.on_vblurcheck_toggled(self.vblurcheck)
self.backendcombo.set_active(self.config["backend"])
if self.config["rom"]:
self.guess_backend()
self.romchooser.set_filename(self.config["rom"])
# this comes after self.guess_backend() so it is accurate
self.set_monocheck_sensitive()
def create_browser():
return gtkmozembed.MozEmbed()
def __init__(self):
self.browser = gtkmozembed.MozEmbed()
def __init__(self, p_mwindow):
"""
p_mwindow: representa el MainWindow.
Constructor de la clase HelpWindow.
"""
self.__searching_stop = False
self.__searching_ocupate = False
self.__wait = False
self.__update = False
self.__buscar = False
self.__window_search = None
self.__xml4 = None
self.__letras_alfabeto = []
self.__lista_labels = []
self.__comando_actual = ""
self.__page_select_search_result = ""
self.__command = ""
self.path2 = os.path.join(os.getcwd(), os.path.dirname(sys.argv[0]),\
"images", 'guiHelp.glade')
self.__xml2 = gtk.glade.XML(self.path2, 'window2')
self.__xml2.signal_autoconnect(self)
self.__window2 = self.__xml2.get_widget('window2')
self.__window2.maximize()
self.__hpaned2 = self.__xml2.get_widget('hpaned2')
# Tener una referencia del mwindow
self.__mwindow = p_mwindow
# Boton reabrir panel de busqueda lateral izquierdo.
self.__show_help_navigator = self.__xml2.get_widget('toolbutton31')
# Boton Stop
self.__stop_button = self.__xml2.get_widget('toolbutton3')
self.__stop_button.set_sensitive(False)
self.__notebook_sections = self.__xml2.get_widget('notebook2')
self.__notebook_sections.set_menu_label_text(
self.__notebook_sections.get_nth_page(2), "Search Results")
self.__notebook_view = self.__xml2.get_widget('notebook3')
# Ocultar tags del notebook3 que representa la derecha de la ventana.
self.__notebook_view.set_show_tabs(False)
# Campo donde se entra el comando a buscar.
self.__entry_Index = self.__xml2.get_widget('entry1')
# Campo para buscar en el Search Result.
self.__entry_Search = self.__xml2.get_widget('entry4')
# Respuesta del Search.
self.__textview_index = self.__xml2.get_widget('textview1')
self.__textview_index.set_editable(False)
self.__textview_index.modify_font(
pango.FontDescription("monospace Expanded 10"))
color = gtk.gdk.color_parse("blue")
self.__textview_index.get_buffer().create_tag("blue_foreground",
foreground_gdk=color)
color = gtk.gdk.color_parse("red")
self.__textview_index.get_buffer().create_tag("red_foreground",
foreground_gdk=color)
self.__textview_index.get_buffer().create_tag("bold",
weight=pango.WEIGHT_BOLD)
# Combobox para poner el historial del Contents.
self.__combo_history_list = gtk.ListStore(str, object)
self.__combo_history = gtk.ComboBox(self.__combo_history_list)
comboCell = gtk.CellRendererText()
self.__combo_history.pack_start(comboCell, True)
self.__combo_history.add_attribute(comboCell, 'text', 0)
self.__combo_history.show_all()
self.__combo_history.connect("changed", self.on_comboboxentry2_changed)
self.__xml2.get_widget("hbox1").pack_start(self.__combo_history, True,
True, 0)
# Verifica si se cambio de elemento en el combo_history.
self.__combo_change = False
# Representa el arbol en la seccion Search Result.
self.__treeview_search = self.__xml2.get_widget('treeview6')
self.__liststore_search = gtk.ListStore(str)
self.__treeview_search.set_model(self.__liststore_search)
column = gtk.TreeViewColumn("Title")
cell = gtk.CellRendererText()
column.pack_start(cell)
column.set_attributes(cell, text=0)
column.set_sort_column_id(0)
self.__treeview_search.append_column(column)
self.write_label()
self.color_label(self.__lista_labels[0])
self.__treeview_index = self.__xml2.get_widget('treeview5')
self.__liststore_index = gtk.ListStore(str)
self.__treeview_index.set_model(self.__liststore_index)
column = gtk.TreeViewColumn("Title")
cell = gtk.CellRendererText()
column.pack_start(cell)
column.set_attributes(cell, text=0)
column.set_sort_column_id(0)
self.__treeview_index.append_column(column)
self.__generate_command = GenerateComands(self)
self.__generate_command.show_help()
# Componente Web.
gtkmozembed.push_startup() # Necesaria para que pinche el gtkmozembed.
self.__web_contents = gtkmozembed.MozEmbed()
self.__web_search = gtkmozembed.MozEmbed()
self.__dire = os.path.join(os.getcwd(), os.path.dirname(sys.argv[0]))
self.__pagina_seleccionada_contents = 'octave'
self.dir_page()
self.__web_contents.show()
# Adicionar al hbox el componente Web del Contents y Search Result.
self.__xml2.get_widget('hbox10').add(self.__web_contents)
self.__xml2.get_widget('hbox11').add(self.__web_search)
self.__window2.show_all()
self.__treeview_Contents = self.__xml2.get_widget('treeview4')
self.__model = gtk.TreeStore(str)
self.__treeview_Contents.set_model(self.__model)
column = gtk.TreeViewColumn()
self.__treeview_Contents.append_column(column)
self.cell = gtk.CellRendererText()
column.pack_start(self.cell, True)
column.add_attribute(self.cell, 'text', 0)
# Instancia a la clase Web.
self.__web = Web()
self.__web.set_mode(self.__model)
self.__model = self.__web.get_mode()
self.__web.set_diccionary()
# Instancia a la clase ControlHelpWindow.
self.__control_helpw = ControlHelpWindow(self)
iter_ = self.__model.get_iter_first()
self.__treeview_Contents.set_cursor_on_cell(
self.__model.get_path(iter_))
self.__treeview_Contents.scroll_to_cell(self.__model.get_path(iter_))
