def __init__(self, setting_widget=None):
gtk.VBox.__init__(self, False)
self.setting_widget = setting_widget
self.wrong_keys = [] # a list of not valid values
scw = gtk.ScrolledWindow()
scw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.sw_vbox = gtk.VBox(False)
self.sw_vbox.set_border_width(5)
# due to scrolled window sw_vbox must not be empty
# the label will be removed
self.sw_vbox.pack_start(gtk.Label())
scw.add_with_viewport(self.sw_vbox)
self.sw_vbox.show()
self.pack_start(scw, True, True)
scw.show()
self.label_msg = gtk.Label()
self.infobar = gtk.InfoBar()
self.infobar.set_message_type(gtk.MESSAGE_WARNING)
self.infobar.get_content_area().add(self.label_msg)
self.pack_start(self.infobar, False, False)
self.set_setting_widget(self.setting_widget)
def __init__(self, selected_account=None, condition=None, message=None):
self.selected_account = selected_account
self.condition = condition
self.message = message
self.gwibber = GwibberPublic()
self.services = json.loads(self.gwibber.GetServices())
self.ui = gtk.Builder()
self.ui.set_translation_domain("gwibber")
self.ui.add_from_file(resources.get_ui_asset("gwibber-accounts-dialog.ui"))
self.ui.connect_signals(self)
dialog = self.ui.get_object("accounts_dialog")
dialog.resize(640,400)
dialog.set_icon_from_file(resources.get_ui_asset("gwibber.svg"))
dialog.show_all()
if hasattr(gtk, "InfoBar"):
self.alignment_infobar = self.ui.get_object("alignment_infobar")
self.infobar = gtk.InfoBar()
self.alignment_infobar.add(self.infobar)
self.infobar.hide()
# Hide the help button until we have help :)
button_help = self.ui.get_object("button_help")
button_help.hide()
# This should check for configured accounts, and if there are any hide this
self.ui.get_object('frame_new_account').hide()
self.ui.get_object('vbox_save').hide()
self.ui.get_object('vbox_create').hide()
self.setup_account_tree()
self.populate_account_tree()
self.select_account()
def register_thread_with_dialog (self, description, thread):
threadbox = gtk.InfoBar()
threadbox.set_message_type(gtk.MESSAGE_INFO)
pb = gtk.ProgressBar()
pb.set_ellipsize(pango.ELLIPSIZE_MIDDLE)
pause_button = gtk.ToggleButton(label=_('Pause'))
threadbox.add_action_widget(pause_button, self.PAUSE)
dlab = gtk.Label(description)
dlab.set_ellipsize(pango.ELLIPSIZE_MIDDLE)
cancel_button = threadbox.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
vbox = gtk.VBox()
vbox.pack_start(dlab, expand=True, fill=True)
vbox.pack_start(pb, expand=True, fill=True)
threadbox.get_content_area().add(vbox)
threadbox.show_all()
self.messagebox.pack_start(threadbox)
self.messagebox.show()
#for b in threadbox.buttons: b.show()
thread.connect('completed',self.thread_done,threadbox)
thread.connect('error',self.thread_error,threadbox)
thread.connect('stopped',self.thread_stopped,threadbox)
thread.connect('pause',self.thread_pause,threadbox)
thread.connect('resume',self.thread_resume,threadbox)
thread.connect('progress',self.progress_update,pb)
pause_button.connect('clicked',self.pause_cb,thread)
cancel_button.connect('clicked',self.cancel_cb,thread)
def add_info_bar(self, message_type, label, action_widget=None):
"""Show an information bar to the user.
:param message_type: message type, a gtk.MessageType
:param label: label to display
:param action_widget: optional, most likely a button
:returns: the infobar
"""
label = gtk.Label(label)
label.set_use_markup(True)
label.set_line_wrap(True)
label.set_width_chars(100)
label.set_alignment(0, 0)
label.set_padding(12, 0)
label.show()
infobar = gtk.InfoBar()
infobar.get_content_area().add(label)
if action_widget:
infobar.add_action_widget(action_widget, 0)
action_widget.show()
infobar.set_message_type(message_type)
infobar.show()
self.main_vbox.pack_start(infobar, False, False, 0)
self.main_vbox.reorder_child(infobar, 2)
return infobar
def __init__(self, parent=None):
gtk.Window.__init__(self)
try:
self.set_screen(parent.get_screen())
except AttributeError:
self.connect('destroy', lambda *w: gtk.main_quit())
self.set_title(self.__class__.__name__)
self.set_default_size(500, 250)
self.set_icon_from_file(ICON_IMAGE)
self.set_geometry_hints(min_width=100, min_height=100)
rootbox = gtk.VBox()
self.add(rootbox)
#region TextView
textview = gtk.TextView()
textbuffer = textview.get_buffer()
textbuffer.set_text(text)
textview.set_wrap_mode(gtk.WRAP_WORD)
#endregion
line_count = textbuffer.get_line_count()
char_count = textbuffer.get_char_count()
Label_text = "Lines: " + str(line_count) + ", Chars: " + str(
char_count)
rootbox.pack_start(textview)
status_bar = gtk.InfoBar()
rootbox.pack_start(status_bar, False, False)
status_bar.set_message_type(gtk.MESSAGE_INFO)
status_bar.get_content_area().pack_start(gtk.Label(Label_text), False,
False)
iter = textbuffer.get_iter_at_line(2)
textbuffer.place_cursor(iter)
self.show_all()
def create_info_bar(self):
self.info_label = gtk.Label()
self.info_bar = gtk.InfoBar()
self.info_bar.get_content_area().pack_start(self.info_label, False,
False)
self.info_bar.add_button(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE)
self.info_bar.connect('response', lambda i, r: i.hide())
def __init__(self, parent=None):
gtk.Window.__init__(self)
try:
self.set_screen(parent.get_screen())
except AttributeError:
self.connect('destroy', lambda *w: gtk.main_quit())
self.set_title(self.__class__.__name__)
self.set_default_size(500, 250)
self.set_icon_from_file(ICON_IMAGE)
self.set_geometry_hints(min_width=100, min_height=100)
rootbox = gtk.VBox()
self.add(rootbox)
#region TextView
textview = gtk.TextView()
textbuffer = textview.get_buffer()
textbuffer.set_text(text)
textview.set_wrap_mode(gtk.WRAP_WORD)
#endregion
line_count = textbuffer.get_line_count()
char_count = textbuffer.get_char_count()
iter = textbuffer.get_iter_at_line(2)
textbuffer.place_cursor(iter)
table = textbuffer.get_tag_table()
tag_red = gtk.TextTag(name="red")
tag_red.set_property("foreground", "red")
table.add(tag_red)
tag_blue = gtk.TextTag(name="blue")
tag_blue.set_property("foreground", "blue")
table.add(tag_blue)
tag_green = gtk.TextTag(name="green")
tag_green.set_property("foreground", "green")
table.add(tag_green)
size = table.get_size()
start, end = textbuffer.get_bounds()
textbuffer.apply_tag(tag_red, start, end)
Label_text = "Table contains: " + str(size) + " Tags"
rootbox.pack_start(textview)
status_bar = gtk.InfoBar()
rootbox.pack_start(status_bar, False, False)
status_bar.set_message_type(gtk.MESSAGE_INFO)
status_bar.get_content_area().pack_start(gtk.Label(Label_text), False,
False)
tagtable = textbuffer.props.tag_table
def foreach_func(tag, data):
print tag.props.name
tagtable.foreach(foreach_func, None)
self.show_all()
def show(self, label=None):
if label:
messagebox = self.ui.get_object('messagebox')
l = gtk.Label(label)
l.set_line_wrap(True)
infobar = gtk.InfoBar()
infobar.set_message_type(gtk.MESSAGE_INFO)
infobar.get_content_area().add(l)
infobar.show_all()
messagebox.pack_start(infobar, True, False)
self.ui.get_object('window1').show()
def _add_info_box(self):
self.__infobar = gtk.InfoBar()
self.__infobar.set_size_request(-1, 32)
self.__warning_label = gtk.Label()
self.__warning_label.set_size_request(400, -1)
self.__warning_label.set_line_wrap(True)
self.__warning_label.set_alignment(0.0, 0.0)
self.__warning_image = gtk.Image()
content = self.__infobar.get_content_area()
content.pack_start(self.__warning_image, False, False)
content.pack_start(self.__warning_label, True, True)
self.__info_box_area.pack_start(self.__infobar, False, False)
self.__infobar.hide_all()
def addInfoBar(self, text):
info_bar = gtk.InfoBar()
label = gtk.Label()
label.set_padding(PADDING, PADDING)
label.set_line_wrap(True)
label.set_line_wrap_mode(pango.WRAP_WORD)
label.set_justify(gtk.JUSTIFY_CENTER)
label.set_markup(text)
info_bar.add(label)
self.info_bar_box.pack_start(info_bar, expand=False, fill=False)
return label, info_bar
def notification_thread_done(self, thread, message):
infobox = gtk.InfoBar()
infobox.set_message_type(gtk.MESSAGE_INFO)
infobox.add_button(gtk.STOCK_DISCARD, gtk.RESPONSE_CLOSE)
infobox.connect('response', lambda ib, response_id: ib.hide())
infobox.show_all()
self.messagebox.pack_start(infobox)
from gourmet.gglobals import launch_url
l = gtk.Label()
l.set_markup(message)
l.connect('activate-link',lambda lbl, uri: launch_url(uri))
l.show()
infobox.get_content_area().add(l)
self.messagebox.show()
def on_grammer_changed(self, buffer, data=None):
print 'TODO: show infobar'
#self.reload_grammer()
if not self.grammer_changed:
self.grammer_changed = True
self.infobar = gtk.InfoBar()
self.infobar.add_button(gtk.STOCK_REFRESH, gtk.RESPONSE_OK)
self.infobar.set_message_type(
gtk.MESSAGE_WARNING) #FIXME: is this needed?
self.infobar_set_text_and_icon(
self.infobar, gtk.STOCK_REFRESH, 'Grammer Changed',
'TreeView & GrammerView needs refresh')
self.vboxGrammer.pack_start(self.infobar, False, False, 0)
self.infobar.connect("response", self.do_reload_grammer)
self.vboxGrammer.show_all()
def __create_macro_info_bar(self):
"""
Creates a component for display information about the current
macro, such as conflicts. The component is added to a placeholder in
the Glade file
"""
self.__macro_infobar = gtk.InfoBar()
self.__macro_infobar.set_size_request(-1, -1)
self.__macro_warning_label = gtk.Label()
self.__macro_warning_label.set_line_wrap(True)
self.__macro_warning_label.set_width_chars(60)
content = self.__macro_infobar.get_content_area()
content.pack_start(self.__macro_warning_label, True, True)
self.__macro_warning_box.pack_start(self.__macro_infobar, True, True)
self.__macro_infobar.set_visible(False)
def show_error(self, message1, message2):
bar = gtk.InfoBar()
bar.props.message_type = gtk.MESSAGE_ERROR
box = bar.get_content_area()
markup = "<b>%s</b> %s" % (
glib.markup_escape_text(message1),
glib.markup_escape_text(message2),
)
label = gtk.Label()
label.props.use_markup = True
label.props.label = markup
label.props.selectable = True
box.pack_start(label, False, False, 0)
self.show_info(bar)
def initialize_network(self):
self.upnpc = Upnp_client()
if self.upnpc.is_ip6():
self.write2log('IPv6 detected!')
self.write2log('IP: ' + self.upnpc.local_ip)
else:
self.write2log('Local IP: ' + self.upnpc.local_ip)
self.write2log('External IP: ' + self.upnpc.external_ip)
if self.upnpc.is_working():
self.write2log('UPnP support working!')
else:
self.write2log('UPnP support not working!')
values = {
'version': self.PYSTREAM_VERSION,
'machine': platform.uname(),
'upnp': self.upnpc.is_working()
}
self.write2log("Sending hello...")
try:
data = urllib.urlencode(values)
response = urllib2.urlopen(self.PYSTREAM_URL + '/api/hello',
data,
timeout=5)
resp_code = response.getcode()
if resp_code == 200:
lines = response.read().splitlines()
if lines:
if lines[0] == 'Bad version!':
self.write2log("Bad version!")
lb_update = gtk.LinkButton(
self.PYSTREAM_URL + '/download',
label='Download a new version!')
lb_update.show()
infobar = gtk.InfoBar()
infobar.get_content_area().add(lb_update)
infobar.show()
self.vbox1.pack_start(infobar, False)
self.b_start.set_sensitive(False)
else:
self.write2log("Hello!")
self.cb_visibility.set_active(0)
else:
self.write2log("Error: " + str(resp_code))
except urllib2.HTTPError, e:
self.write2log('Response code: ' + str(e.code))
def __init__(self, window, title=""):
bar = gtk.InfoBar()
bar.props.message_type = gtk.MESSAGE_INFO
bar.connect("response", self.__handle_info_bar_response)
bar.add_button(gtk.STOCK_CANCEL, 1)
area_box = bar.get_content_area()
box = gtk.HBox(spacing=8)
box.pack_start(gtk.Label(title), False, False, 0)
progress = gtk.ProgressBar()
box.pack_start(progress, False, False, 0)
area_box.pack_start(box, False, False, 0)
self.widget = bar
self.__progress_bar = progress
def infobar(self, id, filename=None, customtext=None):
"""Popup a new auto-hiding InfoBar."""
# CB for destroy timeout
def destroy_ibar():
self.ibar_timeout = 0
self.ibar.destroy()
self.window.resize(1, 1)
# If infobar already active: delete old timeout, destroy old ibar
if self.ibar_timeout > 0:
glib.source_remove(self.ibar_timeout)
destroy_ibar()
# Find the needed dictionary inside our message dict, by id
MSG = MESSAGE_DICT[id]
# Use value from MSG type & icon to lookup Gtk constant, e.g. gtk.MESSAGE_INFO
msgtype = cfg.MSGTYPES[MSG['type']]
imgtype = cfg.IMGTYPES[MSG['icon']]
# Replace variables in message text & change text color
message = ("<span foreground='#2E2E2E'>" + MSG['text'].format(
filename=filename, customtext=customtext) + "</span>")
# Now that we have all the data we need, START creating!
self.ibar = gtk.InfoBar()
self.ibar.set_message_type(msgtype)
self.vbox_ib.pack_end(self.ibar, False, False)
img = gtk.Image()
img.set_from_stock(imgtype, gtk.ICON_SIZE_LARGE_TOOLBAR)
label = gtk.Label()
label.set_markup(message)
content = self.ibar.get_content_area()
content.pack_start(img, False, False)
content.pack_start(label, False, False)
img.show()
label.show()
self.ibar.show()
self.ibar_timeout = glib.timeout_add_seconds(MSG['timeout'],
destroy_ibar)
def gui_start_button(self, widget, data=False):
self.b_start.set_sensitive(False)
self.fcb_folder.set_sensitive(False)
self.sb_port.set_sensitive(False)
self.cb_visibility.set_sensitive(False)
if self.is_stream_lan_only():
self.lb_lan.set_uri('http://' + self.upnpc.local_ip + ':' +
str(int(self.sb_port.get_value())))
self.lb_lan.set_label('http://' + self.upnpc.local_ip + ':' +
str(int(self.sb_port.get_value())))
self.lb_lan.set_sensitive(True)
thread.start_new_thread(self.run_webserver, ())
self.write2log('Serving...')
else:
thread.start_new_thread(self.run_webserver, ())
self.upnpc.add_port_mapping(int(self.sb_port.get_value()))
self.write2log('Serving...')
if self.new_stream(self.fcb_folder.get_filename()):
self.lb_online.set_uri(self.PYSTREAM_URL + self.stream_link)
self.lb_online.set_label(self.PYSTREAM_URL + self.stream_link)
self.lb_online.set_sensitive(True)
self.lb_lan.set_uri('http://' + self.upnpc.local_ip + ':' +
str(int(self.sb_port.get_value())))
self.lb_lan.set_label('http://' + self.upnpc.local_ip + ':' +
str(int(self.sb_port.get_value())))
self.lb_lan.set_sensitive(True)
# edition password
label = gtk.Label('Edition password: ' + self.stream_edit_pass)
label.show()
infobar = gtk.InfoBar()
infobar.show()
infobar.get_content_area().add(label)
self.vbox1.pack_start(infobar, False)
# adding files and more info to stream
thread.start_new_thread(self.add_files_background, ())
# adding send_alive work
gobject.timeout_add_seconds(600, self.send_alive)
def __init__(self, instance, uiman):
gtk.VBox.__init__(self)
Loggable.__init__(self)
self.app = instance
self.settings = instance.settings
self._errors = []
# Store
# icon, infotext, objectfactory, uri, length
self.storemodel = gtk.ListStore(gtk.gdk.Pixbuf, gtk.gdk.Pixbuf, str,
object, str, str, str, str)
# Scrolled Windows
self.treeview_scrollwin = gtk.ScrolledWindow()
self.treeview_scrollwin.set_policy(gtk.POLICY_NEVER,
gtk.POLICY_AUTOMATIC)
self.treeview_scrollwin.set_shadow_type(gtk.SHADOW_ETCHED_IN)
self.iconview_scrollwin = gtk.ScrolledWindow()
self.iconview_scrollwin.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.iconview_scrollwin.set_shadow_type(gtk.SHADOW_ETCHED_IN)
# Popup Menu
self.popup = gtk.Menu()
self.popup_importitem = gtk.ImageMenuItem(_("Import Files..."))
image = gtk.Image()
image.set_from_stock(gtk.STOCK_ADD, gtk.ICON_SIZE_MENU)
self.popup_importitem.set_image(image)
self.popup_remitem = gtk.ImageMenuItem(_("Remove Clip"))
image = gtk.Image()
image.set_from_stock(gtk.STOCK_REMOVE, gtk.ICON_SIZE_MENU)
self.popup_remitem.set_image(image)
self.popup_playmenuitem = gtk.MenuItem(_("Play Clip"))
self.popup_importitem.connect("activate", self._importButtonClickedCb)
self.popup_remitem.connect("activate", self._removeButtonClickedCb)
self.popup_playmenuitem.connect("activate", self._playButtonClickedCb)
self.popup_importitem.show()
self.popup_remitem.show()
self.popup_playmenuitem.show()
self.popup.append(self.popup_importitem)
self.popup.append(self.popup_remitem)
self.popup.append(self.popup_playmenuitem)
# import sources dialogbox
self._importDialog = None
# Search/filter box
self.search_hbox = gtk.HBox()
self.search_hbox.set_spacing(SPACING)
self.search_hbox.set_border_width(
3) # Prevents being flush against the notebook
searchLabel = gtk.Label(_("Search:"))
searchEntry = gtk.Entry()
searchEntry.set_icon_from_stock(gtk.ENTRY_ICON_SECONDARY, "gtk-clear")
searchEntry.connect("changed", self.searchEntryChangedCb)
searchEntry.connect("button-press-event", self.searchEntryActivateCb)
searchEntry.connect("focus-out-event", self.searchEntryDeactivateCb)
searchEntry.connect("icon-press", self.searchEntryIconClickedCb)
self.search_hbox.pack_start(searchLabel, expand=False)
self.search_hbox.pack_end(searchEntry, expand=True)
# Filtering model for the search box.
# Use this instead of using self.storemodel directly
self.modelFilter = self.storemodel.filter_new()
self.modelFilter.set_visible_func(self._setRowVisible,
data=searchEntry)
# TreeView
# Displays icon, name, type, length
self.treeview = gtk.TreeView(self.modelFilter)
self.treeview_scrollwin.add(self.treeview)
self.treeview.connect("button-press-event",
self._treeViewButtonPressEventCb)
self.treeview.connect("row-activated", self._rowActivatedCb)
self.treeview.set_property("rules_hint", True)
self.treeview.set_headers_visible(False)
self.treeview.set_property("search_column", COL_SEARCH_TEXT)
tsel = self.treeview.get_selection()
tsel.set_mode(gtk.SELECTION_MULTIPLE)
tsel.connect("changed", self._viewSelectionChangedCb)
pixbufcol = gtk.TreeViewColumn(_("Icon"))
pixbufcol.set_expand(False)
pixbufcol.set_spacing(SPACING)
self.treeview.append_column(pixbufcol)
pixcell = gtk.CellRendererPixbuf()
pixcell.props.xpad = 6
pixbufcol.pack_start(pixcell)
pixbufcol.add_attribute(pixcell, 'pixbuf', COL_ICON)
namecol = gtk.TreeViewColumn(_("Information"))
self.treeview.append_column(namecol)
namecol.set_expand(True)
namecol.set_spacing(SPACING)
namecol.set_sizing(gtk.TREE_VIEW_COLUMN_GROW_ONLY)
namecol.set_min_width(150)
txtcell = gtk.CellRendererText()
txtcell.set_property("ellipsize", pango.ELLIPSIZE_END)
namecol.pack_start(txtcell)
namecol.add_attribute(txtcell, "markup", COL_INFOTEXT)
namecol = gtk.TreeViewColumn(_("Duration"))
namecol.set_expand(False)
self.treeview.append_column(namecol)
txtcell = gtk.CellRendererText()
txtcell.set_property("yalign", 0.0)
namecol.pack_start(txtcell)
namecol.add_attribute(txtcell, "markup", COL_LENGTH)
# IconView
self.iconview = gtk.IconView(self.modelFilter)
self.iconview_scrollwin.add(self.iconview)
self.iconview.connect("button-press-event",
self._iconViewButtonPressEventCb)
self.iconview.connect("selection-changed",
self._viewSelectionChangedCb)
self.iconview.set_orientation(gtk.ORIENTATION_VERTICAL)
self.iconview.set_property("has_tooltip", True)
self.iconview.set_tooltip_column(COL_INFOTEXT)
self.iconview.set_text_column(COL_SHORT_TEXT)
self.iconview.set_pixbuf_column(COL_ICON_LARGE)
self.iconview.set_selection_mode(gtk.SELECTION_MULTIPLE)
self.iconview.set_item_width(106)
# Explanatory message InfoBar
self.infobar = gtk.InfoBar()
txtlabel = gtk.Label()
txtlabel.set_padding(PADDING, PADDING)
txtlabel.set_line_wrap(True)
txtlabel.set_line_wrap_mode(pango.WRAP_WORD)
txtlabel.set_justify(gtk.JUSTIFY_CENTER)
txtlabel.set_text(
_('Add media to your project by dragging files and folders here or '
'by using the "Import Files..." button.'))
self.infobar.add(txtlabel)
self.txtlabel = txtlabel
# The infobar that shows up if there are _errors when importing clips
self._import_warning_infobar = gtk.InfoBar()
self._import_warning_infobar.set_message_type(gtk.MESSAGE_WARNING)
content_area = self._import_warning_infobar.get_content_area()
actions_area = self._import_warning_infobar.get_action_area()
self._warning_label = gtk.Label()
self._warning_label.set_line_wrap(True)
self._warning_label.set_line_wrap_mode(pango.WRAP_WORD)
self._warning_label.set_justify(gtk.JUSTIFY_CENTER)
self._view_error_btn = gtk.Button()
self._hide_infobar_btn = gtk.Button()
self._hide_infobar_btn.set_label(_("Hide"))
self._view_error_btn.connect("clicked",
self._viewErrorsButtonClickedCb)
self._hide_infobar_btn.connect("clicked", self._hideInfoBarClickedCb)
content_area.add(self._warning_label)
actions_area.add(self._view_error_btn)
actions_area.add(self._hide_infobar_btn)
# The _progressbar that shows up when importing clips
self._progressbar = gtk.ProgressBar()
# Connect to project. We must remove and reset the callbacks when
# changing project.
self.project_signals = SignalGroup()
self.app.connect("new-project-created", self._newProjectCreatedCb)
self.app.connect("new-project-loaded", self._newProjectLoadedCb)
self.app.connect("new-project-failed", self._newProjectFailedCb)
# default pixbufs
self.audiofilepixbuf = self._getIcon("audio-x-generic",
"pitivi-sound.png")
self.videofilepixbuf = self._getIcon("video-x-generic",
"pitivi-video.png")
# Drag and Drop
self.drag_dest_set(gtk.DEST_DEFAULT_DROP | gtk.DEST_DEFAULT_MOTION,
[dnd.URI_TUPLE, dnd.FILE_TUPLE],
gtk.gdk.ACTION_COPY)
self.connect("drag_data_received", self._dndDataReceivedCb)
self.treeview.drag_source_set(0, [], gtk.gdk.ACTION_COPY)
self.treeview.connect("motion-notify-event",
self._treeViewMotionNotifyEventCb)
self.treeview.connect("button-release-event",
self._treeViewButtonReleaseCb)
self.treeview.connect("drag_begin", self._dndDragBeginCb)
self.treeview.connect("drag_data_get", self._dndDataGetCb)
self.iconview.drag_source_set(0, [], gtk.gdk.ACTION_COPY)
self.iconview.connect("motion-notify-event",
self._iconViewMotionNotifyEventCb)
self.iconview.connect("button-release-event",
self._iconViewButtonReleaseCb)
self.iconview.connect("drag_begin", self._dndDragBeginCb)
self.iconview.connect("drag_data_get", self._dndDataGetCb)
# Hack so that the views have the same method as self
self.treeview.getSelectedItems = self.getSelectedItems
# always available
actions = (
("ImportSources", gtk.STOCK_ADD, _("_Import Files..."), None,
_("Add media files to your project"), self._importSourcesCb),
("ImportSourcesFolder", gtk.STOCK_ADD, _("Import _Folders..."),
None, _("Add the contents of a folder as clips in your project"),
self._importSourcesFolderCb),
("SelectUnusedSources", None, _("Select Unused Media"), None,
_("Select clips that have not been used in the project"),
self._selectUnusedSourcesCb),
)
# only available when selection is non-empty
selection_actions = (
("RemoveSources", gtk.STOCK_DELETE, _("_Remove from Project"),
"<Control>Delete", None, self._removeSourcesCb),
("InsertEnd", gtk.STOCK_COPY, _("Insert at _End of Timeline"),
"Insert", None, self._insertEndCb),
)
actiongroup = gtk.ActionGroup("sourcelistpermanent")
actiongroup.add_actions(actions)
actiongroup.get_action("ImportSources").props.is_important = True
uiman.insert_action_group(actiongroup, 0)
self.selection_actions = gtk.ActionGroup("sourcelistselection")
self.selection_actions.add_actions(selection_actions)
self.selection_actions.set_sensitive(False)
uiman.insert_action_group(self.selection_actions, 0)
uiman.add_ui_from_string(ui)
# clip view menu items
view_menu_item = uiman.get_widget('/MainMenuBar/View')
view_menu = view_menu_item.get_submenu()
seperator = gtk.SeparatorMenuItem()
self.treeview_menuitem = gtk.RadioMenuItem(None,
_("Show Clips as a List"))
self.iconview_menuitem = gtk.RadioMenuItem(self.treeview_menuitem,
_("Show Clips as Icons"))
# update menu items with current clip view before we connect to item
# signals
if self.settings.lastClipView == SHOW_TREEVIEW:
self.treeview_menuitem.set_active(True)
self.iconview_menuitem.set_active(False)
else:
self.treeview_menuitem.set_active(False)
self.iconview_menuitem.set_active(True)
# we only need to connect to one menu item because we get a signal
# from each radio item in the group
self.treeview_menuitem.connect("toggled",
self._treeViewMenuItemToggledCb)
view_menu.append(seperator)
view_menu.append(self.treeview_menuitem)
view_menu.append(self.iconview_menuitem)
self.treeview_menuitem.show()
self.iconview_menuitem.show()
seperator.show()
# add all child widgets
self.pack_start(self.infobar, expand=False, fill=False)
self.pack_start(self._import_warning_infobar, expand=False, fill=False)
self.pack_start(self.search_hbox, expand=False)
self.pack_start(self.iconview_scrollwin)
self.pack_start(self.treeview_scrollwin)
self.pack_start(self._progressbar, expand=False)
# display the help text
self.clip_view = self.settings.lastClipView
self._displayClipView()
def __init__(self, instance, uiman):
gtk.VBox.__init__(self)
Loggable.__init__(self)
self.app = instance
self.settings = instance.settings
# Store
# icon, infotext, objectfactory, uri, length
self.storemodel = gtk.ListStore(gtk.gdk.Pixbuf, gtk.gdk.Pixbuf, str,
object, str, str, str, str)
# Scrolled Windows
self.treeview_scrollwin = gtk.ScrolledWindow()
self.treeview_scrollwin.set_policy(gtk.POLICY_NEVER,
gtk.POLICY_AUTOMATIC)
self.treeview_scrollwin.set_shadow_type(gtk.SHADOW_ETCHED_IN)
self.iconview_scrollwin = gtk.ScrolledWindow()
self.iconview_scrollwin.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.iconview_scrollwin.set_shadow_type(gtk.SHADOW_ETCHED_IN)
# Popup Menu
self.popup = gtk.Menu()
self.popup_importitem = gtk.ImageMenuItem(_("Import clips..."))
image = gtk.Image()
image.set_from_stock(gtk.STOCK_ADD, gtk.ICON_SIZE_MENU)
self.popup_importitem.set_image(image)
self.popup_remitem = gtk.ImageMenuItem(_("Remove Clip"))
image = gtk.Image()
image.set_from_stock(gtk.STOCK_REMOVE, gtk.ICON_SIZE_MENU)
self.popup_remitem.set_image(image)
self.popup_playmenuitem = gtk.MenuItem(_("Play Clip"))
self.popup_importitem.connect("activate", self._importButtonClickedCb)
self.popup_remitem.connect("activate", self._removeButtonClickedCb)
self.popup_playmenuitem.connect("activate", self._playButtonClickedCb)
self.popup_importitem.show()
self.popup_remitem.show()
self.popup_playmenuitem.show()
self.popup.append(self.popup_importitem)
self.popup.append(self.popup_remitem)
self.popup.append(self.popup_playmenuitem)
# import sources dialogbox
self._importDialog = None
# TreeView
# Displays icon, name, type, length
self.treeview = gtk.TreeView(self.storemodel)
self.treeview_scrollwin.add(self.treeview)
self.treeview.connect("button-press-event",
self._treeViewButtonPressEventCb)
self.treeview.connect("row-activated", self._rowActivatedCb)
self.treeview.set_property("rules_hint", True)
self.treeview.set_headers_visible(False)
self.treeview.set_property("search_column", COL_SEARCH_TEXT)
tsel = self.treeview.get_selection()
tsel.set_mode(gtk.SELECTION_MULTIPLE)
tsel.connect("changed", self._viewSelectionChangedCb)
pixbufcol = gtk.TreeViewColumn(_("Icon"))
pixbufcol.set_expand(False)
pixbufcol.set_spacing(5)
self.treeview.append_column(pixbufcol)
pixcell = gtk.CellRendererPixbuf()
pixcell.props.xpad = 6
pixbufcol.pack_start(pixcell)
pixbufcol.add_attribute(pixcell, 'pixbuf', COL_ICON)
namecol = gtk.TreeViewColumn(_("Information"))
self.treeview.append_column(namecol)
namecol.set_expand(True)
namecol.set_spacing(5)
namecol.set_sizing(gtk.TREE_VIEW_COLUMN_GROW_ONLY)
namecol.set_min_width(150)
txtcell = gtk.CellRendererText()
txtcell.set_property("ellipsize", pango.ELLIPSIZE_END)
namecol.pack_start(txtcell)
namecol.add_attribute(txtcell, "markup", COL_INFOTEXT)
namecol = gtk.TreeViewColumn(_("Duration"))
namecol.set_expand(False)
self.treeview.append_column(namecol)
txtcell = gtk.CellRendererText()
txtcell.set_property("yalign", 0.0)
namecol.pack_start(txtcell)
namecol.add_attribute(txtcell, "markup", COL_LENGTH)
# IconView
self.iconview = gtk.IconView(self.storemodel)
self.iconview_scrollwin.add(self.iconview)
self.iconview.connect("button-press-event",
self._iconViewButtonPressEventCb)
self.iconview.connect("selection-changed",
self._viewSelectionChangedCb)
self.iconview.set_orientation(gtk.ORIENTATION_VERTICAL)
self.iconview.set_text_column(COL_SHORT_TEXT)
self.iconview.set_pixbuf_column(COL_ICON_LARGE)
self.iconview.set_selection_mode(gtk.SELECTION_MULTIPLE)
self.iconview.set_item_width(106)
# Explanatory message InfoBar
infobar = gtk.InfoBar()
txtlabel = gtk.Label()
txtlabel.set_padding(PADDING, PADDING)
txtlabel.set_line_wrap(True)
txtlabel.set_line_wrap_mode(pango.WRAP_WORD)
txtlabel.set_justify(gtk.JUSTIFY_CENTER)
txtlabel.set_markup(
_("<span>Import your clips by dragging them here or "
"by using the buttons above.</span>"))
infobar.add(txtlabel)
self.infobar = infobar
self.txtlabel = txtlabel
self.infostub = InfoStub()
self.infostub.connect("remove-me", self._removeInfoStub)
# Connect to project. We must remove and reset the callbacks when
# changing project.
self.project_signals = SignalGroup()
self.app.connect("new-project-created", self._newProjectCreatedCb)
self.app.connect("new-project-loaded", self._newProjectLoadedCb)
self.app.connect("new-project-failed", self._newProjectFailedCb)
# default pixbufs
self.audiofilepixbuf = self._getIcon("audio-x-generic",
"pitivi-sound.png")
self.videofilepixbuf = self._getIcon("video-x-generic",
"pitivi-video.png")
# Drag and Drop
self.drag_dest_set(gtk.DEST_DEFAULT_DROP | gtk.DEST_DEFAULT_MOTION,
[dnd.URI_TUPLE, dnd.FILE_TUPLE],
gtk.gdk.ACTION_COPY)
self.connect("drag_data_received", self._dndDataReceivedCb)
self.treeview.drag_source_set(0, [], gtk.gdk.ACTION_COPY)
self.treeview.connect("motion-notify-event",
self._treeViewMotionNotifyEventCb)
self.treeview.connect("button-release-event",
self._treeViewButtonReleaseCb)
self.treeview.connect("drag_begin", self._dndDragBeginCb)
self.treeview.connect("drag_data_get", self._dndDataGetCb)
self.iconview.drag_source_set(0, [], gtk.gdk.ACTION_COPY)
self.iconview.connect("motion-notify-event",
self._iconViewMotionNotifyEventCb)
self.iconview.connect("button-release-event",
self._iconViewButtonReleaseCb)
self.iconview.connect("drag_begin", self._dndDragBeginCb)
self.iconview.connect("drag_data_get", self._dndDataGetCb)
# Hack so that the views have the same method as self
self.treeview.getSelectedItems = self.getSelectedItems
# Error dialog box
self.errorDialogBox = None
# always available
actions = (
("ImportSources", gtk.STOCK_ADD, _("_Import clips..."), None,
_("Import clips to use"), self._importSourcesCb),
("ImportSourcesFolder", gtk.STOCK_ADD,
_("Import _folder of clips..."), None,
_("Import folder of clips to use"), self._importSourcesFolderCb),
)
# only available when selection is non-empty
selection_actions = (
("RemoveSources", gtk.STOCK_DELETE, _("_Remove from project"),
"<Control>Delete", None, self._removeSourcesCb),
("InsertEnd", gtk.STOCK_COPY, _("Insert at _end of timeline"),
"Insert", None, self._insertEndCb),
)
actiongroup = gtk.ActionGroup("sourcelistpermanent")
actiongroup.add_actions(actions)
actiongroup.get_action("ImportSources").props.is_important = True
uiman.insert_action_group(actiongroup, 0)
self.selection_actions = gtk.ActionGroup("sourcelistselection")
self.selection_actions.add_actions(selection_actions)
self.selection_actions.set_sensitive(False)
uiman.insert_action_group(self.selection_actions, 0)
uiman.add_ui_from_string(ui)
# clip view menu items
view_menu_item = uiman.get_widget('/MainMenuBar/View')
view_menu = view_menu_item.get_submenu()
seperator = gtk.SeparatorMenuItem()
self.treeview_menuitem = gtk.RadioMenuItem(None,
"Show Clips as a List")
self.iconview_menuitem = gtk.RadioMenuItem(self.treeview_menuitem,
"Show Clips as Icons")
# update menu items with current clip view before we connect to item
# signals
if self.settings.lastClipView == SHOW_TREEVIEW:
self.treeview_menuitem.set_active(True)
self.iconview_menuitem.set_active(False)
else:
self.treeview_menuitem.set_active(False)
self.iconview_menuitem.set_active(True)
# we only need to connect to one menu item because we get a signal
# from each radio item in the group
self.treeview_menuitem.connect("toggled",
self._treeViewMenuItemToggledCb)
view_menu.append(seperator)
view_menu.append(self.treeview_menuitem)
view_menu.append(self.iconview_menuitem)
self.treeview_menuitem.show()
self.iconview_menuitem.show()
seperator.show()
# add all child widgets
self.pack_start(self.infobar, expand=False, fill=False)
self.pack_start(self.iconview_scrollwin)
self.pack_start(self.treeview_scrollwin)
# display the help text
self.clip_view = self.settings.lastClipView
self._displayClipView()
def build_window(message_type,
stock_id,
message,
widget,
top_label=None,
bottom_label=None):
image = gtk.Image()
image.set_from_stock(stock_id, gtk.ICON_SIZE_LARGE_TOOLBAR)
image.show()
label = gtk.Label()
label.set_markup('<b>%s</b>' % message)
label.set_alignment(0., .5)
label.show()
info_bar = gtk.InfoBar()
info_bar.set_message_type(message_type)
content_area = info_bar.get_content_area()
content_area.pack_start(image, False, False, 0)
content_area.pack_start(label, True, True, 0)
info_bar.show()
scrolled_window = gtk.ScrolledWindow()
scrolled_window.add(widget)
scrolled_window.set_shadow_type(gtk.SHADOW_IN)
scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled_window.show()
close_button = gtk.Button(gtk.STOCK_CLOSE)
close_button.set_use_stock(True)
close_button.set_can_default(True)
close_button.connect('clicked', gtk.main_quit)
close_button.show()
button_hbox = gtk.HBox(False, 4)
button_hbox.pack_end(close_button, False, False, 0)
button_hbox.show()
dialog_vbox = gtk.VBox(False, 8)
dialog_vbox.set_border_width(8)
if top_label is not None:
dialog_vbox.pack_start(top_label, False, False, 0)
dialog_vbox.pack_start(scrolled_window, True, True, 0)
if bottom_label is not None:
dialog_vbox.pack_start(bottom_label, False, False, 0)
dialog_vbox.pack_start(button_hbox, False, False, 0)
dialog_vbox.show()
top_vbox = gtk.VBox(False, 0)
top_vbox.pack_start(info_bar, False, False, 0)
top_vbox.pack_start(dialog_vbox, True, True, 0)
top_vbox.show()
def key_press_event(window, event):
if event.keyval == gtk.keysyms.Escape:
gtk.main_quit()
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.set_title('gnetlist')
window.set_default_size(600, 400)
window.set_position(gtk.WIN_POS_CENTER)
window.connect('key-press-event', key_press_event)
window.connect('destroy', gtk.main_quit)
window.add(top_vbox)
window.show()
def __init__(self, parent=None):
gtk.Window.__init__(self)
try:
self.set_screen(parent.get_screen())
except AttributeError:
self.connect('destroy', lambda *w: gtk.main_quit())
self.set_title(self.__class__.__name__)
self.set_border_width(8)
vb = gtk.VBox()
self.add(vb)
bar = gtk.InfoBar()
vb.pack_start(bar, False, False)
bar.set_message_type(gtk.MESSAGE_INFO)
bar.get_content_area().pack_start(
gtk.Label(
"This is an info bar with message type GTK_MESSAGE_INFO"),
False, False)
bar = gtk.InfoBar()
vb.pack_start(bar, False, False)
bar.set_message_type(gtk.MESSAGE_WARNING)
bar.get_content_area().pack_start(
gtk.Label(
"This is an info bar with message type GTK_MESSAGE_WARNING"),
False, False)
bar = gtk.InfoBar()
bar.add_button(gtk.STOCK_OK, gtk.RESPONSE_OK)
bar.connect("response", self._on_bar_response)
vb.pack_start(bar, False, False)
bar.set_message_type(gtk.MESSAGE_QUESTION)
bar.get_content_area().pack_start(
gtk.Label(
"This is an info bar with message type GTK_MESSAGE_QUESTION"),
False, False)
bar = gtk.InfoBar()
vb.pack_start(bar, False, False)
bar.set_message_type(gtk.MESSAGE_ERROR)
bar.get_content_area().pack_start(
gtk.Label(
"This is an info bar with message type GTK_MESSAGE_ERROR"),
False, False)
bar = gtk.InfoBar()
vb.pack_start(bar, False, False)
bar.set_message_type(gtk.MESSAGE_OTHER)
bar.get_content_area().pack_start(
gtk.Label(
"This is an info bar with message type GTK_MESSAGE_OTHER"),
False, False)
frame = gtk.Frame("Info bars")
vb.pack_start(frame, False, False, 8)
vb2 = gtk.VBox(spacing=8)
vb2.set_border_width(8)
frame.add(vb2)
vb2.pack_start(gtk.Label("An example of different info bars"), False,
False)
self.show_all()
def on_save_clicked(self, button):
id = self.selected_id
msg = ''
account_name = self.builder.get_object('account_name').get_text()
account_number = self.builder.get_object('account_number').get_text()
account_type = self.builder.get_object(
'account_types_combo').get_active()
account_owner = self.builder.get_object('account_owner').get_text()
bank_name = self.builder.get_object(
'bank_names_combo').get_active_text()
if len(account_name) == 0:
msg += 'Account Name Can not be empty\n'
if len(account_number) == 0:
msg += 'Account Number Can not be empty\n'
if len(account_owner) == 0:
msg += 'Account Owner Can not be empty\n'
if account_type == -1:
msg += 'Select an account type\n'
if bank_name == None:
msg += 'Select a Bank\n'
if len(msg):
dialog = gtk.MessageDialog(None, 0, gtk.MESSAGE_ERROR,
gtk.BUTTONS_OK, msg)
dialog.run()
dialog.destroy()
return
result = self.bankaccounts_class.add_account(
id, account_name, account_number, account_type, account_owner,
bank_name,
self.builder.get_object('bank_branch').get_text(),
self.builder.get_object('bank_address').get_text(),
self.builder.get_object('bank_phone').get_text(),
self.builder.get_object('bank_webpage').get_text(),
self.builder.get_object('desc').get_text())
if result > 0:
window = self.builder.get_object('add_window').hide_all()
infobar = gtk.InfoBar()
label = gtk.Label('successfully added.')
infobar.get_content_area().add(label)
width, height = self.main_window_background.window.get_size()
infobar.set_size_request(width, -1)
self.main_window_background.put(infobar, 0, 0)
infobar.show_all()
model = self.builder.get_object('treeview').get_model()
if id == -1:
iter = model.append()
else:
iter = model.get_iter_first()
while iter != None:
if model.get_value(iter, 0) == id:
break
else:
iter = model.iter_next(iter)
if account_type == 0:
accType = 'جاری'
else:
accType = 'حساب پس انداز'
model.set(iter, 0, result, 1, account_name, 2, account_number, 3,
account_owner, 4, accType, 5, bank_name)
glib.timeout_add_seconds(3, lambda w: w.destroy(), infobar)
def test():
def set_message_area_text_and_icon (message_area,
icon_stock_id,
primary_text,
secondary_text=None):
hbox_content = gtk.HBox(False, 8)
image = gtk.image_new_from_stock(icon_stock_id, gtk.ICON_SIZE_DIALOG)
hbox_content.pack_start(image, False, False, 0)
image.set_alignment(0.5, 0)
vbox = gtk.VBox(False, 6)
hbox_content.pack_start(vbox, True, True, 0)
primary_markup = "<b>%s</b>" % primary_text
primary_label = gtk.Label(primary_markup)
vbox.pack_start(primary_label, True, True, 0)
primary_label.set_use_markup(True)
primary_label.set_line_wrap(True)
primary_label.set_alignment(0, 0.5)
primary_label.set_flags(gtk.CAN_FOCUS)
primary_label.set_selectable(True)
if secondary_text:
secondary_markup = "<small>%s</small>" % secondary_text
secondary_label = gtk.Label(secondary_markup)
vbox.pack_start(secondary_label, True, True, 0)
secondary_label.set_flags(gtk.CAN_FOCUS)
secondary_label.set_use_markup(True)
secondary_label.set_line_wrap(True)
secondary_label.set_selectable(True)
secondary_label.set_alignment(0, 0.5)
hbox_content.show_all()
ca = message_area.get_content_area()
ca.add(hbox_content)
window = gtk.Window()
window.connect("delete-event", gtk.main_quit)
if False:
widget = MessageArea()
widget.add_stock_button_with_text('hello', gtk.STOCK_REFRESH, gtk.RESPONSE_OK)
widget.add_button (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
else:
infobar = gtk.InfoBar()
infobar.add_button('hello', gtk.RESPONSE_OK)
infobar.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
widget = infobar
infobar.set_message_type(gtk.MESSAGE_WARNING)
set_message_area_text_and_icon(widget, gtk.STOCK_REFRESH, 'hello world', 'example')
window.add(widget)
window.show_all()
gtk.main()
def __init__(self, path="ExportVideo.ui", root="frmExportVideo", domain="LibreShot", form=None, project=None, **kwargs):
SimpleGtkBuilderApp.__init__(self, os.path.join(project.UI_DIR, path), root, domain, **kwargs)
# Add language support
_ = Language_Init.Translator(project).lang.gettext
self._ = _
# set important vars
self.form = form
self.project = project
self.original_project_type = self.project.project_type # remember the original project type (i.e. mlt_profile)
# Show all controls on this screen
self.frmExportVideo.show_all()
# set window as MODAL (so they can't mess up the export)
self.frmExportVideo.set_modal(True)
self.invalid_codecs = []
# init the project type properties
self.init_properties(self.cmbProjectType.get_active_text())
# set the export file name
self.txtFileName.set_text(self.project.name)
# set the export folder as the project folder (if any)
if ".libreshot" in self.project.folder:
# This is the libreshot default project (set the folder to 'DESKTOP')
self.fileExportFolder.set_current_folder(self.project.DESKTOP)
else:
# Set project folder
self.fileExportFolder.set_current_folder(self.project.folder)
# init the list of possible project types / profiles
self.profile_list = profiles.mlt_profiles(self.project).get_profile_list()
# loop through each profile, and add it to the dropdown
for file_name, p in self.profile_list:
# append profile to list
self.cmbProjectType.append_text(p.description())
export_options = [_("Video & Audio"), _("Image Sequence")]
# loop through export to options
for option in export_options:
# append profile to list
self.cboExportTo.append_text(option)
export_types_model = self.cboExportType.get_model()
export_types_model.clear()
export_types = [_("Export to Folder"), _("Upload to Web")]
# loop through export to options
for option in export_types:
# append profile to list
self.cboExportType.append_text(option)
self.set_dropdown_values(_("Export to Folder"), self.cboExportType)
upload_model = self.cboUploadServices.get_model()
upload_model.clear()
self.upload_manager = UploadManager(project, self.form.settings)
self.upload_services = self.upload_manager.get_services()
upload_types = self.upload_services.keys()
upload_types.sort()
# loop through export to options
for option in upload_types:
# append profile to list
self.cboUploadServices.append_text(option)
self.set_dropdown_values(_("YouTube"), self.cboUploadServices)
#populate the format/codec drop downs
#formats
format_model = self.cboVIdeoFormat.get_model()
format_model.clear()
for format in self.form.vformats:
self.cboVIdeoFormat.append_text(format)
#video codecs
vcodecs_model = self.cboVideoCodec.get_model()
vcodecs_model.clear()
for vcodec in self.form.vcodecs:
self.cboVideoCodec.append_text(vcodec)
#audio codecs
acodecs_model = self.cboAudioCodec.get_model()
acodecs_model.clear()
# Add 'none' audio codec
self.cboAudioCodec.append_text( "none" )
for acodec in self.form.acodecs:
# Add the rest of the audio codecs
self.cboAudioCodec.append_text(acodec)
# set the dropdown boxes
self.set_project_type_dropdown()
self.set_export_to_dropdown()
#load the simple project type dropdown
presets = []
for file in os.listdir(self.project.EXPORT_PRESETS_DIR):
xmldoc = xml.parse(os.path.join(self.project.EXPORT_PRESETS_DIR,file))
type = xmldoc.getElementsByTagName("type")
presets.append(_(type[0].childNodes[0].data))
#exclude duplicates
presets = list(set(presets))
for item in sorted(presets):
self.cboSimpleProjectType.append_text(item)
#indicate that exporting cancelled
self.cancelled = False
# create the infobar displaying the missing codec message
self.use_infobar = True
self.last_error = None
try:
self.infobar = gtk.InfoBar()
self.content = self.infobar.get_content_area()
self.label = gtk.Label()
self.image = gtk.Image()
self.image.set_from_stock(gtk.STOCK_DIALOG_WARNING, gtk.ICON_SIZE_DIALOG)
self.content.add(self.image)
self.content.add(self.label)
self.vbox1.pack_start(self.infobar)
self.vbox1.reorder_child(self.infobar, 3)
self.infobar.set_message_type(gtk.MESSAGE_WARNING)
except:
# older version of pygtk can not create an InfoBar
self.use_infobar = False
