def __init__(self):
Gtk.Window.__init__(self, title='My Window Title')
self.connect('delete-event', Gtk.main_quit)
# Gtk.ListStore will hold data for the TreeView
# Only the first two columns will be displayed
# The third one is for sorting file sizes as numbers
store = Gtk.ListStore(str, str, long)
# Get the data - see below
self.populate_store(store)
treeview = Gtk.TreeView(model=store)
# The first TreeView column displays the data from
# the first ListStore column (text=0), which contains
# file names
renderer_1 = Gtk.CellRendererText()
column_1 = Gtk.TreeViewColumn('File Name', renderer_1, text=0)
# Calling set_sort_column_id makes the treeViewColumn sortable
# by clicking on its header. The column is sorted by
# the ListStore column index passed to it
# (in this case 0 - the first ListStore column)
column_1.set_sort_column_id(0)
treeview.append_column(column_1)
# xalign=1 right-aligns the file sizes in the second column
renderer_2 = Gtk.CellRendererText(xalign=1)
# text=1 pulls the data from the second ListStore column
# which contains filesizes in bytes formatted as strings
# with thousand separators
column_2 = Gtk.TreeViewColumn('Size in bytes', renderer_2, text=1)
# Mak the Treeview column sortable by the third ListStore column
# which contains the actual file sizes
column_2.set_sort_column_id(2)
treeview.append_column(column_2)
# Use ScrolledWindow to make the TreeView scrollable
# Otherwise the TreeView would expand to show all items
# Only allow vertical scrollbar
scrolled_window = Gtk.ScrolledWindow()
scrolled_window.set_policy(
Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
scrolled_window.add(treeview)
scrolled_window.set_min_content_height(200)
self.add(scrolled_window)
self.show_all()
python类TreeView()的实例源码
def __init__(self):
glade_dir = gv.jcchess.get_glade_dir()
self.glade_file = os.path.join(glade_dir, "move_list.glade")
Move_List.move_list_ref = self
self.comments = comments.get_ref()
self.saved_move_list = []
# create move list window
self.builder = Gtk.Builder()
self.builder.set_translation_domain(gv.domain)
self.builder.add_from_file(self.glade_file)
self.builder.connect_signals(self)
self.window = self.builder.get_object("move_list_window")
self.vbox = self.builder.get_object("vbox1") #man
self.treeview = Gtk.TreeView() #man
self.liststore = self.builder.get_object("liststore1")
self.scrolled_window = Gtk.ScrolledWindow()
#self.scrolled_window.set_size_request(150,300)
self.treeview.set_model(self.liststore)
self.scrolled_window.add(self.treeview)
self.vbox.add(self.scrolled_window)
self.comments_button = self.builder.get_object("comments_button")
#self.builder.connect("button_press_event",self.comments_button_clicked_cb)
cell0 = Gtk.CellRendererText()
# cell0.set_property("cell-background", Gdk.color_parse("#F8F8FF"))
tvcolumn0 = Gtk.TreeViewColumn("#")
self.treeview.append_column(tvcolumn0)
tvcolumn0.pack_start(cell0, True)
tvcolumn0.set_min_width(50)
tvcolumn0.set_attributes(cell0, text=0)
cell1 = Gtk.CellRendererText()
# cell1.set_property("cell-background", Gdk.color_parse("#F8F8FF"))
tvcolumn1 = Gtk.TreeViewColumn(_("Move"))
self.treeview.append_column(tvcolumn1)
tvcolumn1.pack_start(cell1, True)
tvcolumn1.set_min_width(100)
tvcolumn1.set_attributes(cell1, text=1)
cell2 = Gtk.CellRendererText()
# cell1.set_property("cell-background", Gdk.color_parse("#F8F8FF"))
tvcolumn2 = Gtk.TreeViewColumn(_("Cmt"))
self.treeview.append_column(tvcolumn2)
tvcolumn2.pack_start(cell2, True)
tvcolumn2.set_min_width(20)
tvcolumn2.set_attributes(cell2, text=2)
self.tree_selection = self.treeview.get_selection()
self.treeview.connect("button_press_event", self.treeview_button_press)
self.treeview.connect("key_press_event", self.treeview_key_press)
self.update()
# user has closed the window
# just hide it
def __init__(self, parent):
Gtk.Dialog.__init__(self, "Alarms", parent, 0,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
Gtk.STOCK_OK, Gtk.ResponseType.OK))
self._store = Gtk.ListStore(str, str, str, object)
for i, alarm in enumerate(config['alarms']):
row = self._build_row(alarm)
self._store.append(row)
self._tree = Gtk.TreeView(self._store)
self._selection = self._tree.get_selection()
self._selection.connect("changed", self._on_tree_selection_changed)
self._tree.set_size_request(300, 150)
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("Exchange", renderer, text=self._EXCHANGE_COL)
self._tree.append_column(column)
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("Market", renderer, text=self._MARKET_COL)
self._tree.append_column(column)
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("Alarm Trigger", renderer, text=self._TRIGGER_COL)
self._tree.append_column(column)
vbox = Gtk.Box(spacing=6, orientation=Gtk.Orientation.VERTICAL)
new_button = Gtk.Button.new_with_label("New Alarm")
new_button.connect("clicked", self._on_new_button_clicked)
vbox.pack_start(new_button, False, False, 0)
self._remove_button = Gtk.Button.new_with_label("Remove Alarm")
self._remove_button.connect("clicked", self._on_remove_button_clicked)
vbox.pack_start(self._remove_button, False, False, 0)
self._market_combo, self._market_store = self._create_market_combo()
self._market_combo.connect("changed", self._on_market_changed)
vbox.pack_start(self._market_combo, False, False, 0)
self._above_radio = Gtk.RadioButton.new_with_label_from_widget(None, "Above")
self._above_radio.connect("clicked", self._on_type_radio_clicked)
self._below_radio = Gtk.RadioButton.new_with_label_from_widget(self._above_radio, "Below")
self._below_radio.connect("clicked", self._on_type_radio_clicked)
type_hbox = Gtk.Box(spacing=6, orientation=Gtk.Orientation.HORIZONTAL)
type_hbox.pack_start(self._above_radio, True, True, 0)
type_hbox.pack_start(self._below_radio, True, True, 0)
vbox.pack_start(type_hbox, False, False, 0)
self._price_entry = Gtk.Entry()
self._price_entry.connect("changed", self._on_price_changed)
_add_label_and_widget(vbox, "Price:", self._price_entry)
hbox = Gtk.Box(spacing=6)
hbox.pack_start(self._tree, True, True, 0)
hbox.pack_start(vbox, False, False, 0)
self.get_content_area().add(hbox)
self._set_inputs_sensitive(False)
self.show_all()
def __init__(self):
Gtk.Window.__init__(self)
self.set_title("Dependency Explorer")
self.set_default_size(500, 500)
self.connect("delete-event", Gtk.main_quit)
# Create the data models
self.pkg_model = Gtk.ListStore(GObject.TYPE_STRING)
self.pkg_model.set_sort_column_id(COL_PKG_NAME, Gtk.SortType.ASCENDING)
self.depends_model = Gtk.ListStore(GObject.TYPE_INT, GObject.TYPE_STRING, GObject.TYPE_STRING)
self.depends_model.set_sort_column_id(COL_DEP_PACKAGE, Gtk.SortType.ASCENDING)
pane = Gtk.HPaned()
pane.set_position(250)
self.add(pane)
# The master list of packages
scrolled = Gtk.ScrolledWindow()
scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
scrolled.set_shadow_type(Gtk.ShadowType.IN)
self.pkg_treeview = Gtk.TreeView(self.pkg_model)
self.pkg_treeview.get_selection().connect("changed", self.on_cursor_changed)
column = Gtk.TreeViewColumn("Package", Gtk.CellRendererText(), text=COL_PKG_NAME)
self.pkg_treeview.append_column(column)
pane.add1(scrolled)
scrolled.add(self.pkg_treeview)
box = Gtk.VBox(homogeneous=True, spacing=4)
# Runtime Depends
scrolled = Gtk.ScrolledWindow()
scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
scrolled.set_shadow_type(Gtk.ShadowType.IN)
self.rdep_treeview = PackageDepView(self.depends_model, TYPE_RDEP, "Runtime Depends")
self.rdep_treeview.connect("row-activated", self.on_package_activated, COL_DEP_PACKAGE)
scrolled.add(self.rdep_treeview)
box.add(scrolled)
# Build Depends
scrolled = Gtk.ScrolledWindow()
scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
scrolled.set_shadow_type(Gtk.ShadowType.IN)
self.dep_treeview = PackageDepView(self.depends_model, TYPE_DEP, "Build Depends")
self.dep_treeview.connect("row-activated", self.on_package_activated, COL_DEP_PACKAGE)
scrolled.add(self.dep_treeview)
box.add(scrolled)
pane.add2(box)
# Reverse Depends
scrolled = Gtk.ScrolledWindow()
scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
scrolled.set_shadow_type(Gtk.ShadowType.IN)
self.revdep_treeview = PackageReverseDepView(self.depends_model, "Reverse Depends")
self.revdep_treeview.connect("row-activated", self.on_package_activated, COL_DEP_PARENT)
scrolled.add(self.revdep_treeview)
box.add(scrolled)
pane.add2(box)
self.show_all()
def __init__(self):
Gtk.Window.__init__(self, title="EFI boot manager")
self.set_border_width(10)
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6)
self.add(vbox)
self.store = EFIStore(self)
self.tree = Gtk.TreeView(self.store, vexpand=True)
vbox.add(self.tree)
renderer_text = Gtk.CellRendererText()
renderer_check = Gtk.CellRendererToggle(radio=False)
renderer_radio = Gtk.CellRendererToggle(radio=True)
renderer_check.connect("toggled", self.store.change_active)
renderer_radio.connect("toggled", self.store.change_boot_next)
self.tree.append_column(Gtk.TreeViewColumn("BootNum", renderer_text, text=0))
self.tree.append_column(Gtk.TreeViewColumn("Name", renderer_text, text=1))
self.tree.append_column(Gtk.TreeViewColumn("Loader", renderer_text, text=2))
self.tree.append_column(Gtk.TreeViewColumn("Active", renderer_check, active=3))
self.tree.append_column(Gtk.TreeViewColumn("NextBoot", renderer_radio, active=4))
for column in self.tree.get_columns():
column.set_resizable(True)
column.set_min_width(75)
hb = Gtk.HeaderBar()
hb.set_show_close_button(True)
hb.props.title = "EFI boot manager"
self.set_titlebar(hb)
clear_btn = btn_with_icon("edit-clear-all-symbolic")
clear_btn.connect("button-press-event", self.discard_changes)
hb.pack_end(clear_btn)
write_btn = btn_with_icon("document-save-symbolic")
write_btn.connect("button-press-event", self.apply_changes)
hb.pack_end(write_btn)
hbox = Gtk.HButtonBox()
hbox.set_layout(Gtk.ButtonBoxStyle.EXPAND)
vbox.add(hbox)
up = btn_with_icon("go-up-symbolic")
down = btn_with_icon("go-down-symbolic")
new = btn_with_icon("list-add-symbolic")
delete = btn_with_icon("list-remove-symbolic")
hbox.add(up)
hbox.add(down)
hbox.add(new)
hbox.add(delete)
up.connect("button-press-event", self.up)
down.connect("button-press-event", self.down)
new.connect("button-press-event", self.new)
delete.connect("button-press-event", self.delete)
self.connect("delete-event", self.quit)
self.set_default_size(300, 260)
def __init__(self):
Gtk.Dialog.__init__(self, _("GNU Solfege Preferences"),
solfege.win, 0,
(Gtk.STOCK_HELP, Gtk.ResponseType.HELP, Gtk.STOCK_CLOSE, Gtk.ResponseType.CLOSE))
cfg.ConfigUtils.__init__(self, 'configwindow')
self.connect('response', self.apply_and_close)
# We do this so that the window is only hidden when the
# user click on the close button provided by the window manager.
self.connect('delete-event', self.on_destroy)#lambda w, e: True)
hbox = Gtk.HBox()
hbox.set_spacing(gu.hig.SPACE_LARGE)
hbox.set_border_width(gu.hig.SPACE_SMALL)
self.vbox.pack_start(hbox, True, True, 0)
frame = Gtk.Frame()
self.g_pages = Gtk.TreeStore(str)
self.g_pview = Gtk.TreeView(self.g_pages)
self.g_pview.set_headers_visible(False)
hbox.pack_start(frame, False, False, 0)
frame.add(self.g_pview)
self.g_page_box = Gtk.HBox()
hbox.pack_start(self.g_page_box, True, True, 0)
self.m_page_mapping = {}
def cursor_changed(treeview):
path, col = treeview.get_cursor()
if not path:
return
path = tuple(path)
for key, page in self.m_page_mapping.items():
if key == path:
page.show()
else:
page.hide()
self.m_page_mapping[path].show_all()
tvcol = Gtk.TreeViewColumn("Col 0")
self.g_pview.append_column(tvcol)
cell = Gtk.CellRendererText()
tvcol.pack_start(cell, True)
tvcol.add_attribute(cell, 'text', 0)
hbox.show_all()
self.create_midi_config()
self.create_user_config()
self.create_external_programs_config()
self.create_gui_config()
self.create_practise_config()
self.create_sound_config()
self.create_statistics_config()
self.g_pview.connect('cursor-changed', cursor_changed)
def create_idtone_accels_config(self, parent):
it, page_vbox = self.new_page_box(parent, _("Identify tone keyboard accelerators"))
self.g_idtone_accels = Gtk.ListStore(GObject.TYPE_STRING,
GObject.TYPE_STRING)
notenames = ('c', 'cis', 'd', 'dis', 'e', 'f', 'fis',
'g', 'gis', 'a', 'ais', 'b')
for notename in notenames:
self.g_idtone_accels.append((
solfege.mpd.MusicalPitch.new_from_notename(notename).get_user_notename(),
cfg.get_string('idtone/tone_%s_ak' % notename)))
self.g_treeview = Gtk.TreeView(self.g_idtone_accels)
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn(_("Note name"), renderer, text=0)
self.g_treeview.append_column(column)
renderer = Gtk.CellRendererAccel()
renderer.set_property('editable', True)
def acc_ff(renderer, path, accel_key, accel_mods, hw_key):
is_unique = True
for notename in notenames:
if (notename != notenames[int(path)]
and cfg.get_string('idtone/tone_%s_ak' % notename) == unichr(accel_key)):
is_unique = False
break
if not is_unique:
gu.dialog_ok(_(u"The accelerator in use for the tone “%s”. You have to choose another key.") % solfege.mpd.MusicalPitch.new_from_notename(notename).get_user_notename(), parent=self, msgtype=Gtk.MessageType.ERROR)
return
it = self.g_idtone_accels.get_iter(path)
cfg.set_string('idtone/tone_%s_ak' % notenames[int(path)], unichr(accel_key))
self.g_idtone_accels.set(it, 1, unichr(accel_key))
return True
renderer.connect('accel-edited', acc_ff)
column = Gtk.TreeViewColumn(_i("keyboard|Key"), renderer, text=1)
self.g_treeview.append_column(column)
page_vbox.pack_start(self.g_treeview, True, True, 0)
layouts = {'ascii': (_('ASCII'), u'awsedfujikol'),
'dvorak': (_('Dvorak'), u'a,o.eughctrn'),
}
hbox = Gtk.HBox()
page_vbox.pack_start(hbox, False, False, 0)
def set_buttons(widget, layout):
v = layouts[layout][1]
idx = 0
it = self.g_idtone_accels.get_iter_first()
while True:
self.g_idtone_accels.set_value(it, 1, v[idx])
cfg.set_string('idtone/tone_%s_ak' % notenames[idx], v[idx])
it = self.g_idtone_accels.iter_next(it)
idx += 1
if not it:
break
for key in layouts:
btn = Gtk.Button(layouts[key][0])
btn.connect('clicked', set_buttons, key)
hbox.pack_start(btn, True, True, 0)
def create_interval_accels_config(self, parent):
it, page_vbox = self.new_page_box(parent, _("Interval keyboard accelerators"))
self.g_interval_accels = Gtk.ListStore(GObject.TYPE_STRING,
GObject.TYPE_STRING)
intervals = ['minor2', 'major2', 'minor3', 'major3',
'perfect4', 'diminished5', 'perfect5', 'minor6',
'major6', 'minor7', 'major7', 'perfect8',
'minor9', 'major9', 'minor10', 'major10']
for interval in intervals:
self.g_interval_accels.append((
mpd.Interval.new_from_int(intervals.index(interval)).get_name(),
cfg.get_string('interval_input/%s' % interval)))
self.g_intervals_treeview = Gtk.TreeView(self.g_interval_accels)
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn(_("Interval"), renderer, text=0)
self.g_intervals_treeview.append_column(column)
renderer = Gtk.CellRendererAccel()
renderer.set_property('editable', True)
def acc_ff(renderer, path, accel_key, accel_mods, hw_key):
is_unique = True
for interval in intervals:
if (interval != intervals[int(path)]
and cfg.get_string('interval_input/%s' % interval) == unichr(accel_key)):
is_unique = False
break
if not is_unique:
gu.dialog_ok(_(u"The accelerator in use for “%s”. You have to choose another key.") % mpd.Interval.new_from_int(intervals.index(interval)).get_name(), parent=self, msgtype=Gtk.MessageType.ERROR)
return
it = self.g_interval_accels.get_iter(path)
cfg.set_string('interval_input/%s' % intervals[int(path)], unichr(accel_key))
self.g_interval_accels.set(it, 1, unichr(accel_key))
return True
renderer.connect('accel-edited', acc_ff)
column = Gtk.TreeViewColumn(_i("keyboard|Key"), renderer, text=1)
self.g_intervals_treeview.append_column(column)
page_vbox.pack_start(self.g_intervals_treeview, True, True, 0)
hbox = Gtk.HBox()
page_vbox.pack_start(hbox, False, False, 0)
layouts = {'ascii': (_('ASCII'), u'1qaz2wsx3edc4rfv'),
'dvorak': (_('Dvorak'), u"1'a;2,oq3.ej4puk"),
}
def set_buttons(widget, layout):
v = layouts[layout][1]
idx = 0
it = self.g_interval_accels.get_iter_first()
while True:
self.g_interval_accels.set_value(it, 1, v[idx])
cfg.set_string('interval_input/%s' % intervals[idx], v[idx])
it = self.g_interval_accels.iter_next(it)
idx += 1
if not it:
break
for key in layouts:
btn = Gtk.Button(layouts[key][0])
btn.connect('clicked', set_buttons, key)
hbox.pack_start(btn, True, True, 0)
def __init__(self, default_profile):
Gtk.Dialog.__init__(self, _("GNU Solfege - Choose User Profile"))
# We save the initially selected profile, because we need to keep
# track of it if the user renames it and then presses cancel.
self.m_default_profile = default_profile
vbox = gu.hig_dlg_vbox()
self.vbox.pack_start(vbox, False, False, 0)
l = Gtk.Label(_("Solfege will save your statistics and test results in the user profile. By adding additional user profiles to Solfege, multiple users can share a user account on the operating system."))
l.set_alignment(0.0, 0.5)
l.set_line_wrap(True)
vbox.pack_start(l, True, True, 0)
hbox = Gtk.HBox()
hbox.set_spacing(gu.hig.SPACE_MEDIUM)
vbox.pack_start(hbox, True, True, 0)
button_box = Gtk.VBox()
self.g_create_profile = Gtk.Button.new_with_mnemonic(_(u"_Create profile\u2026"))
self.g_create_profile.connect('clicked', self.on_create_profile)
button_box.pack_start(self.g_create_profile, False, False, 0)
self.g_rename_profile = Gtk.Button.new_with_mnemonic(_(u"_Rename profile\u2026"))
self.g_rename_profile.connect('clicked', self.on_rename_profile)
button_box.pack_start(self.g_rename_profile, False, False, 0)
self.g_delete_profile = Gtk.Button.new_with_mnemonic(_(u"_Delete profile\u2026"))
self.g_delete_profile.connect('clicked', self.on_delete_profile)
button_box.pack_start(self.g_delete_profile, False, False, 0)
hbox.pack_start(button_box, False, False, 0)
self.g_liststore = liststore = Gtk.ListStore(GObject.TYPE_STRING)
liststore.append((_("Standard profile"),))
if os.path.exists(os.path.join(filesystem.app_data(), 'profiles')):
for subdir in os.listdir(os.path.join(filesystem.app_data(),
'profiles')):
liststore.append((subdir,))
#
self.g_tw = tw = Gtk.TreeView(liststore)
tw.connect('row-activated', lambda a, b, c: self.response(Gtk.ResponseType.ACCEPT))
tw.set_headers_visible(False)
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn(None, renderer, text=0)
tw.append_column(column)
hbox.pack_start(tw, False, False, 0)
tw.show()
tw.connect('cursor-changed', self.on_cursor_changed)
tw.set_cursor((0,))
for idx, s in enumerate(self.g_liststore):
if s[0].decode("utf-8") == default_profile:
tw.set_cursor((idx, ))
#
chk = gu.nCheckButton("app", "noprofilemanager", _("D_on't ask at startup"))
vbox.pack_start(chk, False, False, 0)
self.show_all()
def __init__(self, parent, app, title, source_url, save_path):
'''???BT???????.
source_url - ???BT????, ?????????.
???????, ???magent:???????.
'''
super().__init__(title, app.window, Gtk.DialogFlags.MODAL,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
Gtk.STOCK_OK, Gtk.ResponseType.OK))
self.app = app
self.source_url = source_url
self.save_path = save_path
self.set_default_response(Gtk.ResponseType.OK)
self.set_default_size(520, 480)
self.set_border_width(10)
box = self.get_content_area()
select_all_button = Gtk.ToggleButton.new_with_label(_('Select All'))
select_all_button.props.halign = Gtk.Align.START
select_all_button.props.margin_bottom = 5
select_all_button.connect('toggled', self.on_select_all_toggled)
box.pack_start(select_all_button, False, False, 0)
scrolled_win = Gtk.ScrolledWindow()
box.pack_start(scrolled_win, True, True, 0)
# check, name, size, humansize
self.liststore = Gtk.ListStore(bool, str, GObject.TYPE_INT64, str)
self.treeview = Gtk.TreeView(model=self.liststore)
self.treeview.set_tooltip_column(NAME_COL)
scrolled_win.add(self.treeview)
check_cell = Gtk.CellRendererToggle()
check_cell.connect('toggled', self.on_check_cell_toggled)
check_col = Gtk.TreeViewColumn('', check_cell, active=CHECK_COL)
self.treeview.append_column(check_col)
name_cell = Gtk.CellRendererText(ellipsize=Pango.EllipsizeMode.END,
ellipsize_set=True)
name_col = Gtk.TreeViewColumn(_('Name'), name_cell, text=NAME_COL)
name_col.set_expand(True)
self.treeview.append_column(name_col)
size_cell = Gtk.CellRendererText()
size_col = Gtk.TreeViewColumn(_('Size'), size_cell, text=HUMANSIZE_COL)
self.treeview.append_column(size_col)
box.show_all()
self.request_data()
def __init__(self, parent, app, title=_('Save to..')):
self.parent = parent
self.app = app
super().__init__(title, app.window, Gtk.DialogFlags.MODAL,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
Gtk.STOCK_OK, Gtk.ResponseType.OK))
self.set_default_size(440, 480)
self.set_border_width(10)
self.set_default_response(Gtk.ResponseType.OK)
box = self.get_content_area()
control_box = Gtk.Box()
box.pack_start(control_box, False, False, 0)
mkdir_button = Gtk.Button.new_with_label(_('Create Folder'))
control_box.pack_end(mkdir_button, False, False, 0)
mkdir_button.connect('clicked', self.on_mkdir_clicked)
reload_button = Gtk.Button.new_with_label(_('Reload'))
control_box.pack_end(reload_button, False, False, 5)
reload_button.connect('clicked', self.on_reload_clicked)
scrolled_win = Gtk.ScrolledWindow()
box.pack_start(scrolled_win, True, True, 5)
# disname, path, empty, loaded
self.treestore = Gtk.TreeStore(str, str, bool, bool)
self.treeview = Gtk.TreeView(model=self.treestore)
self.selection = self.treeview.get_selection()
scrolled_win.add(self.treeview)
icon_cell = Gtk.CellRendererPixbuf(icon_name='folder')
name_cell = Gtk.CellRendererText()
name_col = Gtk.TreeViewColumn(_('Folder'))
name_col.pack_start(icon_cell, False)
name_col.pack_start(name_cell, True)
if Config.GTK_LE_36:
name_col.add_attribute(name_cell, 'text', NAME_COL)
else:
name_col.set_attributes(name_cell, text=NAME_COL)
self.treeview.append_column(name_col)
self.treeview.connect('row-expanded', self.on_row_expanded)
box.show_all()
self.reset()
def __init__(self):
GObject.GObject.__init__(self)
self.set_position (500)
# Graph viewers
hbox = Gtk.HBox(True, 5)
dw = self.dw = DiffView()
dw2 = self.dw2 = DiffView()
hbox.pack_start(dw, True, True, 0)
hbox.pack_start(dw2, True, True, 0)
self.add(hbox)
# Function list
scrolledwin = Gtk.ScrolledWindow()
scrolledwin.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
liststore = self.liststore = Gtk.ListStore(str, str, str, str, str)
treeview = Gtk.TreeView(liststore)
# Column Address L
tvcolumn0 = Gtk.TreeViewColumn('Function L')
treeview.append_column(tvcolumn0)
cell0 = Gtk.CellRendererText()
tvcolumn0.pack_start(cell0, True)
tvcolumn0.add_attribute(cell0, 'text', 0)
tvcolumn0.set_sort_column_id(0)
# Column Function L
tvcolumn1 = Gtk.TreeViewColumn('Address L')
treeview.append_column(tvcolumn1)
cell1 = Gtk.CellRendererText()
tvcolumn1.pack_start(cell1, True)
tvcolumn1.add_attribute(cell1, 'text', 1)
tvcolumn1.set_sort_column_id(1)
# Column Address R
tvcolumn2 = Gtk.TreeViewColumn('Function R')
treeview.append_column(tvcolumn2)
cell2 = Gtk.CellRendererText()
tvcolumn2.pack_start(cell2, True)
tvcolumn2.add_attribute(cell2, 'text', 2)
tvcolumn2.set_sort_column_id(2)
# Column Function R
tvcolumn3 = Gtk.TreeViewColumn('Address R')
treeview.append_column(tvcolumn3)
cell3 = Gtk.CellRendererText()
tvcolumn3.pack_start(cell3, True)
tvcolumn3.add_attribute(cell3, 'text', 3)
tvcolumn3.set_sort_column_id(3)
# Column Diff
tvcolumn4 = Gtk.TreeViewColumn('Diff')
treeview.append_column(tvcolumn4)
cell4 = Gtk.CellRendererText()
tvcolumn4.pack_start(cell4, True)
tvcolumn4.add_attribute(cell4, 'text', 4)
tvcolumn4.set_sort_column_id(4)
# Set treeview options and add it to scrolledwin
treeview.set_reorderable(True)
scrolledwin.add(treeview)
self.add2(scrolledwin)
treeview.connect('row-activated', self.on_row_activated)
def setup_builder(self):
"""
Setup the layout for the window and containers.
"""
grid = Gtk.Grid()
grid.set_column_homogeneous(True)
scroll_window = Gtk.ScrolledWindow()
scroll_window.set_vexpand(True)
grid.attach(scroll_window, 0, 0, 1, 1)
self.builder_grid = ModifyGrid()
add_button = Gtk.Button.new_with_label("Add")
add_button.connect('clicked', self.add_entry)
add_button.set_margin_top(5)
self.builder_grid.attach(add_button, 1, 9, 2, 1)
grid.attach(self.builder_grid, 1, 0, 1, 1)
self.course_manager.store = Gtk.ListStore(str, str, int, str, int)
self.added_tree = Gtk.TreeView(self.course_manager.store)
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("Course", renderer, text=0)
self.added_tree.append_column(column)
column = Gtk.TreeViewColumn("Year/Quarter", renderer, text=1)
self.added_tree.append_column(column)
column = Gtk.TreeViewColumn("Units", renderer, text=2)
self.added_tree.append_column(column)
column = Gtk.TreeViewColumn("Type", renderer, text=3)
self.added_tree.append_column(column)
self.added_tree.connect('button-press-event', self.treeview_clicked)
scroll_window.add(self.added_tree)
self.interface_switcher.insert_page(grid, None, 1)
def __init__(self, keybindings):
super().__init__()
self.set_orientation(Gtk.Orientation.VERTICAL)
self._keybindings = keybindings
scrolled_window = Gtk.ScrolledWindow()
scrolled_window.set_policy(
Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC
)
self._store = Gtk.ListStore(str, str, int, int)
self._tree_view = Gtk.TreeView()
self._tree_view.set_model(self._store)
self._tree_view.set_vexpand(True)
self._tree_view.set_hexpand(True)
self._tree_view.get_selection().set_mode(Gtk.SelectionMode.SINGLE)
action_renderer = Gtk.CellRendererText()
action_column = Gtk.TreeViewColumn()
action_column.props.title = _('Action')
action_column.props.expand = True
action_column.pack_start(action_renderer, True)
action_column.add_attribute(action_renderer, 'text', 1)
self._tree_view.append_column(action_column)
keybinding_renderer = Gtk.CellRendererAccel()
keybinding_renderer.props.editable = True
keybinding_renderer.connect('accel-edited', self._on_accel_edited)
keybinding_column = Gtk.TreeViewColumn()
keybinding_column.props.title = _('Modify')
keybinding_column.pack_end(keybinding_renderer, False)
keybinding_column.add_attribute(
keybinding_renderer,
'accel-mods',
KeybindingsWidget.Columns.MODS
)
keybinding_column.add_attribute(
keybinding_renderer,
'accel-key',
KeybindingsWidget.Columns.KEY
)
self._tree_view.append_column(keybinding_column)
scrolled_window.add(self._tree_view)
self.add(scrolled_window)
self._refresh()
def __init__(self, desktopFile):
self.desktopFile = desktopFile
(status, output) = subprocess.getstatusoutput("dpkg -S " + self.desktopFile)
package = output[:output.find(":")]
if status != 0:
warnDlg = Gtk.MessageDialog(None, 0, Gtk.MessageType.WARNING, Gtk.ButtonsType.YES_NO, _("This application has been removed. Are you sure remove the menu form the startup menu?"))
warnDlg.vbox.set_spacing(10)
response = warnDlg.run()
if response == Gtk.ResponseType.YES :
print (("removing '%s'" % self.desktopFile))
os.system("rm -f '%s'" % self.desktopFile)
os.system("rm -f '%s.desktop'" % self.desktopFile)
warnDlg.destroy()
sys.exit(0)
warnDlg = Gtk.MessageDialog(None, 0, Gtk.MessageType.WARNING, Gtk.ButtonsType.OK_CANCEL, _("The following packages will be removed:"))
warnDlg.vbox.set_spacing(10)
treeview = Gtk.TreeView()
column1 = Gtk.TreeViewColumn(_("Packages will be removed"))
renderer = Gtk.CellRendererText()
column1.pack_start(renderer, False)
column1.add_attribute(renderer, "text", 0)
treeview.append_column(column1)
model = Gtk.ListStore(str)
dependenciesString = subprocess.getoutput("apt-get -s -q remove " + package + " | grep Remv")
dependencies = string.split(dependenciesString, "\n")
for dependency in dependencies:
dependency = dependency.replace("Remv ", "")
model.append([dependency])
treeview.set_model(model)
treeview.show()
scrolledwindow = Gtk.ScrolledWindow()
scrolledwindow.set_shadow_type(Gtk.ShadowType.ETCHED_OUT)
scrolledwindow.set_size_request(300, 150)
scrolledwindow.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
scrolledwindow.add(treeview)
scrolledwindow.show()
warnDlg.get_content_area().add(scrolledwindow)
response = warnDlg.run()
if response == Gtk.ResponseType.OK :
executer = RemoveExecuter(package)
executer.start()
elif response == Gtk.ResponseType.CANCEL :
sys.exit(0)
warnDlg.destroy()
Gtk.main()
VulnerabilitiesSpider.py 文件源码
项目:Vulnerabilities-spider
作者: muhammad-bouabid
项目源码
文件源码
阅读 24
收藏 0
点赞 0
评论 0
def __init__(self, parent):
Gtk.Dialog.__init__(self, "History Scanne Tables", parent,
Gtk.DialogFlags.MODAL, buttons=(
Gtk.STOCK_OK, Gtk.ResponseType.OK,
Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL))
self.set_default_size(500, 400)
box = self.get_content_area()
self.HoriBox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
box.add(self.HoriBox)
self.scrolledwindow = Gtk.ScrolledWindow()
self.scrolledwindow.set_hexpand(True)
self.scrolledwindow.set_vexpand(True)
self.HoriBox.pack_start(self.scrolledwindow, True, True, 0)
self.people_lst = []
#convert data to listStore Now (lists that TreeView can Display)
peoples_list_store = Gtk.ListStore(str, str, str, str)
for item in self.people_lst:
peoples_list_store.append(list(item))
#Make treeView for those item will display
people_tree_view = Gtk.TreeView(peoples_list_store)
for i, col_title in enumerate(["Website", "Point", "Faille","Payload"]):
#Render means how to draw the data
renderer = Gtk.CellRendererText()
#create columns
column = Gtk.TreeViewColumn(col_title, renderer, text=i)
column.set_sort_column_id(i) # Make the Columns Sortable just bech ywali bsort (option)
people_tree_view.append_column(column) # Add column to treeView
#Handel data
selected_row = people_tree_view.get_selection()
selected_row.connect("changed", self.the_item_selected)
# Add TreeView to main layout now
self.scrolledwindow.add(people_tree_view)
self.show_all()
#user selectred row method
def user_agent(self):
if self.tabs[self.current_page][0]\
.scrolled_window.get_name() != "webview": return True
window = build_window(self, 0, 0)
window.set_titlebar(build_headerbar("User Agent", None, 1))
scrolled_window = Gtk.ScrolledWindow()
scrolled_window.set_size_request(400, 300)
tree = Gtk.TreeView()
tree.connect('row-activated', self.new_user_agent)
column = Gtk.TreeViewColumn()
column.set_title(_("Double click item to switch"))
cell = Gtk.CellRendererText()
column.pack_start(cell, True)
column.add_attribute(cell, "text", 0)
treestore = Gtk.TreeStore(str, str)
ua_browsers_list = []
ua_mobile_list = []
ua_crawlers_list = []
treestore.append(None, ["Default", ""])
browsers = treestore.append(None, ["Browsers", None])
for c, i in enumerate(ua_browsers_dsc): ua_browsers_list.append([i, ua_browsers_val[c]])
ua_browsers_list.sort()
for c, i in enumerate(ua_browsers_list): treestore.append(browsers, [ua_browsers_list[c][0], ua_browsers_list[c][1]])
mobile = treestore.append(None, ["Mobile Browsers", None])
for c, i in enumerate(ua_mobile_dsc): ua_mobile_list.append([i, ua_mobile_val[c]])
ua_mobile_list.sort()
for c, i in enumerate(ua_mobile_list): treestore.append(mobile, [ua_mobile_list[c][0], ua_mobile_list[c][1]])
crawlers = treestore.append(None, ["Crawlers", None])
for c, i in enumerate(ua_crawlers_dsc): ua_crawlers_list.append([i, ua_crawlers_val[c]])
ua_crawlers_list.sort()
for c, i in enumerate(ua_crawlers_list): treestore.append(crawlers, [ua_crawlers_list[c][0], ua_crawlers_list[c][1]])
tree.append_column(column)
tree.set_model(treestore)
scrolled_window.add(tree)
window.add(scrolled_window)
window.show_all()
def __init__(self, icons):
Gtk.ScrolledWindow.__init__(self)
BasePane.__init__(self)
self.state = DisplayState()
self.pane_name = _("Progress")
self.tv = Gtk.TreeView()
# customization
self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
self.add(self.tv)
self.tv.set_headers_visible(False)
self.tv.connect("button-press-event", self._on_button_pressed)
# icon
self.icons = icons
tp = Gtk.CellRendererPixbuf()
tp.set_property("xpad", self.CANCEL_XPAD)
tp.set_property("ypad", self.CANCEL_YPAD)
column = Gtk.TreeViewColumn("Icon", tp, pixbuf=PendingStore.COL_ICON)
self.tv.append_column(column)
# name
tr = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("Name", tr, markup=PendingStore.COL_STATUS)
column.set_min_width(200)
column.set_expand(True)
self.tv.append_column(column)
# progress
tp = Gtk.CellRendererProgress()
tp.set_property("xpad", self.CANCEL_XPAD)
tp.set_property("ypad", self.CANCEL_YPAD)
tp.set_property("text", "")
column = Gtk.TreeViewColumn("Progress", tp,
value=PendingStore.COL_PROGRESS,
pulse=PendingStore.COL_PULSE)
column.set_min_width(200)
self.tv.append_column(column)
# cancel icon
tpix = Gtk.CellRendererPixbuf()
column = Gtk.TreeViewColumn("Cancel", tpix,
stock_id=PendingStore.COL_CANCEL)
self.tv.append_column(column)
# fake columns that eats the extra space at the end
tt = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("Cancel", tt)
self.tv.append_column(column)
# add it
store = PendingStore(icons)
self.tv.set_model(store)
def __init__(self, icons):
Gtk.ScrolledWindow.__init__(self)
BasePane.__init__(self)
self.state = DisplayState()
self.pane_name = _("Progress")
self.tv = Gtk.TreeView()
# customization
self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
self.add(self.tv)
self.tv.set_headers_visible(False)
self.tv.connect("button-press-event", self._on_button_pressed)
# icon
self.icons = icons
tp = Gtk.CellRendererPixbuf()
tp.set_property("xpad", self.CANCEL_XPAD)
tp.set_property("ypad", self.CANCEL_YPAD)
column = Gtk.TreeViewColumn("Icon", tp, pixbuf=PendingStore.COL_ICON)
self.tv.append_column(column)
# name
tr = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("Name", tr, markup=PendingStore.COL_STATUS)
column.set_min_width(200)
column.set_expand(True)
self.tv.append_column(column)
# progress
tp = Gtk.CellRendererProgress()
tp.set_property("xpad", self.CANCEL_XPAD)
tp.set_property("ypad", self.CANCEL_YPAD)
tp.set_property("text", "")
column = Gtk.TreeViewColumn("Progress", tp,
value=PendingStore.COL_PROGRESS,
pulse=PendingStore.COL_PULSE)
column.set_min_width(200)
self.tv.append_column(column)
# cancel icon
tpix = Gtk.CellRendererPixbuf()
column = Gtk.TreeViewColumn("Cancel", tpix,
stock_id=PendingStore.COL_CANCEL)
self.tv.append_column(column)
# fake columns that eats the extra space at the end
tt = Gtk.CellRendererText()
column = Gtk.TreeViewColumn("Cancel", tt)
self.tv.append_column(column)
# add it
store = PendingStore(icons)
self.tv.set_model(store)