def __init__(self):
"""
Method to initialize on instance of the Add Control or Action
Assistant.
"""
ramstk.RAMSTKDialog.__init__(
self,
_(u"RAMSTK FMEA/FMECA Design Control and "
u"Action Addition Assistant"))
# Initialize private dictionary attributes.
# Initialize private list attributes.
# Initialize private scalar attributes.
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self.rdoControl = ramstk.RAMSTKOptionButton(None, _(u"Add control"))
self.rdoAction = ramstk.RAMSTKOptionButton(self.rdoControl,
_(u"Add action"))
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #
# Build-up the containers for the dialog. #
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #
_fixed = gtk.Fixed()
self.vbox.pack_start(_fixed)
_label = ramstk.RAMSTKLabel(_(
u"This is the RAMSTK Design Control and Action "
u"Addition Assistant. Enter the information "
u"requested below and then press 'OK' to add "
u"a new design control or action to the RAMSTK "
u"Program database."),
width=600,
height=-1,
wrap=True)
_fixed.put(_label, 5, 10)
_y_pos = _label.size_request()[1] + 50
self.rdoControl.set_tooltip_text(
_(u"Select to add a design control "
u"to the selected failure cause."))
self.rdoAction.set_tooltip_text(
_(u"Select to add an Action to the "
u"selected failure cause."))
_fixed.put(self.rdoControl, 10, _y_pos)
_fixed.put(self.rdoAction, 10, _y_pos + 35)
_fixed.show_all()
def __init__(self, parent_window, less_file):
"""
Public instance variables: tracker, less_file, parent_window, compiler_subprocess
"""
super(Lessie, self).__init__()
self.set_spacing(10)
self.parent_window = parent_window
self.less_file = less_file
self.compiler_subprocess = None
self.__fork_compiler_subprocess()
self.tracker = Tracker.Instance()
fixed = gtk.Fixed()
label = gtk.Label("<b>%s</b>" % less_file.id)
label.set_use_markup(True)
fixed.put(label, 0, 0)
label = gtk.Label(less_file.source)
fixed.put(label, 0, 25)
image = gtk.Image()
image.set_from_file(absolute_path('assets/remove.png'))
image.set_tooltip_text('Remove')
event_box = gtk.EventBox()
event_box.add(image)
#event_box.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.HAND1))
event_box.connect('button_press_event', self.delete_me)
fixed.put(event_box, 364, 0)
hbox = gtk.HBox(False, 0)
hbox.set_spacing(10)
self.__label_destination = gtk.Label(less_file.destination)
hbox.add(self.__label_destination)
image = gtk.Image()
image.set_from_file(absolute_path('assets/refresh.png'))
image.set_tooltip_text('Refresh')
event_box = gtk.EventBox()
event_box.add(image)
event_box.connect('button_press_event', self.force_compilation)
hbox.add(event_box)
image = gtk.Image()
image.set_from_file(absolute_path('assets/change.png'))
image.set_tooltip_text('Change destination')
event_box = gtk.EventBox()
event_box.add(image)
event_box.connect('button_press_event', self.change_destination)
hbox.add(event_box)
fixed.put(hbox, 0, 50)
self.add(fixed)
self.add(gtk.HSeparator())
self.show_all()
def __init__(self):
super(JigsawPuzzleWidget, self).__init__()
self._container = gtk.Fixed()
self.add(self._container)
self.board = JigsawBoard()
self.board.connect('solved', self._solved_cb)
self.board.show()
self._container.put(self.board, 10, 10)
self._container.show_all()
self.running = False
self.forced_location = False
def __init__(self):
"""
Method to initialize on instance of the Add Stress or Test Method
Assistant.
"""
ramstk.RAMSTKDialog.__init__(
self,
_(u"RAMSTK Physics of Failure Analysis Operating Stress and "
u"Test Method Addition Assistant"))
# Initialize private dictionary attributes.
# Initialize private list attributes.
# Initialize private scalar attributes.
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self.rdoStress = ramstk.RAMSTKOptionButton(None, _(u"Add stress"))
self.rdoMethod = ramstk.RAMSTKOptionButton(self.rdoStress,
_(u"Add test method"))
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #
# Build-up the containers for the dialog. #
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #
_fixed = gtk.Fixed()
self.vbox.pack_start(_fixed)
_label = ramstk.RAMSTKLabel(
_(u"This is the RAMSTK Operating Stress and Test Method "
u"Addition Assistant. Enter the information "
u"requested below and then press 'OK' to add "
u"a new design control or action to the RAMSTK "
u"Program database."),
width=600,
height=-1,
wrap=True)
_fixed.put(_label, 5, 10)
_y_pos = _label.size_request()[1] + 50
self.rdoStress.set_tooltip_text(
_(u"Select to add an operating stress to the selected operating "
u"load."))
self.rdoMethod.set_tooltip_text(
_(u"Select to add a test method to the selected operating load."))
_fixed.put(self.rdoStress, 10, _y_pos)
_fixed.put(self.rdoMethod, 10, _y_pos + 35)
_fixed.show_all()
def __init__(self):
super(PyApp, self).__init__()
self.set_title("Dialog Demo")
self.set_default_size(250, 200)
fixed = gtk.Fixed()
btn = gtk.Button("Show")
btn.connect("clicked",self.show_sialog)
fixed.put(btn,100,100)
self.add(fixed)
self.connect("destroy", gtk.main_quit)
self.show_all()
def __init__(self):
self.cellList = {}
super(TInterpreterBoard, self).__init__()
self.f = gtk.Fixed()
self.add(self.f)
self.cellResaltada = None
self._backgroundColor = None
self.barriendo = False
self.velocidadBarrido = 2.0
def __init__(self, title, X, Y, width, height):
id = None
#Initialize the Widget
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.connect("destroy", gtk.main_quit)
self.window.set_title(title)
self.window.set_size_request(width, height)
# Create a Fixed Container
self.fixed = gtk.Fixed()
self.window.add(self.fixed)
self.fixed.show()
def __init__(self):
super(PyApp, self).__init__()
#initializing the window dimensions and title
self.connect("destroy", gtk.main_quit)
self.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(6100, 6400, 6440))
self.set_size_request(330, 330)
self.set_position(gtk.WIN_POS_CENTER)
self.set_title("MAIN WINDOW ")
# defining a CONTAINER on which buttons are placed
fixed = gtk.Fixed()
# defining a button's
btn1 = gtk.Button("PyGtk")
btn2 = gtk.Button("tkinter")
btn3 = gtk.Button("Quit")
btn4 = gtk.Button("List")
btn1.connect("clicked", self.helloworld)
btn2.connect("clicked", self.hello)
btn3.connect("clicked", gtk.main_quit)
btn4.connect("clicked", self.ListHello)
# button position
fixed.put(btn1, 85, 220)
fixed.put(btn4, 165, 220)
fixed.put(btn3, 165, 260)
fixed.put(btn2, 85, 260)
self.set_tooltip_text("MAIN WINDOW")
btn1.set_tooltip_text("Assignment 1")
btn2.set_tooltip_text("Assignment 3")
btn3.set_tooltip_text("Assigment 2")
btn4.set_tooltip_text("for exit click here")
cbtn1 = gtk.CheckButton("CHECK ME 1")
cbtn2 = gtk.CheckButton("CHECK ME 2")
cbtn3 = gtk.CheckButton("CHECK ME 3")
fixed.put(cbtn1, 30, 50)
fixed.put(cbtn2, 30, 100)
fixed.put(cbtn3, 30, 150)
rbtn1 = gtk.RadioButton(None, "Radio One")
rbtn2 = gtk.RadioButton(rbtn1, "Radio Two")
rbtn3 = gtk.RadioButton(rbtn2, "Radio Three")
fixed.put(rbtn1, 150, 50)
fixed.put(rbtn2, 150, 100)
fixed.put(rbtn3, 150, 150)
self.add(fixed)
self.show_all()
def confirmar_tocando(self):
aviso = gtk.Window(gtk.WINDOW_TOPLEVEL)
aviso.set_border_width(10)
aviso.set_title("Aviso")
mensagem = gtk.Label("A música já esta em execução!!")
container = gtk.HBox(False, 0)
aviso.add(container)
fixar = gtk.Fixed()
container.pack_start(fixar)
fixar.show()
container.pack_start(mensagem)
aviso.show_all()
class LoginWindow(gtk.Window):
name_entry = None
password_entry = None
"""docstring for LoginWindow"""
def __init__(self):
super(LoginWindow, self).__init__()
self.set_title("图书管理系统")
self.set_size_request(600, 400)
self.set_position(gtk.WIN_POS_CENTER)
self.set_icon_from_file("web.png")
self.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color('#fff'))
try:
self.library = gtk.gdk.pixbuf_new_from_file("library3.png")
except Exception, e:
print e.message
sys.exit(1)
library_image = gtk.Image()
library_image.set_from_pixbuf(self.library)
library_image.set_size_request(100, 100)
title_label = gtk.Label()
title_label.set_markup('<span size="20000">欢迎使用图书管理系统!</span>')
name_label = gtk.Label("账号")
password_label = gtk.Label("密码")
self.name_entry = gtk.Entry()
self.name_entry.set_size_request(280, 30)
self.password_entry = gtk.Entry()
self.password_entry.set_size_request(280, 30)
self.password_entry.set_visibility(False)
login_button = gtk.Button("登录")
login_button.set_size_request(280, 30)
login_button.connect("clicked", self.on_clicked)
fix = gtk.Fixed()
fix.put(library_image, 250, 20)
fix.put(title_label, 165, 147)
fix.put(name_label, 160, 200)
fix.put(self.name_entry, 160, 220)
fix.put(password_label, 160, 260)
fix.put(self.password_entry, 160, 280)
fix.put(login_button, 160, 340)
self.add(fix)
self.connect("destroy", gtk.main_quit)
self.show_all()
def __init__(self, id, title, width,
height): # Constructor for WindowFrame class
self.window = gtk.Window(
gtk.WINDOW_TOPLEVEL) #assigning a window to WindowFrame
self.window.connect(
"destroy", gtk.main_quit) #adding a destroy event to close button
self.window.set_title(title) #setting title
self.window.set_size_request(width, height) #setting size for window
# Create a Fixed Container
self.fixed = gtk.Fixed() #making a fixed container
self.window.add(self.fixed) #adding container to class
self.fixed.show()
def __init__(self):
self.janela = gtk.Window()
self.janela.set_position(gtk.WIN_POS_CENTER)
self.janela.set_size_request(480, 480)
self.janela.set_title("share - Receber um arquivo")
self.janela.set_resizable(False)
try:
self.janela.set_icon_from_file("icone.png")
except Exception:
self.icone = self.janela.render_icon(gtk.STOCK_MISSING_IMAGE,
gtk.ICON_SIZE_MENU)
self.janela.set_icon(self.icone)
self.label_instrucao = gtk.Label(
"Digite o IP de quem está compartilhando:")
self.label_ip = gtk.Label("Nenhum IP escolhido.")
self.label_instrucao2 = gtk.Label(
"Escolha uma porta entre 1025 e 65535:")
self.label_porta = gtk.Label("Nenhuma porta escolhida.")
self.label_conexao = gtk.Label("")
self.botao_voltar = gtk.Button("<Voltar".center(30))
self.botao_voltar.connect("clicked", self.voltar)
self.texto_ip = gtk.Entry(15)
self.texto_ip.connect("changed", self.escolher_ip)
self.botao_receber = gtk.Button('Receber'.center(50))
self.botao_receber.connect('clicked', self.receber_arquivo)
self.texto_porta = gtk.Entry(5)
self.texto_porta.connect("changed", self.escolher_porta)
self.fixo = gtk.Fixed()
self.fixo.put(self.label_instrucao, 30, 100)
self.fixo.put(self.label_instrucao2, 30, 150)
self.fixo.put(self.label_ip, 30, 200)
self.fixo.put(self.label_porta, 30, 250)
self.fixo.put(self.label_conexao, 30, 350)
self.fixo.put(self.texto_ip, 310, 95)
self.fixo.put(self.texto_porta, 310, 145)
self.fixo.put(self.botao_receber, 120, 300)
self.fixo.put(self.botao_voltar, 310, 420)
self.janela.add(self.fixo)
self.janela.show_all()
self.nome_arquivo = ""
self.ip = ""
self.porta = ""
self.IP_OK = False
def __init__(self):
self.settings_marshaller = settings.SettingsMarshaller()
self.settings = self.settings_marshaller.settings
self.face_recognizer = face_recognizer.FaceRecognizer(self.settings)
self.gtk_window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.gtk_window.connect("destroy", gtk.main_quit)
self.gtk_window.connect("key_press_event", self.on_key_press_event)
self.gtk_window.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(0, 0, 0))
self.gtk_fixed = gtk.Fixed()
self.gtk_window.add(self.gtk_fixed)
if self.settings.default_height is not None and self.settings.default_width is not None:
self.gtk_window.set_default_size(self.settings.default_width, self.settings.default_height)
self.gtk_window.fullscreen()
self.gtk_fixed.show()
self.gtk_window.show()
self.screen_width, self.screen_height = self.gtk_window.get_size()
self.gtk_drawing_area = gtk.DrawingArea()
self.gtk_drawing_area.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(0, 0, 0))
self.gtk_drawing_area.connect("expose_event", self.expose_event)
self.gtk_drawing_area.connect("configure_event", self.configure_event)
self.gtk_drawing_area.set_size_request(self.screen_width, self.screen_height)
self.gtk_pixmap = None
self.gtk_fixed.add(self.gtk_drawing_area)
self.gtk_drawing_area.show()
#self.pixbuf_animation_blue_bird_iter = gtk.gdk.PixbufAnimation('images/bluebird.gif').get_iter()
self.scene = scene.Scene()
self.settings_marshaller.default_if_none('background_image_width', self.screen_width)
self.settings_marshaller.default_if_none('background_image_height', self.screen_height)
self.settings_marshaller.default_if_none('left_pad', 0)
self.settings_marshaller.default_if_none('top_pad', 0)
self.settings_marshaller.default_if_none('showing_background_image', False)
self.settings_marshaller.default_if_none('showing_face_rectangles', False)
self.settings_marshaller.default_if_none('recognition_threshold', 80)
self.settings_marshaller.save()
self.camera = self.get_camera()
self.background_thread = threading.Thread(target=self.background_work)
self.background_thread.daemon = True
self.kill_background = False
self.recognizing_face = False
self.pending_delete_training = False
self.temporary_notice_timer = None
self.temporary_notice = None
def __init__(self, pyroom_config, edit_instance):
self.config = pyroom_config.config # FIXME: use pyroom_config itself
# Theme
theme_name = self.config.get('visual', 'theme')
self.theme = Theme(theme_name)
self.status = FadeLabel()
self.edit_instance = edit_instance
# Main window
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_name('PyRoom')
self.window.set_title("PyRoom")
self.window.connect('delete_event', self.delete_event)
self.window.connect('destroy', self.destroy)
self.textbox = gtk.TextView()
self.textbox.connect('scroll-event', self.scroll_event)
self.textbox.set_wrap_mode(gtk.WRAP_WORD)
self.fixed = gtk.Fixed()
self.vbox = gtk.VBox()
self.window.add(self.fixed)
self.fixed.put(self.vbox, 0, 0)
self.boxout = gtk.EventBox()
self.boxout.set_border_width(1)
self.boxin = gtk.EventBox()
self.boxin.set_border_width(1)
self.vbox.pack_start(self.boxout, True, True, 1)
self.boxout.add(self.boxin)
self.scrolled = gtk.ScrolledWindow()
self.boxin.add(self.scrolled)
self.scrolled.add(self.textbox)
self.scrolled.set_policy(gtk.POLICY_NEVER, gtk.POLICY_NEVER)
self.scrolled.show()
self.scrolled.set_property('resize-mode', gtk.RESIZE_PARENT)
self.textbox.set_property('resize-mode', gtk.RESIZE_PARENT)
self.vbox.set_property('resize-mode', gtk.RESIZE_PARENT)
self.vbox.show_all()
# Status
self.hbox = gtk.HBox()
self.hbox.set_spacing(12)
self.hbox.pack_end(self.status, True, True, 0)
self.vbox.pack_end(self.hbox, False, False, 0)
self.status.set_alignment(0.0, 0.5)
self.status.set_justify(gtk.JUSTIFY_LEFT)
self.apply_theme()
def __init__(frame,
txtLabel,
parentFixed,
lsVal,
x,
y,
row_height,
active=0,
wrap=0,
fontDesc=None):
super(gtk.Frame, frame).__init__(label=txtLabel)
items = len(lsVal)
frame.fixed = gtk.Fixed()
if type(wrap) is not int or (wrap < 0):
wrap = 0
frameW = 5
maxColW = 0
posX = 2
for idx, (radioTxt, radioValue) in enumerate(lsVal):
if idx:
hRadio = gtk.RadioButton(group=hMainRadio, label=radioTxt)
else:
hRadio = hMainRadio = gtk.RadioButton(group=None,
label=radioTxt)
if fontDesc:
hRadio.modify_font(fontDesc)
radioW = getTxtPixelWidth(hRadio, radioTxt, fontDesc=fontDesc) + 20
if wrap:
maxColW = max(maxColW, radioW)
if not (idx % wrap) or (idx == items - 1) and (items % wrap):
frameW += maxColW + 2
if idx and (not (idx % wrap)):
posX += maxColW + 2
maxColW = 0
posY = (idx % wrap) * row_height
if idx == items - 1: frameW += 3
else:
posY = idx * row_height
frameW = max(frameW, radioW)
if idx == items - 1: frameW += 5
hRadio.set_size_request(radioW, row_height - 2)
frame.fixed.put(hRadio, posX, posY)
hRadio.connect("toggled", frame.callBack, radioValue)
frameH = (wrap + 1) * row_height if wrap else (items + 1) * row_height
frame.add(frame.fixed)
frame.set_size_request(frameW, frameH)
parentFixed.put(frame, x, y)
frame.group = tuple(reversed(hMainRadio.get_group()))
if type(active) is not int or (active >= items):
frame.value = None
return
frame.set_active(active)
def __init__(self, label=None, size=None):
super(ImageFrame, self).__init__(label, size, aspect=True)
# Use a fixed widget to display the image.
self.fixed = gtk.Fixed()
self.frame.add(self.fixed)
# Create an image widget.
self.image = gtk.Image()
self.fixed.put(self.image, 0, 0)
# Show all widgets added to this frame
self.frame.show_all()
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(200, 200)
self.set_icon_from_file(ICON_IMAGE)
self.set_geometry_hints(min_width=100, min_height=100)
box = gtk.HBox()
self.add(box)
self.show_all()
self.timer = None
windows = []
window1 = gtk.Window()
window1.set_default_size(200, 200)
window1.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
window1.set_icon_from_file(ICON_IMAGE)
windows.append(window1)
pixbuf = gtk.gdk.pixbuf_new_from_file(ARROWS_IMAGE)
# pixbuf = pixbuf.scale_simple(100, 100, gtk.gdk.INTERP_BILINEAR)
pixmap, mask = pixbuf.render_pixmap_and_mask()
image = gtk.Image()
image.set_from_pixbuf(pixbuf)
del pixbuf
image.show()
fixed = gtk.Fixed()
fixed.put(image, 0, 0)
fixed.show()
window2 = gtk.Window()
window2.set_transient_for(self)
window2.add(fixed)
window2.shape_combine_mask(mask, 0, 0)
try:
window2.shape_combine_mask(mask, 0, 0) # set alpha if necessary
except:
pass
del pixmap
window2.set_decorated(False)
windows.append(window2)
# I need to set this timer once as a delay before querying main windows pos.
self.timer = gobject.timeout_add(500, self.cb, windows)
self.connect("delete_event", self.close, windows)
window1.connect("delete_event", self.close, windows)
def __init__(self):
#janela do aplicativo
win = gtk.Window()
win.set_title("GstPlayer")
win.set_size_request(500, 300)
win.connect("destroy", gtk.main_quit)
container = gtk.HBox(False, 0)
win.add(container)
fixar = gtk.Fixed()
container.pack_start(fixar)
fixar.show()
#botão play:
botao_play = gtk.Button("Play")
fixar.put(botao_play, 50, 100)
container.pack_start(botao_play)
botao_play.connect("clicked", self.tocar)
#botão stop:
botao_stop = gtk.Button("Stop")
fixar.put(botao_stop, 100, 100)
container.pack_start(botao_stop)
botao_stop.connect("clicked", self.parar)
#botão pause:
botao_pause = gtk.Button("Pause")
fixar.put(botao_pause, 150, 100)
container.pack_start(botao_pause)
botao_pause.connect("clicked", self.pausar)
win.show_all()
#montando a paipleline p/ tocar a mp3
self.paipe = gst.Pipeline('paipeline')
self.source = gst.element_factory_make('filesrc', 'source')
self.decoder = gst.element_factory_make('mad', 'decoder')
self.convert = gst.element_factory_make('audioconvert', 'convert')
self.resample = gst.element_factory_make('audioresample', 'resample')
self.sink = gst.element_factory_make('alsasink', 'sink')
self.paipe.add(self.source)
self.paipe.add(self.decoder)
self.paipe.add(self.convert)
self.paipe.add(self.resample)
self.paipe.add(self.sink)
gst.element_link_many(self.source, self.decoder, self.convert,
self.resample, self.sink)
self.paipe.set_state(gst.STATE_READY)
def categories(self, widget):
self.catWindow = gtk.Window()
self.catWindow.set_border_width(1)
self.catWindow.set_default_size(300, 220)
self.catWindow.set_title("Categories")
self.catWindow.set_position(gtk.WIN_POS_CENTER)
catFixed = gtk.Fixed()
self.catWindow.add(catFixed)
# Scrollable treeview for displaying existing profiles
self.catList = gtk.ListStore(str, str)
self.catTreeView = gtk.TreeView(self.catList)
# Item Column
column_cat = gtk.TreeViewColumn()
cell_icon = gtk.CellRendererPixbuf()
cell_icon.set_property('cell-background', 'light blue')
column_cat.pack_start(cell_icon, False)
column_cat.set_attributes(cell_icon, stock_id=0)
cell_cat = gtk.CellRendererText()
cell_cat.set_property('cell-background', 'white')
column_cat.pack_start(cell_cat, True)
column_cat.set_attributes(cell_cat, text=1)
#Set up treeview
self.catTreeView.append_column(column_cat)
self.catTreeView.set_search_column(0)
self.catTreeView.set_size_request(260, 120)
# Embed treeview in scrollable window
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.add(self.catTreeView)
catFixed.put(sw, 15, 20)
for f in self.profile.getCategories():
self.catList.append([gtk.STOCK_FILE, f])
addButton = gtk.Button("Add ")
addButton.connect("clicked", self.add_categories)
catFixed.put(addButton, 45, 180)
removeButton = gtk.Button("Remove")
removeButton.connect("clicked", self.remove_categories)
catFixed.put(removeButton, 115, 180)
doneButton = gtk.Button("Done ")
doneButton.connect("clicked", self.done_categories)
catFixed.put(doneButton, 195, 180)
self.addEntry = gtk.Entry(max=100)
self.addEntry.set_size_request(260, 20)
self.addEntry.connect("activate", self.add_categories)
catFixed.put(self.addEntry, 15, 150)
self.catWindow.show_all()
def __init__(self):
super(PyApp, self).__init__()
self.set_title("Mouse coordinates 0.1")
self.set_size_request(250, 60)
self.set_position(gtk.WIN_POS_CENTER)
self.connect("destroy", self.quit)
label = gtk.Label()
jplabel = gtk.Label()
self.mouseThread = MouseThread(self, label, jplabel)
self.mouseThread.start()
fixed = gtk.Fixed()
fixed.put(label, 10, 10)
# jplabel.set_text('hello world')
jplabel.set_text(str(get_pixel_colour(mouseX, mouseY)))
jptemp = gtk.Fixed()
fixed.put(jplabel, 10, 40)
self.add(fixed)
self.show_all()
def iniciar(self): self.screen_saver = gtk.Window() self.screen_saver.set_position(gtk.WIN_POS_CENTER) self.screen_saver.resize(900, 700) self.screen_saver.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(0,0,0,1)) self.fixed = gtk.Fixed() self.fixed.put(imagen, self.x, self.y) self.screen_saver.add(self.fixed) self.conteo = False gobject.timeout_add(30000, self.mostrar) gobject.timeout_add(100, self.mover_imagen)
def __init__(self, notes_area, fade_in=False):
gtk.DrawingArea.__init__(self)
self.set_size_request(NOTE_WIDTH, NOTE_HEIGHT)
self.text = ''
self.editing = False
self._opacity = 0 if fade_in else 1
pango_context = self.get_pango_context()
self.layout = pango.Layout(pango_context)
self.layout.set_width(LAYOUT_WIDTH * pango.SCALE)
self.layout.set_wrap(pango.WRAP_WORD_CHAR)
self.add_events(gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.BUTTON_RELEASE_MASK
| gtk.gdk.POINTER_MOTION_MASK)
self.connect('expose-event', self._expose_cb)
self.connect('button-press-event', self.edit)
self.fixed = gtk.Fixed()
self.fixed.modify_bg(gtk.STATE_NORMAL, WHITE)
self.fixed.put(self, 0, 0)
self.textview = gtk.TextView()
self.textview.set_left_margin(MARGIN)
self.textview.set_right_margin(MARGIN)
self.textview.set_wrap_mode(gtk.WRAP_WORD_CHAR)
self.textview.set_property('width-request', NOTE_WIDTH)
self.textview.set_property('height-request', NOTE_HEIGHT)
self.textview.connect('key-press-event', self._key_press_event_cb)
stroke, fill = get_colors()
self.textview.modify_base(gtk.STATE_NORMAL,
gtk.gdk.Color(fill[0], fill[1], fill[2]))
self.textview.frame = gtk.Frame()
self.textview.frame.modify_bg(
gtk.STATE_NORMAL, gtk.gdk.Color(stroke[0], stroke[1], stroke[2]))
self.textview.frame.add(self.textview)
self.fixed.put(self.textview.frame, 0, 0)
if fade_in:
gobject.timeout_add(50, self._fade_in_animation)
self._notes_area = notes_area
def save_profile(self, widget=None):
tmp = gtk.Window()
tmp.set_border_width(1)
tmp.set_default_size(200, 100)
tmp.set_title("Saving")
tmp.set_position(gtk.WIN_POS_CENTER)
tmpfixed = gtk.Fixed()
tmp.add(tmpfixed)
tmplabel = gtk.Label("Saving...")
tmpfixed.put(tmplabel, 70, 40)
tmp.show_all()
self.profile.saveProfile()
tmp.destroy()
self.recentSaved = True
def saveAs_confirmButton(self, widget):
try:
# If profile already exists, notify the user and do not overwrite profile
exists = open(self.saveAs_entry.get_text() + ".profile", "r")
exists.close()
self.saveAsExists_window = gtk.Window()
self.saveAsExists_window.set_border_width(1)
self.saveAsExists_window.set_default_size(200, 100)
self.saveAsExists_window.set_title("Save Profile as..")
self.saveAsExists_window.set_position(gtk.WIN_POS_CENTER)
saveAsExists_fixed = gtk.Fixed()
self.saveAsExists_window.add(saveAsExists_fixed)
saveAsExists_button = gtk.Button("Ok")
saveAsExists_button.connect("clicked", self.saveAs_sou, "")
saveAsExists_fixed.put(saveAsExists_button, 90, 50)
saveAsExists_label = gtk.Label("Profile Already Exists!")
saveAsExists_fixed.put(saveAsExists_label, 25, 20)
self.saveAsExists_window.show_all()
except IOError:
# If profile does not exist, then save existing profile as specified name
self.profile.setName(self.saveAs_entry.get_text())
self.save_profile()
self.profile_label.set_label("Profile: " + self.profile.getName())
self.saveAsCreated_window = gtk.Window()
self.saveAsCreated_window.set_border_width(1)
self.saveAsCreated_window.set_default_size(200, 100)
self.saveAsCreated_window.set_title("Save Profile as..")
self.saveAsCreated_window.set_position(gtk.WIN_POS_CENTER)
saveAsCreated_fixed = gtk.Fixed()
self.saveAsCreated_window.add(saveAsCreated_fixed)
saveAsCreated_button = gtk.Button("Ok")
saveAsCreated_button.connect("clicked", self.saveAs_sou,
"SUCCESSFUL")
saveAsCreated_fixed.put(saveAsCreated_button, 90, 50)
saveAsCreated_label = gtk.Label("Profile Saved!")
saveAsCreated_fixed.put(saveAsCreated_label, 50, 20)
self.saveAsCreated_window.show_all()
def __init__(self, titulo, icono, widget, xScreen, yScreen, diccConfig):
self.cantidad = 0
self.x = 10
self.y = 10
self.xScreen = xScreen
self.yScreen = yScreen
""" Calculo cantidad de iconos """
self.sizeIconoX = int(diccConfig["sizeiconox"])
self.sizeIconoY = int(diccConfig["sizeiconoy"])
self.sizeEspaciadoIconosX = int(diccConfig["sizeespaciadoiconosx"])
self.sizeEspaciadoIconosY = int(diccConfig["sizeespaciadoiconosy"])
self.cantidadPorLinea = int(
self.xScreen / (self.sizeIconoX + self.sizeEspaciadoIconosX)) - 1
""" Genero un hbox y le agrego el label """
self.hbox = gtk.HBox(False, 0)
""" Genero el label que sera el nombre del tabs. """
self.label = gtk.Label(titulo)
""" Imagen X para poder luego cerrar es parte del boton """
imagen = gtk.image_new_from_file("/usr/share/interfaz-1.0/" + icono)
""" Creo el boton con el grafico del icono del tabs """
self.boton = gtk.Button()
self.boton.add(imagen)
""" Muestro primero el icono y luego la etiqueta """
self.hbox.pack_start(self.boton, False, False)
self.hbox.pack_start(self.label)
""" Le cambio el estilo al boton para que no tenga
echo un recuadro.
"""
style = gtk.RcStyle()
style.xthickness = 0
style.ythickness = 0
self.boton.modify_style(style)
self.hbox.show_all()
""" Agrego un fixed para luego colocar los datos en el fixed2 donde
pondremos los botones como imagenes
"""
self.fixed = gtk.Fixed()
""" Inserta a la izquierda """
widget.append_page(self.fixed, self.hbox)
""" Creo la imagen del Logo """
self.logoCentrux = gtk.Image()
self.logoCentrux.set_from_file(
"/usr/share/interfaz-1.0/imagenes/centrux.png")
""" Incorporo Imagen Logo """
self.fixed.put(self.logoCentrux, self.xScreen - 500,
self.yScreen - 110)
def __init__(self):
super(App, self).__init__()
self.set_title("Text-Box")
self.set_size_request(350, 200)
self.set_position(gtk.WIN_POS_CENTER)
fixed = gtk.Fixed()
btn = gtk.Button("OK")
btn.set_size_request(80, 40)
entry = gtk.Entry()
entry.set_text("Type anything!")
fixed.put(entry, 100, 80)
fixed.put(btn, 125, 150)
self.connect("destroy", gtk.main_quit)
self.add(fixed)
self.show_all()
def create(self, left_button_list, right_button_list):
''' Creates buttons on the bottom of a window. The buttons can be left
or right, depending on which button list contains the buttons.
left_button_list = [gtk.Button('first'), gtk.Button('second')]
left aligned buttons,
right_button_lit = [gtk.Button('fourth'), gtk.Button('third')]
right aligned buttons. '''
# Bottom buttons
self.widget = gtk.HBox()
fixed_left = gtk.Fixed()
fixed_right = gtk.Fixed()
x_pos = 0
for left_button in left_button_list:
fixed_left.put(left_button, x=x_pos, y=0)
x_pos, y_pos = left_button.size_request()
x_pos += 4
x_pos = 0
for right_button in right_button_list:
fixed_right.put(right_button, x=x_pos, y=0)
x_pos, y_pos = right_button.size_request()
x_pos += 4
self.widget.pack_start(child=fixed_left,
expand=True,
fill=True,
padding=0)
self.widget.pack_start(child=fixed_right,
expand=False,
fill=True,
padding=0)
self.widget.set_border_width(border_width=8)
return self.widget
def __init__(self, cmd=None):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_name("TermRoom")
self.window.set_title("TermRoom")
self.window.connect("destroy", self.destroy)
self.terminal = vte.Terminal()
self.terminal.connect("child-exited", lambda term: gtk.main_quit())
self.terminal.fork_command()
if cmd:
self.terminal.feed_child(cmd + "\n")
self.fixed = gtk.Fixed()
self.window.add(self.fixed)
self.vbox = gtk.VBox()
self.fixed.put(self.vbox, 0, 0)
self.vbox.pack_start(self.terminal, True, True, 6)
self.profile = TerminalProfile()
self.window.modify_bg(
gtk.STATE_NORMAL,
gtk.gdk.color_parse(self.profile["background_color"]))
self.terminal.set_font_from_string(self.profile["font"])
self.terminal.set_allow_bold(self.profile["allow_bold"])
self.terminal.set_audible_bell(not self.profile["silent_bell"])
self.terminal.set_colors(
gtk.gdk.color_parse(self.profile["foreground_color"]),
gtk.gdk.color_parse(self.profile["background_color"]), [
gtk.gdk.color_parse(x)
for x in self.profile["palette"].split(":")
])
self.nmonitors = \
gtk.gdk.display_get_default().get_screen(0).get_n_monitors()
(w, h) = (gtk.gdk.screen_width(), gtk.gdk.screen_height())
if w > h:
w = w / self.nmonitors
width = int(WIDTH_RATIO * w)
height = int(HEIGHT_RATIO * h)
padding_x = int((w - width) / 2)
padding_y = int((h - height) / 2)
self.vbox.set_size_request(width, height)
self.fixed.move(self.vbox, padding_x, padding_y)
self.window.show_all()
self.window.fullscreen()
def _setup_gtk(self):
''' Set up a scrolled window in which to run Turtle Blocks. '''
win = gtk.Window(gtk.WINDOW_TOPLEVEL)
win.set_default_size(self.width, self.height)
win.move(self.x, self.y)
win.maximize()
win.set_title('%s %s' % (self.name, str(self.version)))
if os.path.exists(os.path.join(self._execdirname, self._ICON_SUBPATH)):
win.set_icon_from_file(os.path.join(self._execdirname,
self._ICON_SUBPATH))
win.show()
win.connect('delete_event', self._quit_ta)
''' Create a scrolled window to contain the turtle canvas. We
add a Fixed container in order to position text Entry widgets
on top of string and number blocks.'''
self.fixed = gtk.Fixed()
self.fixed.connect('size-allocate', self._fixed_resize_cb)
width = gtk.gdk.screen_width() - 80
height = gtk.gdk.screen_height() - 80
self.fixed.set_size_request(width, height)
self.vbox = gtk.VBox(False, 0)
self.vbox.show()
self.menu_bar = self._get_menu_bar()
self.vbox.pack_start(self.menu_bar, False, False)
self.menu_bar.show()
self.menu_height = self.menu_bar.size_request()[1]
self.sw = gtk.ScrolledWindow()
self.sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.sw.show()
canvas = gtk.DrawingArea()
width = gtk.gdk.screen_width() * 2
height = gtk.gdk.screen_height() * 2
canvas.set_size_request(width, height)
self.sw.add_with_viewport(canvas)
canvas.show()
self.vbox.pack_end(self.sw, True, True)
self.fixed.put(self.vbox, 0, 0)
self.fixed.show()
win.add(self.fixed)
win.show_all()
self.win = win
self.canvas = canvas
def __init__(self): # It generates the GUI window
super(PyApp, self).__init__()
self.set_title("Target")
self.set_size_request(350, 400)
self.set_position(gtk.WIN_POS_CENTER)
self.wins = gtk.Entry()
self.wins.set_editable(True)
self.wins.set_size_request(200,30)
self.wins2 = gtk.Entry()
self.wins2.set_editable(True)
self.wins2.set_size_request(200,30)
self.wins2.set_text("Source IP (only for Smurf Attack)")
self.wins.set_text("Destination IP")
self.btn1 = gtk.Button("INITIALIZE")
self.btn1.connect("clicked",self.on_clicked1)
self.btn1.set_size_request(200, 40)
self.btn2 = gtk.Button("Snort ON")
self.btn2.connect("clicked",self.on_clicked2)
self.btn2.set_size_request(90, 40)
self.btn3 = gtk.Button("Snort OFF")
self.btn3.connect("clicked",self.on_clicked3)
self.btn3.set_size_request(90, 40)
self.btn5 = gtk.Button("TCP Client")
self.btn5.connect("clicked",self.on_clicked4)
self.btn5.set_size_request(90, 30)
self.btn4 = gtk.Button("Prevent!!!")
self.btn4.connect("clicked",self.on_clicked)
self.btn4.set_size_request(200, 40)
self.rb2=gtk.RadioButton(None,"Syn Flood")
self.rb3=gtk.RadioButton(self.rb2,"PortScan Attack")
self.rb4=gtk.RadioButton(self.rb2,"Worm Attack")
self.rb5=gtk.RadioButton(self.rb2,"Smurf Attack")
fixed = gtk.Fixed()
fixed.put(self.btn1,80,30)
fixed.put(self.btn2,80,90)
fixed.put(self.btn3,180,90)
fixed.put(self.btn5,190,220)
fixed.put(self.btn4,80,280)
fixed.put(self.rb2,80,160)
fixed.put(self.rb3,80,180)
fixed.put(self.rb4,80,220)
fixed.put(self.rb5,80,200)
self.myTerminal = terminal()
self.connect("destroy", gtk.main_quit)
self.set_tooltip_text("Target Window")
self.btn1.set_tooltip_text("Initialize Button")
self.add(fixed)
self.show_all()
