def load_font(self):
fontdesc = pango.FontDescription(Prefs.current_font)
context = self.textview0.get_pango_context()
metrics = context.get_metrics(fontdesc, context.get_language())
self.pixels_per_line = (metrics.get_ascent() +
metrics.get_descent()) / 1024
self.pango_char_width = metrics.get_approximate_char_width()
tabs = pango.TabArray(10, 0)
tab_size = Prefs.tab_size
for i in range(10):
tabs.set_tab(i, pango.TAB_LEFT,
i * tab_size * self.pango_char_width)
for i in range(2):
self.textview[i].modify_font(fontdesc)
self.textview[i].set_tabs(tabs)
self.linkmap.queue_draw()
self.pixbuf_apply0 = load_pixbuf("button_apply0.xpm",
self.pixels_per_line)
self.pixbuf_apply1 = load_pixbuf("button_apply1.xpm",
self.pixels_per_line)
self.pixbuf_delete = load_pixbuf("button_delete.xpm",
self.pixels_per_line)
self.pixbuf_copy0 = load_pixbuf("button_copy0.xpm",
self.pixels_per_line)
self.pixbuf_copy1 = load_pixbuf("button_copy1.xpm",
self.pixels_per_line)
def __init__(self, scrolling='hv', **kwds):
gtk_sw = gtk.ScrolledWindow()
gtk_sw.show()
gtk_tv = gtk.TextView()
gtk_tv.show()
gtk_sw.add(gtk_tv)
gtk_tb = gtk.TextBuffer()
self._gtk_textbuffer = gtk_tb
gtk_tv.set_buffer(self._gtk_textbuffer)
tag = gtk.TextTag()
tabs = pango.TabArray(1, True)
tabs.set_tab(0, pango.TAB_LEFT, 28)
tag.set_property('tabs', tabs)
tag.set_property('tabs-set', True)
self._gtk_tag = tag
gtk_tb.get_tag_table().add(tag)
GTextEditor.__init__(self,
_gtk_outer=gtk_sw,
_gtk_inner=gtk_tv,
_gtk_focus=gtk_tv,
**kwds)
self.set_hscrolling('h' in scrolling)
self.set_vscrolling('v' in scrolling)
if 'h' not in scrolling:
gtk_tv.set_wrap_mode(gtk.WRAP_WORD)
self._gtk_apply_tag()
def setfont(self, fam=None, size=None):
self.pangolayout = self.window.create_pango_layout("a")
if fam or size:
fd = pango.FontDescription()
if fam:
fd.set_family(fam)
if size:
fd.set_size(size * pango.SCALE)
self.pangolayout.set_font_description(fd)
# Get Pango steps
self.cxx, self.cyy = self.pangolayout.get_pixel_size()
# Get Pango tabs
self.tabarr = pango.TabArray(80, False)
for aa in range(self.tabarr.get_size()):
self.tabarr.set_tab(aa, pango.TAB_LEFT,
aa * TABSTOP * self.cxx * pango.SCALE)
self.pangolayout.set_tabs(self.tabarr)
ts = self.pangolayout.get_tabs()
if ts != None:
al, self.tabstop = ts.get_tab(1)
self.tabstop /= self.cxx * pango.SCALE
def open(self, filename, container=None):
self.type = "gtk"
self.has_data = True
self.tag_table = gtk.TextTagTable()
sheet = self.get_style_sheet()
for name in sheet.get_paragraph_style_names():
tag = gtk.TextTag(name)
style = sheet.get_paragraph_style(name)
font = style.get_font()
if font.get_type_face() == FONT_SERIF:
tag.set_property("family", "Serif")
elif font.get_type_face() == FONT_SANS_SERIF:
tag.set_property("family", "Sans")
elif font.get_type_face() == FONT_MONOSPACE:
tag.set_property("family", "MonoSpace")
tag.set_property("size-points", float(font.get_size()))
if font.get_bold():
tag.set_property("weight", pango.WEIGHT_BOLD)
if style.get_alignment() == PARA_ALIGN_RIGHT:
tag.set_property("justification", gtk.JUSTIFY_RIGHT)
elif style.get_alignment() == PARA_ALIGN_LEFT:
tag.set_property("justification", gtk.JUSTIFY_LEFT)
elif style.get_alignment() == PARA_ALIGN_CENTER:
tag.set_property("justification", gtk.JUSTIFY_CENTER)
else:
tag.set_property("justification", gtk.JUSTIFY_FILL)
if font.get_italic():
tag.set_property("style", pango.STYLE_ITALIC)
if style.get_first_indent():
tag.set_property("indent", pixels(style.get_first_indent()))
#tag.set_property("tabs", [pixels(abs(style.get_first_indent()))])
tag.set_property("left-margin", pixels(style.get_left_margin()))
tag.set_property("right-margin", pixels(style.get_right_margin()))
tag.set_property("pixels-above-lines", pixels(style.get_top_margin()))
tag.set_property("pixels-below-lines", pixels(style.get_bottom_margin()))
tag.set_property("wrap-mode", gtk.WRAP_WORD)
new_tabs = style.get_tabs()
tab_array = pango.TabArray(len(new_tabs)+1,True)
index = 0
for tab in map(pixels, new_tabs):
tab_array.set_tab(index, pango.TAB_LEFT, tab)
index += 1
tag.set_property("tabs", tab_array)
self.tag_table.add(tag)
self.buffer = gtk.TextBuffer(self.tag_table)
if container:
return DocumentManager(_('Quick View'), self, container)
else:
DisplayBuf(_('Quick View'), self)
return
def __init__(self):
gtk.TextBuffer.__init__(self)
tt = self.get_tag_table()
self.refcount = 0
self.filename = None
self.untitled_serial = -1
self.color_tags = []
self.color_cycle_timeout_id = 0
self.start_hue = 0.0
for i in range(Buffer.N_COLORS):
tag = self.create_tag()
self.color_tags.append(tag)
#self.invisible_tag = self.create_tag(None, invisible=True)
self.not_editable_tag = self.create_tag(editable=False,
foreground="purple")
self.found_text_tag = self.create_tag(foreground="red")
tabs = pango.TabArray(4, True)
tabs.set_tab(0, pango.TAB_LEFT, 10)
tabs.set_tab(1, pango.TAB_LEFT, 30)
tabs.set_tab(2, pango.TAB_LEFT, 60)
tabs.set_tab(3, pango.TAB_LEFT, 120)
self.custom_tabs_tag = self.create_tag(tabs=tabs, foreground="green")
TestText.buffers.push(self)
def __init__(self):
gtk.TextBuffer.__init__(self)
tabledesbalises = self.get_tag_table()
self.comptref = 0
self.nomfichier = None
self.sanstitre_num = -1
self.balises_couleurs = []
self.marqueur_cycle_couleurs = 0
self.teinte_depart = 0.0
for i in range(Buffer.NBRE_COULEURS):
balise = self.create_tag()
self.balises_couleurs.append(balise)
#self.balise_invisible = self.create_tag(None, invisible=True)
self.balise_non_editable = self.create_tag(editable=False,
foreground="purple")
self.balise_resultat = self.create_tag(foreground="red")
tabulations = pango.TabArray(4, True)
tabulations.set_tab(0, pango.TAB_LEFT, 10)
tabulations.set_tab(1, pango.TAB_LEFT, 30)
tabulations.set_tab(2, pango.TAB_LEFT, 60)
tabulations.set_tab(3, pango.TAB_LEFT, 120)
self.balise_tabs_perso = self.create_tag(tabs=tabulations,
foreground="green")
TestTexte.buffers.empiler(self)
def setTabs(self,*args): n = len(args) t = pango.TabArray(n,True) i = 0 for v in args: t.set_tab(i,pango.TAB_LEFT,v) i+=1; self.textview.set_tabs(t)
def set_up_log_view_columns(self):
"""Set up tab stops in the log view."""
pango_context = self.log_view.get_pango_context()
em = pango_context.get_font_description().get_size()
tabs = pango.TabArray(2, False)
tabs.set_tab(0, pango.TAB_LEFT, 9 * em)
tabs.set_tab(1, pango.TAB_LEFT, 12 * em)
self.log_view.set_tabs(tabs)
def set_tab_width(self, width, force=False):
if width < 1:
return
if not force and width == self._tab_width:
return
tab_size = self._calculate_tab_size(width, ' ')
if not tab_size:
return
tab_array = pango.TabArray(1, True)
tab_array.set_tab(0, pango.TAB_LEFT, tab_size)
self.widget.set_tabs(tab_array)
self._tab_width = width
def __init__(self):
self.game = utils.get_game_ref()
glade_dir = self.game.get_glade_dir()
self.glade_file = os.path.join(glade_dir, "engine_output.glade")
Engine_Output.engine_output_ref = self
self.builder = gtk.Builder()
self.builder.add_from_file(self.glade_file)
self.builder.connect_signals(self)
self.window = self.builder.get_object('engine_output_window')
self.tv = [gtk.TextView(), gtk.TextView()]
self.tv[0] = self.builder.get_object('engine_output_textview1')
self.tv[1] = self.builder.get_object('engine_output_textview2')
self.tv[0].set_editable(False)
self.tv[1].set_editable(False)
tabs = pango.TabArray(4, True)
tabs.set_tab(0, pango.TAB_LEFT, 40)
tabs.set_tab(1, pango.TAB_LEFT, 160)
tabs.set_tab(2, pango.TAB_LEFT, 230)
tabs.set_tab(3, pango.TAB_LEFT, 280)
self.tv[0].set_tabs(tabs)
self.tv[1].set_tabs(tabs)
self.tb = [gtk.TextBuffer(), gtk.TextBuffer()]
self.tb[0] = self.tv[0].get_buffer()
self.tb[1] = self.tv[1].get_buffer()
#self.tb[0].set_text('')
#self.tb[1].set_text('')
self.nps_lbl = [gtk.Label(), gtk.Label()]
self.nps_lbl[0] = self.builder.get_object('engine_output_nodes_lbl1')
self.nps_lbl[1] = self.builder.get_object('engine_output_nodes_lbl2')
self.engine_name_lbl = [gtk.Label(), gtk.Label()]
self.engine_name_lbl[0] = self.builder.get_object('engine_output_engine_name_lbl1')
self.engine_name_lbl[1] = self.builder.get_object('engine_output_engine_name_lbl2')
self.ponder_move_lbl = [gtk.Label(), gtk.Label()]
self.ponder_move_lbl[0] = self.builder.get_object('engine_output_ponder_move_lbl1')
self.ponder_move_lbl[1] = self.builder.get_object('engine_output_ponder_move_lbl2')
self.currmove_lbl = [gtk.Label(), gtk.Label()]
self.currmove_lbl[0] = self.builder.get_object('engine_output_currmove_lbl1')
self.currmove_lbl[1] = self.builder.get_object('engine_output_currmove_lbl2')
def tabstop(self, value):
"""Sets tabstops for columns.
A semicolon separated list of tab positions (in pixels). If the position
is prefixed with a '+' sign it is relative to the previous position.
"""
v = value.split(';')
t = pango.TabArray(len(v), True)
c = 0
for i, x in enumerate(v):
if x[0] == '+':
x = c + int(x[1:])
else:
x = int(x)
c = x
t.set_tab(i, pango.TAB_LEFT, x)
self.area.set_tabs(t)
def __init__(self, controlState, xml):
controlState.displayHeaderBar = True
controlState.windowIcon = 'abouttoinstall.png'
controlState.windowTitle = "Summary of installation settings"
controlState.windowText = \
"Review the summary of the installation settings"
htmlTextView = HtmlTextView()
htmlTextView.set_wrap_mode(gtk.WRAP_NONE)
context = htmlTextView.get_pango_context()
initialFont = context.get_font_description()
# The review uses monospace, so get the font description for that at the
# same size as the default font used by the text view.
metrics = context.get_metrics(
pango.FontDescription('monospace, %d' %
(initialFont.get_size() / pango.SCALE)))
# Generate the list of tab stops from the column widths specified in
# the review module.
tabPosition = 0
ta = pango.TabArray(len(review.COLUMN_WIDTHS), True)
for index, charWidth in enumerate(review.COLUMN_WIDTHS):
tabPosition += pango.PIXELS(metrics.get_approximate_char_width() *
charWidth)
ta.set_tab(index, pango.TAB_LEFT, tabPosition)
htmlTextView.set_tabs(ta)
buf = review.produceText()
htmlTextView.display_html(buf)
viewPort = xml.get_widget('ReviewViewPort')
assert (viewPort)
for child in viewPort.get_children():
viewPort.remove(child)
viewPort.add(htmlTextView)
htmlTextView.show()
def set_package_details_text(labs, text, textview, installed_icon,
not_installed_icon, update_available_icon,
pkg_renamed):
style = textview.get_style()
font_size_in_pango_unit = style.font_desc.get_size()
font_size_in_pixel = font_size_in_pango_unit / pango.SCALE
tab_array = pango.TabArray(2, True)
infobuffer = textview.get_buffer()
infobuffer.set_text("")
max_test_len = 0
for lab in labs:
__add_label_to_generalinfo(infobuffer, 0, labs[lab])
test_len = get_textview_width(textview)
if test_len > max_test_len:
max_test_len = test_len
infobuffer.set_text("")
tab_array.set_tab(1, pango.TAB_LEFT, max_test_len + font_size_in_pixel)
textview.set_tabs(tab_array)
infobuffer.set_text("")
i = 0
__add_line_to_generalinfo(infobuffer, i, labs["name"], text["name"])
i += 1
if pkg_renamed:
i = __add_renamed_line_to_generalinfo(infobuffer, i, labs, text)
__add_line_to_generalinfo(infobuffer, i, labs["summ"], text["summ"])
i += 1
installed = False
if text["ins"].startswith(_("No")):
icon = not_installed_icon
else:
icon = installed_icon
installed = True
__add_line_to_generalinfo(infobuffer, i, labs["ins"], text["ins"], icon,
font_size_in_pixel)
i += 1
if installed:
if text["available"] != "No":
__add_line_to_generalinfo(infobuffer, i, labs["available"],
text["available"], update_available_icon,
font_size_in_pixel)
i += 1
if not pkg_renamed:
i = __add_renamed_line_to_generalinfo(infobuffer, i, labs, text)
else:
__add_line_to_generalinfo(infobuffer, i, labs["available"],
text["available"])
i += 1
if text["size"] != "0":
__add_line_to_generalinfo(infobuffer, i, labs["size"], text["size"])
i += 1
__add_line_to_generalinfo(infobuffer, i, labs["cat"], text["cat"])
i += 1
__add_line_to_generalinfo(infobuffer, i, labs["repository"],
text["repository"])
if len(text["desc"]) > 0:
i += 1
__add_label_to_generalinfo(infobuffer, i, labs["desc"] + '\n')
i += 1
itr = infobuffer.get_iter_at_line(i)
infobuffer.insert(itr, text["desc"])
def __init__(self):
#Set the Glade file
self.builder = gtk.Builder()
self.builder.add_from_file(GLADE_PATH)
# get top window
self.window = self.builder.get_object("top_window")
# status bar stuff
self.statusbar = self.builder.get_object("statusbar")
self.statusbar_ctx = self.statusbar.get_context_id("default")
# set buttons
self.save_button = self.builder.get_object('save_file_toolbutton')
self.connect_button = self.builder.get_object('connect_button')
self.save_button.set_sensitive(False)
self.connect_button.set_sensitive(True)
# set control buttons
self.controls = [
self.builder.get_object('reset_button'),
self.builder.get_object('bootloader_button'),
self.builder.get_object('exec_button'),
self.builder.get_object('stop_button'),
self.builder.get_object('zoomin_button'),
self.builder.get_object('zoomout_button'),
self.builder.get_object('bestfit_button'),
self.builder.get_object('refresh_button')
]
self.connected = False
map(lambda x: x.set_sensitive(False), self.controls)
# workaround bug in gtkcodebuffer
gtkcodebuffer.SYNTAX_PATH.append(
os.path.join(sys.prefix, "local", "share", "pygtkcodebuffer",
"syntax"))
# Configure source viewer
self.buffer = CodeBuffer(lang=SyntaxLoader("python"))
self.buffer.connect("changed", self.text_changed)
tabs = pango.TabArray(1, True)
tabs.set_tab(0, pango.TAB_LEFT, 8 * 4) #seems right
txtview = gtk.TextView(self.buffer)
txtview.set_tabs(tabs)
self.builder.get_object("src_scrolledwindow").add(txtview)
# Configure terminal window
self.terminal_scroll = self.builder.get_object('vte_scrolledwindow')
self.terminal = self.builder.get_object('vte_textview')
self.terminal.modify_base(gtk.STATE_NORMAL,
gtk.gdk.color_parse('black'))
self.terminal.modify_text(gtk.STATE_NORMAL,
gtk.gdk.color_parse('green'))
# get drawingarea
self.pixbuf = None
self.drawingarea = self.builder.get_object("drawingarea")
self.da_menu = self.builder.get_object("da_menu")
# selection coords
self.sel_ended = False
self.selection_started = False
self.x1 = self.y1 = self.x2 = self.y2 = 0
# set control scales attributes
self.builder.get_object("contrast_adjust").attr = openmv.ATTR_CONTRAST
self.builder.get_object(
"brightness_adjust").attr = openmv.ATTR_BRIGHTNESS
self.builder.get_object(
"saturation_adjust").attr = openmv.ATTR_SATURATION
self.builder.get_object(
"gainceiling_adjust").attr = openmv.ATTR_GAINCEILING
#connect signals
signals = {
"on_top_window_destroy": self.quit,
"on_connect_clicked": self.connect_clicked,
"on_reset_clicked": self.reset_clicked,
"on_fwupdate_clicked": self.fwupdate_clicked,
"on_fwpath_clicked": self.fwpath_clicked,
"on_execute_clicked": self.execute_clicked,
"on_stop_clicked": self.stop_clicked,
"on_motion_notify": self.motion_notify,
"on_button_press": self.button_pressed,
"on_button_release": self.button_released,
"on_open_file": self.open_file,
"on_new_file": self.new_file,
"on_save_file": self.save_file,
"on_save_file_as": self.save_file_as,
"on_save_template_activate": self.save_template,
"on_save_descriptor_activate": self.save_descriptor,
"on_ctrl_scale_value_changed": self.on_ctrl_scale_value_changed,
"on_zoomin_clicked": self.zoomin_clicked,
"on_zoomout_clicked": self.zoomout_clicked,
"on_bestfit_clicked": self.bestfit_clicked,
"on_preferences_clicked": self.preferences_clicked,
"on_updatefb_clicked": self.updatefb_clicked,
"on_vte_size_allocate": self.scroll_terminal,
}
self.builder.connect_signals(signals)
# create data directory
if not os.path.isdir(DATA_DIR):
os.makedirs(DATA_DIR)
# create user scripts directory
if not os.path.isdir(SCRIPTS_DIR):
os.makedirs(SCRIPTS_DIR)
# create fresh config if needed
if not os.path.isfile(CONFIG_PATH):
try:
with open(CONFIG_PATH, "w") as f:
f.write(DEFAULT_CONFIG)
except Exception as e:
print("Failed to create config file %s" % (e))
sys.exit(1)
# load config
self.config = configparser.ConfigParser()
try:
self.config.read(CONFIG_PATH)
except Exception as e:
print("Failed to open config file %s" % (e))
sys.exit(1)
# current file path
self.file_path = None
self.fw_file_path = ""
# path = self.config.get("main", "last_opened_file")
# if os.path.isfile(path):
# self._load_file(path)
# built-in examples menu
submenu = gtk.Menu()
menu = self.builder.get_object('example_menu')
files = sorted(os.listdir(EXAMPLES_DIR))
for f in files:
if f.endswith(".py"):
label = os.path.basename(f)
mitem = gtk.MenuItem(label)
mitem.connect("activate", self.open_example, EXAMPLES_DIR)
submenu.append(mitem)
menu.set_submenu(submenu)
# recent files menu
self.files = []
files = self.config.get("main", "recent")
if files:
self.files = files.split(',')
self.update_recent_files()
def setTabSpace(self, spaces, fontDesc=None):
pangoTabSpc = self.getTabPixelWidth(spaces, fontDesc=fontDesc)
tabArray = pango.TabArray(1, True)
tabArray.set_tab(0, pango.TAB_LEFT, pangoTabSpc)
self.set_tabs(tabArray)
return pangoTabSpc
def apply_theme(self):
"""immediately apply the theme given in configuration
this has changed from previous versions! Takes no arguments!
Only uses configuration!"""
# text cursor
gtkrc_string = """\
style "pyroom-colored-cursor" {
GtkTextView::cursor-color = '%s'
bg_pixmap[NORMAL] = "<none>"
}
class "GtkWidget" style "pyroom-colored-cursor"
""" % self.theme['foreground']
gtk.rc_parse_string(gtkrc_string)
padding = int(self.theme['padding'])
self.textbox.set_border_width(padding)
# Screen geometry
screen = gtk.gdk.screen_get_default()
root_window = screen.get_root_window()
mouse_x, mouse_y, mouse_mods = root_window.get_pointer()
current_monitor_number = screen.get_monitor_at_point(mouse_x, mouse_y)
monitor_geometry = screen.get_monitor_geometry(current_monitor_number)
(screen_width, screen_height) = (monitor_geometry.width,
monitor_geometry.height)
width_percentage = float(self.theme['width'])
height_percentage = float(self.theme['height'])
# Sizing
self.vbox.set_size_request(int(width_percentage * screen_width),
int(height_percentage * screen_height))
parse_color = lambda x: gtk.gdk.color_parse(self.theme[x])
# Colors
self.window.modify_bg(gtk.STATE_NORMAL, parse_color('background'))
self.boxout.modify_bg(gtk.STATE_NORMAL, parse_color('border'))
self.status.active_color = self.theme['foreground']
self.status.inactive_color = self.theme['background']
self.textbox.modify_bg(gtk.STATE_NORMAL, parse_color('textboxbg'))
self.textbox.modify_base(gtk.STATE_NORMAL, parse_color('textboxbg'))
self.textbox.modify_base(gtk.STATE_SELECTED, parse_color('foreground'))
self.textbox.modify_text(gtk.STATE_NORMAL, parse_color('foreground'))
self.textbox.modify_text(gtk.STATE_SELECTED, parse_color('textboxbg'))
self.textbox.modify_fg(gtk.STATE_NORMAL, parse_color('foreground'))
# Border
if not int(config.get('visual', 'showborder')):
self.boxin.set_border_width(0)
self.boxout.set_border_width(0)
else:
self.boxin.set_border_width(1)
self.boxout.set_border_width(1)
# Fonts
if config.get('visual', 'use_font_type') == 'custom' or\
not state['gnome_fonts']:
new_font = config.get('visual', 'custom_font')
else:
font_type = config.get('visual', 'use_font_type')
new_font = state['gnome_fonts'][font_type]
self.textbox.modify_font(pango.FontDescription(new_font))
tab_width = pango.TabArray(1, False)
tab_width.set_tab(0, pango.TAB_LEFT,
calculate_real_tab_width(self.textbox, 4))
self.textbox.set_tabs(tab_width)
# Indent
if config.get('visual', 'indent') == '1':
pango_context = self.textbox.get_pango_context()
current_font_size = pango_context.\
get_font_description().\
get_size() / 1024
self.textbox.set_indent(current_font_size * 2)
else:
self.textbox.set_indent(0)
# linespacing
linespacing = config.getint('visual', 'linespacing')
self.textbox.set_pixels_below_lines(linespacing)
self.textbox.set_pixels_above_lines(linespacing)
self.textbox.set_pixels_inside_wrap(linespacing)
# alignment
self.align.set(xalign=0.5,
yalign=ORIENTATION[config.get('visual', 'alignment')],
xscale=0,
yscale=0)
def set_tab_spacing(self, x):
tabs = pango.TabArray(1, True)
tabs.set_tab(0, pango.TAB_LEFT, x)
self._gtk_tag.set_property('tabs', tabs)
def set_dependencies_text(textview, info, dep_info, installed_dep_info,
installed_icon, not_installed_icon):
names = []
states = None
installed_states = []
if dep_info != None and len(dep_info.get(0)) >= 0:
states = dep_info[0]
if installed_dep_info != None and len(installed_dep_info.get(0)) >= 0:
installed_states = installed_dep_info[0]
version_fmt = get_version_fmt_string()
for x in info.dependencies:
if states != None and len(states) > 0:
name = fmri.extract_pkg_name(x)
found = False
for state in states:
if name == state.pkg_stem:
version = version_fmt % \
{"version": state.version,
"build": state.build_release,
"branch": state.branch}
found = True
break
if not found:
version = version_fmt % \
{"version": '0',
"build": '0',
"branch": '0'}
found = False
for state in installed_states:
if name == state.fmri.get_name():
installed_version = version_fmt % \
{"version": state.version,
"build": state.build_release,
"branch": state.branch}
found = True
break
if not found:
installed_version = (_("(not installed)"))
names.append((name, version, installed_version, found))
else:
build_rel = "0"
pkg_fmri = fmri.PkgFmri(x, build_release=build_rel)
branch = pkg_fmri.version.branch
version_stripped = pkg_fmri.get_version().split("-%s" % branch)[0]
version = version_fmt % \
{"version": version_stripped,
"build": build_rel,
"branch": branch}
names.append(
(pkg_fmri.pkg_name, version, _("(not installed)"), False))
depbuffer = textview.get_buffer()
depbuffer.set_text("")
if states == None:
if len(names) == 0:
itr = depbuffer.get_iter_at_line(0)
depbuffer.insert_with_tags_by_name(itr, _("None"), "bold")
else:
for i in range(0, len(names)):
itr = depbuffer.get_iter_at_line(i)
dep_str = "%s\n" % (names[i])
depbuffer.insert(itr, dep_str)
return
style = textview.get_style()
font_size_in_pango_unit = style.font_desc.get_size()
font_size_in_pixel = font_size_in_pango_unit / pango.SCALE
tab_array = pango.TabArray(3, True)
header = [_("Name"), _("Dependency"), _("Installed Version")]
max_len = [0, 0]
for i in range(2):
depbuffer.set_text("")
itr = depbuffer.get_iter_at_line(0)
depbuffer.insert_with_tags_by_name(itr, header[i], "bold")
max_len[i] = get_textview_width(textview)
depbuffer.set_text("")
for one_names in names:
itr = depbuffer.get_iter_at_line(0)
depbuffer.insert(itr, one_names[i])
test_len = get_textview_width(textview)
if test_len > max_len[i]:
max_len[i] = test_len
depbuffer.set_text("")
tab_array.set_tab(1, pango.TAB_LEFT, max_len[0] + font_size_in_pixel)
tab_array.set_tab(2, pango.TAB_LEFT,
max_len[0] + max_len[1] + 2 * font_size_in_pixel)
textview.set_tabs(tab_array)
if len(names) == 0:
depbuffer.set_text("")
itr = depbuffer.get_iter_at_line(0)
depbuffer.insert_with_tags_by_name(itr, _("No dependencies"), "bold")
return
itr = depbuffer.get_iter_at_line(0)
header_text = "%s\t%s\t%s\n" % (header[0], header[1], header[2])
depbuffer.insert_with_tags_by_name(itr, header_text, "bold")
resized_installed_icon = None
resized_not_installed_icon = None
i += 0
for (name, version, installed_version, is_installed) in names:
if is_installed:
if resized_installed_icon == None:
resized_installed_icon = resize_icon(installed_icon,
font_size_in_pixel)
icon = resized_installed_icon
else:
if resized_not_installed_icon == None:
resized_not_installed_icon = resize_icon(
not_installed_icon, font_size_in_pixel)
icon = resized_not_installed_icon
itr = depbuffer.get_iter_at_line(i + 1)
dep_str = "%s\t%s\t" % (name, version)
depbuffer.insert(itr, dep_str)
end_itr = depbuffer.get_end_iter()
depbuffer.insert_pixbuf(end_itr, icon)
depbuffer.insert(end_itr, " %s\n" % installed_version)
i += 1
def setTabSpace(it, spaces, fontDesc=None):
pangoTabSpc = getTxtPixelWidth(it, ' ' * spaces, fontDesc)
tabArray = pango.TabArray(1, True)
tabArray.set_tab(0, pango.TAB_LEFT, pangoTabSpc)
it.set_tabs(tabArray)
return pangoTabSpc
def set_pub_cert_details_text(labs,
text,
textview,
added=False,
reinstated=False):
style = textview.get_style()
font_size_in_pango_unit = style.font_desc.get_size()
font_size_in_pixel = font_size_in_pango_unit / pango.SCALE
tab_array = pango.TabArray(3, True)
infobuffer = textview.get_buffer()
infobuffer.set_text("")
labs_issuer = {}
labs_issuer["common_name_to"] = PUBCERT_COMMON_NAME
labs_issuer["org_to"] = PUBCERT_ORGANIZATION
labs_issuer["org_unit_to"] = PUBCERT_ORGANIZATIONAL_UNIT
max_issuer_len = 0
for lab in labs_issuer:
__add_label_to_generalinfo(infobuffer, 0, labs_issuer[lab])
test_len = get_textview_width(textview)
if test_len > max_issuer_len:
max_issuer_len = test_len
infobuffer.set_text("")
max_finger_len = 0
__add_label_to_generalinfo(infobuffer, 0, labs["fingerprints"])
max_finger_len = get_textview_width(textview)
infobuffer.set_text("")
tab_array.set_tab(0, pango.TAB_LEFT, max_finger_len + font_size_in_pixel)
tab_array.set_tab(1, pango.TAB_LEFT, max_issuer_len + font_size_in_pixel)
textview.set_tabs(tab_array)
infobuffer.set_text("")
i = 0
__add_label_to_generalinfo(infobuffer, i, labs["issued_to"] + '\n')
i += 1
__add_line_to_pub_cert_info(infobuffer, i, labs["common_name_to"],
text["common_name_to"])
i += 1
__add_line_to_pub_cert_info(infobuffer,
i,
labs["org_to"],
text["org_to"],
bold_label=False)
i += 1
__add_line_to_pub_cert_info(infobuffer, i, labs["org_unit_to"],
text["org_unit_to"])
i += 1
__add_label_to_generalinfo(infobuffer, i, labs["issued_by"] + '\n')
i += 1
__add_line_to_pub_cert_info(infobuffer, i, labs["common_name_by"],
text["common_name_by"])
i += 1
__add_line_to_pub_cert_info(infobuffer, i, labs["org_by"], text["org_by"])
i += 1
__add_line_to_pub_cert_info(infobuffer, i, labs["org_unit_by"],
text["org_unit_by"])
i += 1
__add_line_to_pub_cert_info(infobuffer,
i,
labs["validity"],
"",
bold_label=True)
i += 1
__add_line_to_pub_cert_info(infobuffer, i, labs["issued_on"],
text["issued_on"])
i += 1
__add_label_to_generalinfo(infobuffer, i, labs["fingerprints"] + '\n')
i += 1
__add_line_to_pub_cert_info(infobuffer, i, labs["sha1"], text["sha1"])
i += 1
__add_line_to_pub_cert_info(infobuffer, i, labs["md5"], text["md5"])
i += 1
if not added and not reinstated:
__add_line_to_pub_cert_info(infobuffer,
i,
labs["ips"],
text["ips"],
add_return=False)
elif added and not reinstated:
__add_label_to_generalinfo(
infobuffer, i, _("Note: \t Certificate is marked to be added"))
elif not added and reinstated:
__add_label_to_generalinfo(
infobuffer, i,
_("Note: \t Certificate is marked to be reinstated"))
