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()