Esempio n. 1
0
    def __init__(self):
        self.readlog = None
        self.keyList = None
        window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        window.set_resizable(True)
        window.set_size_request(1000, 800)
        window.connect("destroy", self.close_application)
        window.set_title("TextView Widget Basic Example")
        window.set_border_width(0)

        box1 = gtk.VBox(False, 0)
        window.add(box1)
        box1.show()

        box2 = gtk.VBox(False, 10)
        box2.set_border_width(10)
        box1.pack_start(box2, True, True, 0)
        box2.show()

        sw = gtk.ScrolledWindow()
        sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        textview = gtk.TextView()
        self.textbuffer = textview.get_buffer()
        sw.add(textview)
        sw.show()
        textview.show()

        box2.pack_start(sw)
        #--- changes

        hbox = gtk.HButtonBox()
        box2.pack_start(hbox, False, False, 0)
        hbox.show()

        vbox = gtk.VBox()
        vbox.show()
        hbox.pack_start(vbox, False, False, 0)
        # check button to toggle editable mode
        check = gtk.CheckButton("Editable")
        vbox.pack_start(check, False, False, 0)
        check.connect("toggled", self.toggle_editable, textview)
        check.set_active(True)
        check.show()
        # check button to toggle cursor visiblity
        check = gtk.CheckButton("Cursor Visible")
        vbox.pack_start(check, False, False, 0)
        check.connect("toggled", self.toggle_cursor_visible, textview)
        check.set_active(True)
        check.show()
        # check button to toggle left margin
        check = gtk.CheckButton("Left Margin")
        vbox.pack_start(check, False, False, 0)
        check.connect("toggled", self.toggle_left_margin, textview)
        check.set_active(False)
        check.show()
        # check button to toggle right margin
        check = gtk.CheckButton("Right Margin")
        vbox.pack_start(check, False, False, 0)
        check.connect("toggled", self.toggle_right_margin, textview)
        check.set_active(False)
        check.show()
        # radio buttons to specify wrap mode
        vbox = gtk.VBox()
        vbox.show()
        hbox.pack_start(vbox, False, False, 0)
        radio = gtk.RadioButton(None, "WRAP__NONE")
        vbox.pack_start(radio, False, True, 0)
        radio.connect("toggled", self.new_wrap_mode, textview, gtk.WRAP_NONE)
        radio.set_active(True)
        radio.show()
        radio = gtk.RadioButton(radio, "WRAP__CHAR")
        vbox.pack_start(radio, False, True, 0)
        radio.connect("toggled", self.new_wrap_mode, textview, gtk.WRAP_CHAR)
        radio.show()
        radio = gtk.RadioButton(radio, "WRAP__WORD")
        vbox.pack_start(radio, False, True, 0)
        radio.connect("toggled", self.new_wrap_mode, textview, gtk.WRAP_WORD)
        radio.show()

        # radio buttons to specify justification
        vbox = gtk.VBox()
        vbox.show()
        hbox.pack_start(vbox, False, False, 0)
        radio = gtk.RadioButton(None, "JUSTIFY__LEFT")
        vbox.pack_start(radio, False, True, 0)
        radio.connect("toggled", self.new_justification, textview,
                      gtk.JUSTIFY_LEFT)
        radio.set_active(True)
        radio.show()
        radio = gtk.RadioButton(radio, "JUSTIFY__RIGHT")
        vbox.pack_start(radio, False, True, 0)
        radio.connect("toggled", self.new_justification, textview,
                      gtk.JUSTIFY_RIGHT)
        radio.show()
        radio = gtk.RadioButton(radio, "JUSTIFY__CENTER")
        vbox.pack_start(radio, False, True, 0)
        radio.connect("toggled", self.new_justification, textview,
                      gtk.JUSTIFY_CENTER)
        radio.show()

        separator = gtk.HSeparator()
        box1.pack_start(separator, False, True, 0)
        separator.show()

        box2 = gtk.VBox(False, 10)
        box2.set_border_width(10)
        box1.pack_start(box2, False, True, 0)
        box2.show()

        button = gtk.Button("close")
        button.connect("clicked", self.close_application)
        box2.pack_start(button, True, True, 0)
        button.set_flags(gtk.CAN_DEFAULT)
        button.grab_default()
        button.show()
        window.show()

        #---------- Logic Buttons ---------
        #--
        label = gtk.Label("Log Path to Process")
        label.set_alignment(0, 0)
        vbox.pack_start(label, True, True, 0)
        label.show()

        self.entry = gtk.Entry()
        self.entry.set_max_length(100)
        self.entry.connect("activate", self.enter_callback, self.entry)
        self.entry.set_text(
            "/var/opt/ORCLemaas/var_opt_ORCLemaas/logs/loganalytics/library/libraryLog.log"
        )
        self.entry.insert_text("", len(self.entry.get_text()))
        self.entry.select_region(0, len(self.entry.get_text()))
        vbox.pack_start(self.entry, True, True, 0)
        self.entry.show()

        buttonlog = gtk.Button("Process log")
        buttonlog.connect("clicked", self.process_log, None)
        vbox.pack_start(buttonlog, True, True, 0)
        #buttonlog.set_flags(gtk.CAN_DEFAULT)
        #buttonlog.grab_default()
        buttonlog.show()
        buttonlog.show()

        buttonlogv = gtk.Button("View log")
        buttonlogv.connect("clicked", self.view_log, None)
        vbox.pack_start(buttonlogv, True, True, 0)
        #buttonlogv.set_flags(gtk.CAN_DEFAULT)
        #buttonlogv.grab_default()
        buttonlogv.show()
        buttonlogv.show()

        #--
        label = gtk.Label("Type of Category")
        label.set_alignment(0, 0)
        vbox.pack_start(label, True, True, 0)
        label.show()

        self.event_type_txt = gtk.Entry()
        self.event_type_txt.set_max_length(100)
        self.event_type_txt.connect("activate", self.enter_callback)
        self.event_type_txt.set_text("2")
        self.event_type_txt.insert_text("",
                                        len(self.event_type_txt.get_text()))
        self.event_type_txt.select_region(0,
                                          len(self.event_type_txt.get_text()))
        vbox.pack_start(self.event_type_txt, True, True, 0)
        self.event_type_txt.show()

        #--
        label = gtk.Label("Number of Lines")
        label.set_alignment(0, 0)
        vbox.pack_start(label, True, True, 0)
        label.show()

        self.num_rows_txt = gtk.Entry()
        self.num_rows_txt.set_max_length(100)
        self.num_rows_txt.connect("activate", self.enter_callback)
        self.num_rows_txt.set_text("4")
        self.num_rows_txt.insert_text("", len(self.num_rows_txt.get_text()))
        self.num_rows_txt.select_region(0, len(self.num_rows_txt.get_text()))
        vbox.pack_start(self.num_rows_txt, True, True, 0)
        self.num_rows_txt.show()

        button = gtk.Button("See latest event")
        button.connect("clicked", self.see_latest_event, None)
        vbox.pack_start(button, True, True, 0)
        #button.set_flags(gtk.CAN_DEFAULT)
        #button.grab_default()
        button.show()
        window.show()

        button2 = gtk.Button("See event one by one")
        button2.connect("clicked", self.see_event_onebyone, None)
        vbox.pack_start(button2, True, True, 0)
        #button2.set_flags(gtk.CAN_DEFAULT)
        #button2.grab_default()
        button2.show()
        window.show()

        # Load the file  into the text window
        #infile = open("textview-basic.py", "r")
        infile = open(self.entry.get_text(), "r")

        if infile:
            string = infile.read()
            infile.close()
            self.textbuffer.set_text(string)
Esempio n. 2
0
    def __init__(self):

        #open the dictionary file
        file = open("pickledatabase.dat", "r")
        self.mldict = pickle.load(file)
        file.close()

        self.window = gtk.Window()
        menubar = gtk.MenuBar()
        menu_file = gtk.Menu()
        menu_help = gtk.Menu()

        item_file = gtk.MenuItem("File")
        item_help = gtk.MenuItem("Help")
        item_quit = gtk.MenuItem("Quit")
        item_about = gtk.MenuItem("About")

        menu_file.append(item_quit)
        menu_help.append(item_about)
        item_file.set_submenu(menu_file)
        item_help.set_submenu(menu_help)
        menubar.append(item_file)
        menubar.append(item_help)

        button = gtk.Button("Look Up")
        self.buffer = gtk.TextBuffer()
        self.entry = gtk.Entry()
        liststore = gtk.ListStore(str)
        textview = gtk.TextView(self.buffer)

        completion = gtk.EntryCompletion()
        self.entry.set_completion(completion)
        completion.set_model(liststore)
        completion.set_text_column(0)

        for item in self.mldict:
            liststore.append([item])

        vbox = gtk.VBox(False, 3)
        hbox = gtk.HBox(False, 3)
        hbox2 = gtk.HBox(False, 3)
        textview.set_editable(False)
        hbox.pack_start(self.entry, True, True, 6)
        hbox.pack_start(button, False, False, 6)
        hbox2.pack_start(textview, True, True, 6)
        vbox.pack_start(menubar, False, False, 0)
        vbox.pack_start(hbox, False, False)
        vbox.pack_start(hbox2, True, True, 6)

        #Event Handlers
        button.connect("clicked", self.FindMeaning1)
        completion.connect("match-selected", self.FindMeaning)
        self.window.connect("destroy", lambda w: gtk.main_quit())
        self.entry.connect("activate", self.FindMeaning1)
        item_quit.connect("activate", lambda w: gtk.main_quit())
        item_about.connect("activate", self.ShowDialog)

        self.window.set_title("Dictionary")
        self.window.set_size_request(400, 520)
        self.window.add(vbox)
        self.window.show_all()
Esempio n. 3
0
    print "Callback", data


def delete_event(widget, event, data=None):
    gtk.main_quit()
    return False


h = gtk.HBox()

b1 = gtk.Button("Button 1")
b1.connect("clicked", callback, "1")

h.add(b1)

for padding in [0, 10]:
    for fill in [True, False]:
        for expand in [True, False]:
            name = "expand %s\nfill %s\npadding %s" % (expand, fill, padding)
            ab = gtk.Button(name)
            ab.connect("clicked", callback, name)
            h.pack_start(ab, expand, fill, padding)

w = gtk.Window()
w.connect("delete_event", delete_event)
w.add(h)
w.set_border_width(10)

w.show_all()
gtk.main()
Esempio n. 4
0
import gtk


def hello_world(widget, data=None):
    print("Hello World")


def delete_event(widget, event, data=None):
    return False


def destroy(widget, data=None):
    gtk.main_quit()


window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.connect("delete_event", delete_event)
window.connect("destroy", destroy)
button = gtk.Button("Hello World")
button.connect("clicked", hello_world, None)

window.add(button)
button.show()
window.show()

try:
    from IPython.lib.inputhook import enable_gui
    enable_gui('gtk')
except ImportError:
    gtk.main()
Esempio n. 5
0
    def __init__(self):
        self.stemmer = Stemmer(sys.argv)
        self.word_count = 0

        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.connect('delete_event', self.delete_event)
        self.window.connect('destroy', self.destroy)
        self.window.set_title('Tamil Stemmer GUI')
        self.window.set_size_request(350, 400)

        self.list = gtk.ListStore(int, str, str, str)

        self.entry = gtk.Entry()
        self.entry.connect('activate', self.add_new_row, self.list)

        self.tvcolumn1 = gtk.TreeViewColumn('No.')
        self.cell1 = gtk.CellRendererText()
        self.tvcolumn1.pack_start(self.cell1, True)
        self.tvcolumn1.add_attribute(self.cell1, 'text', 0)
        self.tvcolumn1.set_resizable(True)

        self.tvcolumn2 = gtk.TreeViewColumn('Word')
        self.cell2 = gtk.CellRendererText()
        self.tvcolumn2.pack_start(self.cell2, True)
        self.tvcolumn2.add_attribute(self.cell2, 'text', 1)
        self.tvcolumn2.set_min_width(175)

        self.tvcolumn3 = gtk.TreeViewColumn('Stemmed word')
        self.cell3 = gtk.CellRendererText()
        self.tvcolumn3.pack_start(self.cell3, True)
        self.tvcolumn3.add_attribute(self.cell3, 'text', 2)

        self.tview = gtk.TreeView(self.list)
        self.tview.append_column(self.tvcolumn1)
        self.tview.append_column(self.tvcolumn2)
        self.tview.append_column(self.tvcolumn3)
        self.tview.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_BOTH)

        self.scrollwindow = gtk.ScrolledWindow()
        self.scrollwindow.set_policy(gtk.POLICY_AUTOMATIC,
                                     gtk.POLICY_AUTOMATIC)
        self.scrollwindow.add(self.tview)

        self.textview = gtk.TextView()
        self.textbuffer = self.textview.get_buffer()
        self.textview.set_editable(False)
        self.textview.set_justification(gtk.JUSTIFY_CENTER)

        self.scrolledwindow2 = gtk.ScrolledWindow()
        self.scrolledwindow2.set_policy(gtk.POLICY_AUTOMATIC,
                                        gtk.POLICY_AUTOMATIC)
        self.scrolledwindow2.add(self.textview)

        self.vbox = gtk.VBox(False, 5)
        self.vbox.pack_start(self.entry, expand=False, fill=False, padding=0)
        self.vbox.pack_start(self.scrollwindow,
                             expand=True,
                             fill=True,
                             padding=0)
        self.vbox.pack_start(self.scrolledwindow2,
                             expand=True,
                             fill=True,
                             padding=0)

        self.window.add(self.vbox)
        self.window.show_all()
    def __init__(self):
        # Create window, set its properties and connect signals
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.connect("delete_event", self.delete_event)
        self.window.connect("destroy", self.destroy)
        self.window.set_title("BlenderTextGenerator")
        self.window.set_border_width(10)

        # Create a hBox which would allow parallel using of settings
        # and openGL view
        self.hBox = gtk.HBox(True, 5)
        self.window.add(self.hBox)

        # Create a vBox to hold all of the settings' controls
        self.vBox = gtk.VBox(True, 5)
        self.hBox.add(self.vBox)

        # Create textbox
        self.textEditFrame = gtk.Frame("Enter Text:")
        self.textEditEntry = gtk.Entry(16)
        self.textEditFrame.add(self.textEditEntry)

        # Create a font selector
        self.fontSelectFrame = gtk.Frame("Select Font:")
        self.fontSelectComboBox = gtk.combo_box_new_text()
        for f in FontFetcher.fetchAllFonts():
            self.fontSelectComboBox.append_text(f)
        self.fontSelectFrame.add(self.fontSelectComboBox)

        # Create a hBox to hold the number settings
        self.numberValuesHBox = gtk.HBox(True, 5)

        # Create an entry for the text height setting
        self.textHeightFrame = gtk.Frame("Height")
        self.textHeightEntry = gtk.Entry(4)
        self.textHeightFrame.add(self.textHeightEntry)

        # Create an entry for the base height setting
        self.baseHeightFrame = gtk.Frame("Base Height")
        self.baseHeightEntry = gtk.Entry(4)
        self.baseHeightFrame.add(self.baseHeightEntry)

        # Create an entry for the base height setting
        self.paddingFrame = gtk.Frame("Padding")
        self.paddingEntry = gtk.Entry(4)
        self.paddingFrame.add(self.paddingEntry)

        # Add all of the number entries to the numberValuesHBox
        self.numberValuesHBox.pack_start(self.textHeightFrame)
        self.numberValuesHBox.add(self.baseHeightFrame)
        self.numberValuesHBox.add(self.paddingFrame)

        # Create a button for creating the model and connect the signal
        self.createButton = gtk.Button("Create")
        self.createButton.connect("clicked", self.createModel)

        # Fill the vBox with the settings
        self.vBox.pack_start(self.textEditFrame)
        self.vBox.add(self.fontSelectFrame)
        self.vBox.add(self.numberValuesHBox)
        self.vBox.add(self.createButton)

        # Show all elements
        self.hBox.show()
        self.vBox.show()
        self.textEditFrame.show()
        self.textEditEntry.show()
        # TODO: self.fontSelectFrame.show()
        self.fontSelectComboBox.show()
        self.numberValuesHBox.show()
        self.textHeightFrame.show()
        self.textHeightEntry.show()
        self.baseHeightFrame.show()
        self.baseHeightEntry.show()
        self.paddingFrame.show()
        self.paddingEntry.show()
        self.createButton.show()
        self.window.show()
Esempio n. 7
0
def get_screen_size():
    """This function finds the width and height of the screen. This will be
    for a single monitor in a multi-monitor set-up.

    Args:
        None

    Returns:
        A list of numbers (width-in-pixels, height-in-pixels)
    """
    backend = plt.get_backend()


    if 'GTK' in backend:
        # Implementation by starfry at
        # https://stackoverflow.com/questions/3129322/how-do-i-get-monitor-resolution-in-python
        import gtk
        window = gtk.Window()
        # the screen contains all monitors
        screen = window.get_screen()
        # collect data about active monitor
        curmon = screen.get_monitor_at_window(screen.get_active_window())
        dx, dy, width, height = screen.get_monitor_geometry(curmon)  # get geometry of current monitor

    elif 'Tk' in backend:
        # Modified version of implementation by FogleBird at
        # https://stackoverflow.com/questions/8762536/how-can-i-choose-the-default-wx-display-in-wxpython
        import wx
        MyApp = wx.App(False)   # the wx.App object must be created first.
        display = wx.Display(0) # find the size of the first display screen
        dx, dy, width, height = display.GetGeometry()

    elif 'MacOSX' in backend:
        # Implementation by Mike Rhodes at
        # https://stackoverflow.com/questions/1281397/how-to-get-the-desktop-resolution-in-mac-via-python
        from Quartz import CGDisplayBounds
        from Quartz import CGMainDisplayID
        from Quartz import CGDisplayScreenSize
        mainMonitor = CGDisplayBounds(CGMainDisplayID())
        width = mainMonitor.size.width
        height = mainMonitor.size.height
        sizeInMm = CGDisplayScreenSize(CGMainDisplayID())
        pixels2inches = width * 25.4 / sizeInMm.width   # 25.4 mm = 1 inch

    elif 'WX' in backend:
        # Implementation by Justin at
        # https://stackoverflow.com/questions/3129322/how-do-i-get-monitor-resolution-in-python
        import ctypes
        user32 = ctypes.windll.user32
        user32.SetProcessDPIAware()
        width = user32.GetSystemMetrics(0)
        height = user32.GetSystemMetrics(1)

    elif 'Qt4' in backend:
        # NOT TESTED YET. Implementation by Harsh Kumar Narula at
        # https://stackoverflow.com/questions/3129322/how-do-i-get-monitor-resolution-in-python
        from PyQt4 import QtGui
        MyApp = QtGui.QApplication(sys.argv)
        screen_resolution = MyApp.desktop().screenGeometry()
        width = screen_resolution.width()
        height = screen_resolution.height()

    elif 'Qt5' in backend:
        # Implementation by Harsh Kumar Narula at
        # https://stackoverflow.com/questions/3129322/how-do-i-get-monitor-resolution-in-python
        from PyQt5 import QtWidgets
        MyApp = QtWidgets.QApplication(sys.argv)
        screen_resolution = MyApp.desktop().screenGeometry()
        width = screen_resolution.width()
        height = screen_resolution.height()

    else:
        print 'Solution not implemented yet for backend =', backend
        width, height = (1280, 1024)

    return (width, height)
Esempio n. 8
0
 def __init__(self):
     window = gtk.Window(gtk.WINDOW_TOPLEVEL)
     window.set_size_request(600, 500)
     window.connect("delete_event", lambda *args: gtk.main_quit())
     window.add(Scene())
     window.show_all()
    def __init__(self):
        gtk.Entry.__init__(self)
        self.news = False
        self.activities = None
        self.external_activities = []  # suggestions from outer space
        self.categories = None
        self.filter = None
        self.max_results = 10  # limit popup size to 10 results
        self.external = external.ActivitiesSource()

        self.popup = gtk.Window(type=gtk.WINDOW_POPUP)

        box = gtk.ScrolledWindow()
        box.set_shadow_type(gtk.SHADOW_IN)
        box.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)

        self.tree = gtk.TreeView()
        self.tree.set_headers_visible(False)
        self.tree.set_hover_selection(True)

        self.time_icon_cell = gtk.CellRendererPixbuf()
        self.time_icon_cell.set_property("icon-name", "appointment-new")

        self.time_icon_column = gtk.TreeViewColumn("", self.time_icon_cell)
        self.tree.append_column(self.time_icon_column)

        self.time_cell = gtk.CellRendererText()
        self.time_cell.set_property("scale", 0.8)

        self.time_column = gtk.TreeViewColumn("Time", self.time_cell, text=3)
        self.tree.append_column(self.time_column)

        self.activity_column = gtk.TreeViewColumn("Activity",
                                                  gtk.CellRendererText(),
                                                  text=1)
        self.activity_column.set_expand(True)
        self.tree.append_column(self.activity_column)

        self.category_cell = gtk.CellRendererText()
        self.category_cell.set_property('alignment', pango.ALIGN_RIGHT)
        self.category_cell.set_property('scale', pango.SCALE_SMALL)
        self.category_cell.set_property('yalign', 0.0)

        self.category_column = gtk.TreeViewColumn("Category",
                                                  self.category_cell,
                                                  text=2)
        self.tree.append_column(self.category_column)

        self.tree.connect("button-press-event",
                          self._on_tree_button_press_event)

        box.add(self.tree)
        self.popup.add(box)

        self.connect("button-press-event", self._on_button_press_event)
        self.connect("key-press-event", self._on_key_press_event)
        self.connect("key-release-event", self._on_key_release_event)
        self.connect("focus-out-event", self._on_focus_out_event)
        self.connect("changed", self._on_text_changed)
        self._parent_click_watcher = None  # bit lame but works

        runtime.storage.connect('activities-changed',
                                self.after_activity_update)

        self.show()
        self.populate_suggestions()
Esempio n. 10
0
    def __init_window(self):       
        # Start pyGTK setup       
        self.window = gtk.Window()        
        self.window.set_title(_("Openbox Logout"))
        
        self.window.connect("destroy", self.quit)
        self.window.connect("key-press-event", self.on_keypress)
        self.window.connect("window-state-event", self.on_window_state_change)
        
        if not self.window.is_composited():
            self.logger.debug("No compositing, enabling rendered effects")
            # Window isn't composited, enable rendered effects
            self.rendered_effects = True
        else:
            # Link in Cairo rendering events
            self.window.connect('expose-event', self.on_expose)
            self.window.connect('screen-changed', self.on_screen_changed)
            self.on_screen_changed(self.window)
            self.rendered_effects = False
        
        self.window.set_size_request(620,200)
        self.window.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("black"))
                   
        self.window.set_decorated(False)
        self.window.set_position(gtk.WIN_POS_CENTER)
        
        # Create the main panel box
        self.mainpanel = gtk.HBox()
        
        # Create the button box
        self.buttonpanel = gtk.HButtonBox()
        self.buttonpanel.set_spacing(10)
        
        # Pack in the button box into the panel box, with two padder boxes
        self.mainpanel.pack_start(gtk.VBox())
        self.mainpanel.pack_start(self.buttonpanel, False, False)
        self.mainpanel.pack_start(gtk.VBox())
                
        # Add the main panel to the window
        self.window.add(self.mainpanel)
         
        for button in self.button_list:
            self.__add_button(button, self.buttonpanel)        
                                          
        if self.rendered_effects == True:    
            self.logger.debug("Stepping though render path")
            w = gtk.gdk.get_default_root_window()
            sz = w.get_size()
            pb = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB,False,8,sz[0],sz[1])
            pb = pb.get_from_drawable(w,w.get_colormap(),0,0,0,0,sz[0],sz[1])

            self.logger.debug("Rendering Fade")
            # Convert Pixbuf to PIL Image
            wh = (pb.get_width(),pb.get_height())
            pilimg = Image.frombytes("RGB", wh, pb.get_pixels())
            
            pilimg = pilimg.point(lambda p: (p * self.opacity) / 255 )

            # "Convert" the PIL to Pixbuf via PixbufLoader
            buf = StringIO.StringIO()
            pilimg.save(buf, "ppm")
            del pilimg
            loader = gtk.gdk.PixbufLoader("pnm")
            loader.write(buf.getvalue())
            pixbuf = loader.get_pixbuf()

            # Cleanup IO
            buf.close()
            loader.close()

            pixmap, mask = pixbuf.render_pixmap_and_mask()
            # width, height = pixmap.get_size()
        else:
            pixmap = None
    
        self.window.set_app_paintable(True)
        self.window.resize(gtk.gdk.screen_width(), gtk.gdk.screen_height())
        self.window.realize()
                
        if pixmap:
            self.window.window.set_back_pixmap(pixmap, False)
        self.window.move(0,0)
Esempio n. 11
0
    def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.set_title("WAVE MIXER")
        self.window.connect("destroy", self.destroy)
        self.window.set_size_request(1000, 800)
        self.fixed = gtk.Fixed()
        self.window.add(self.fixed)
        self.fixed.show()
        self.timerevlist = []
        self.modlist = []
        self.mixlist = []
        self.playing = [-1] * 3
        self.pause = [-1] * 3
        self.processpid = 0
        filelist = [-1] * 3
        self.mixspause = -1
        self.mixspid = -1
        self.modspause = -1
        self.modspid = -1
        for i in range(3):
            checkbutton1 = gtk.CheckButton("Time Reversal")
            checkbutton2 = gtk.CheckButton("Select for Modulation")
            checkbutton3 = gtk.CheckButton("Select for Mix")
            self.fixed.put(checkbutton1, 100 + 250 * i, 330)
            self.fixed.put(checkbutton2, 100 + 250 * i, 360)
            self.fixed.put(checkbutton3, 100 + 250 * i, 390)
            self.timerevlist.append(checkbutton1)
            self.modlist.append(checkbutton2)
            self.mixlist.append(checkbutton3)
    #scale for amplitude
        self.amplist = []
        for i in range(3):
            scale = gtk.HScale()
            scale.set_range(0, 10)
            scale.set_value(1)
            scale.set_increments(0.5, 1)
            scale.set_digits(1)
            scale.set_size_request(160, 45)
            self.fixed.put(scale, 100 + i * 250, 130)
            self.amplist.append(scale)
    #scale for time Shift
        self.timeshiftlist = []
        for i in range(3):
            scale = gtk.HScale()
            scale.set_range(-30, 30)
            scale.set_increments(1, 1)
            scale.set_digits(0)
            scale.set_size_request(160, 45)
            self.fixed.put(scale, 100 + i * 250, 200)
            self.timeshiftlist.append(scale)

    #scale for tCONTscaling
        self.timescalelist = []
        for i in range(3):
            scale = gtk.HScale()
            scale.set_range(0.125, 10)
            scale.set_value(1)
            scale.set_increments(0.125, 0.125)
            scale.set_digits(3)
            scale.set_size_request(160, 45)
            self.fixed.put(scale, 100 + i * 250, 270)
            self.timescalelist.append(scale)
        #filechooser
        self.filechooser = []
        for i in range(3):
            filechooserbutton = gtk.FileChooserButton("Select A File", None)
            filechooserbutton.connect("file-set", self.file_selected, i)
            filechooserbutton.set_width_chars(10)
            self.fixed.put(filechooserbutton, 100 + 250 * i, 50)
            self.filechooser.append(filechooserbutton)

        for i in range(3):
            label = gtk.Label("Select File")
            self.fixed.put(label, 120 + i * 250, 30)
        for i in range(3):
            label = gtk.Label("Amplitude:")
            self.fixed.put(label, 100 + i * 250, 110)
        for i in range(3):
            label = gtk.Label("Time Shift:")
            self.fixed.put(label, 100 + i * 250, 180)
        for i in range(3):
            label = gtk.Label("Time Scaling:")
            self.fixed.put(label, 100 + i * 250, 250)
        self.button = []
        for i in range(3):
            but = gtk.Button("Start")
            but1 = gtk.Button("Play/Pause")
            but2 = gtk.Button("Stop")
            self.button.append(but)
            self.fixed.put(but, 100 + i * 250, 500)
            self.fixed.put(but2, 240 + i * 250, 500)
            self.fixed.put(but1, 150 + i * 250, 500)
            but.connect("clicked", self.callback, i)
            but2.connect("clicked", self.stopback, i)
            but1.connect("clicked", self.pauseback, i)
        but = gtk.Button("Mix and Play")

        but3 = gtk.Button("Stop Mix")
        but2 = gtk.Button("Stop Modulation")
        but1 = gtk.Button("Modulate and Play")
        but.connect("clicked", self.mixback)
        but1.connect("clicked", self.modback)
        but2.connect("clicked", self.modstop)
        but3.connect("clicked", self.mixstop)
        self.fixed.put(but, 100, 600 - 50)
        self.fixed.put(but3, 100, 600 - 20)
        self.fixed.put(but1, 200, 600 - 50)
        self.fixed.put(but2, 200, 600 - 20)
        recordbut = gtk.Button("Record")
        recordbut.connect("clicked", self.recordstart)
        self.fixed.put(recordbut, 400, 550)
        #recordbut=gtk.Button("Play")
        #recordbut.connect("clicked",self.recordplay)
        self.recordingplay = -1
        self.recordpid = -1
        #self.fixed.put(recordbut,480,550)
        self.window.show_all()
Esempio n. 12
0
def main():
    # window
    window = gtk.Window()
    window.resize(400, 400)  # TODO this resizes the surface and view?
    window.move(400, 600)
    window.connect('destroy', gtk.main_quit)
    window.realize()

    da = gtk.DrawingArea()
    '''
  This must precede realization of view? or use add_events().
  First three are mouse events.
  STRUCTURE is configure-event (resizing the window)
  Last are focus and keyboard events.
  '''
    da.set_events( \
      gdk.BUTTON_PRESS_MASK \
      | gdk.POINTER_MOTION_MASK \
      | gdk.BUTTON_RELEASE_MASK \
      | gdk.STRUCTURE_MASK \
      | gdk.FOCUS_CHANGE_MASK\
      | gdk.KEY_RELEASE_MASK \
      | gdk.KEY_PRESS_MASK )
    '''
  Enable drawing area widget to receive keyboard events: focus_in, key_release, etc.
  We implement our own widgets (controls) including text controls that receive keyboard.
  Also, we implement our own *traversal* (via the tab key per convention)
  among our controls that get the keyboard focus.
  '''
    da.set_flags(da.flags() | gtk.CAN_FOCUS)

    window.add(da)

    # Can draw to several ports.
    a_view = port.ViewPort(da)
    a_printerport = port.PrinterPort()
    a_fileport = port.FilePort()

    # global singletons
    config.viewport = a_view
    config.scheme = scheme.Scheme()

    window.show_all()  # Show now so allocation becomes valid

    gui.manager.control.control_manager = gui.manager.control.ControlsManager(
    )  # Enforces one control active
    controlinstances.build_all(a_printerport,
                               a_fileport)  # build singleton controls
    gui.manager.control.control_manager.set_root_control(
        controlinstances.bkgd_control)

    # Initial active control is the background manager. Controlee is the bkgd_control itself.
    gui.manager.control.control_manager.activate_control(
        controlinstances.bkgd_control, controlinstances.bkgd_control)

    a_view.set_model(config.scheme.model)
    a_printerport.set_model(config.scheme.model)
    a_fileport.set_model(config.scheme.model)

    make_test_doc()

    gtk.main()
Esempio n. 13
0
lines = commands.getoutput("wmctrl -l").split("\n")
windows = []
for line in lines:
    line = line.replace("  ", " ")
    win = tuple(line.split(" ", 3))
    windows.append(win)

isPopulated = dict()
for desktop in desktops:
    isPopulated[desktop[0]] = False
    for win in windows:
        if win[1] == desktop[0]:
            isPopulated[desktop[0]] = True

tabWin = gtk.Window()
tabWin.set_decorated(False)
tabWin.set_skip_taskbar_hint(True)
tabWin.set_skip_pager_hint(True)

cols = 0
for desktop in isPopulated:
    if isPopulated[desktop] == True:
        cols = cols + 1
    else:
        desktops.remove(desktops[int(desktop)])

buttons = []
table = gtk.Table(3, cols, False)
table.set_col_spacings(10)
windowName = gtk.Label(windows[0][3])
Esempio n. 14
0
    def main(self):
        #print "------------------Main-------------------------"
        accel_group = gtk.AccelGroup()
        # Main Window
        main_window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        main_window.set_resizable(False)
        main_window.set_title("GTK Tetris")
        main_window.connect("key-press-event", self.keyboard_event_handler)
        main_window.connect("destroy", gtk.main_quit)
        
        # vertical box
        v_box = gtk.VBox(False, 0)
        main_window.add(v_box)
        v_box.show()
        
        # menu stuff
        menu_bar = gtk.MenuBar()
        menu_bar.show()
        v_box.pack_start(menu_bar, False, False, 0)
        
        # Game sub-menu
        menu_game = gtk.MenuItem("_Game", True)
        menu_game.show()
        menu_bar.add(menu_game)
        
        menu_game_menu = gtk.Menu()
        menu_game.set_submenu(menu_game_menu)
        
        self.menu_game_quick = gtk.MenuItem("Start Game", True)
        self.menu_game_quick.show()
        menu_game_menu.add(self.menu_game_quick)
        self.menu_game_quick.connect("activate", self.game_start_stop)
        self.menu_game_quick.add_accelerator("activate", accel_group,
                                        ord('G'), gtk.gdk.CONTROL_MASK,
                                        gtk.ACCEL_VISIBLE)

        self.menu_game_stop = gtk.MenuItem("Stop Game", True)
        self.menu_game_stop.show()
        menu_game_menu.add(self.menu_game_stop)
        self.menu_game_stop.connect("activate", self.game_start_stop)
        self.menu_game_stop.add_accelerator("activate", accel_group,
                                        ord('O'), gtk.gdk.CONTROL_MASK,
                                        gtk.ACCEL_VISIBLE)
        self.menu_game_stop.set_sensitive(False)

        self.menu_game_pause = gtk.CheckMenuItem("Pause", True)
        self.menu_game_pause.show()
        menu_game_menu.add(self.menu_game_pause)
        self.menu_game_pause.connect("activate", self.game_set_pause)
        self.menu_game_pause.add_accelerator("activate", accel_group,
                                        ord('P'), gtk.gdk.CONTROL_MASK,
                                        gtk.ACCEL_VISIBLE)

        separatormenuitem1 = gtk.MenuItem()
        separatormenuitem1.show()
        menu_game_menu.add(separatormenuitem1)
        separatormenuitem1.set_sensitive(False)
        
        self.menu_game_quit = gtk.MenuItem("Quit", True)
        self.menu_game_quit.show()
        menu_game_menu.add(self.menu_game_quit)
        self.menu_game_quit.connect("activate", gtk.main_quit)
        self.menu_game_quit.add_accelerator("activate", accel_group,
                                        ord('X'), gtk.gdk.CONTROL_MASK,
                                        gtk.ACCEL_VISIBLE)        
        
        # Settings sub-menu
        menu_settings = gtk.MenuItem("_Settings", True)
        menu_settings.show()
        menu_bar.add(menu_settings)
        
        menu_settings_menu = gtk.Menu()
        menu_settings.set_submenu(menu_settings_menu)
        
        self.menu_game_start = gtk.MenuItem("Level Settings", True)
        self.menu_game_start.show()
        menu_settings_menu.add(self.menu_game_start)
        self.menu_game_start.connect("activate", self.show_new_game)

        self.menu_game_show_next_block = gtk.CheckMenuItem("Show next block", True)
        self.menu_game_show_next_block.show()
        menu_settings_menu.add(self.menu_game_show_next_block)
        self.menu_game_show_next_block.connect("activate", self.game_show_next_block)
        if common.options["shw_nxt"]:
            self.menu_game_show_next_block.set_active(True)
        self.menu_game_show_next_block.add_accelerator("activate", accel_group,
                                        ord('N'), gtk.gdk.CONTROL_MASK,
                                        gtk.ACCEL_VISIBLE)        

        separator1 = gtk.MenuItem()
        separator1.show()
        menu_settings_menu.add(separator1)
        separator1.set_sensitive(False)
        
        self.menu_save_options = gtk.MenuItem("Save Settings", True)
        self.menu_save_options.show()
        menu_settings_menu.add(self.menu_save_options)
        self.menu_save_options.connect("activate", self.save_options)

        # Help sub-menu
        menu_help = gtk.MenuItem("_Help", True)
        menu_help.show()
        menu_bar.add(menu_help)
        menu_help.set_right_justified(True)
        
        menu_help_menu = gtk.Menu()
        menu_help.set_submenu(menu_help_menu)
        
        help1 = gtk.MenuItem("Help", True)
        help1.show()
        menu_help_menu.add(help1)
        help1.connect("activate", self.show_help)
        # How to set F1 shortcut????????????????????????//
        help1.add_accelerator("activate", accel_group,
                                ord('H'), gtk.gdk.CONTROL_MASK,
                                gtk.ACCEL_VISIBLE)

        high_scores1 = gtk.MenuItem("High-scores", True)
        high_scores1.show()
        menu_help_menu.add(high_scores1)
        high_scores1.connect("activate", self.show_highscore_wrapper)

        separator2 = gtk.MenuItem()
        separator2.show()
        menu_help_menu.add(separator2)
        separator2.set_sensitive(False)
        
        about1 = gtk.MenuItem("About", True)
        about1.show()
        menu_help_menu.add(about1)
        about1.connect("activate", self.show_about)
        
        # horizontal box
        h_box = gtk.HBox(False, 1)
        h_box.show()
        v_box.pack_start(h_box, False, False, 0)
        
        # game_border
        game_border = gtk.Frame()
        game_border.set_shadow_type(gtk.SHADOW_IN)
        h_box.pack_start(game_border, False, False, 1)
        game_border.show()
        
        # Global game_area
        common.game_area = gtk.DrawingArea()
        common.game_area.show()
        common.game_area.set_size_request(common.MAX_X*common.BLOCK_WIDTH,
                                          common.MAX_Y*common.BLOCK_HEIGHT)
        common.game_area.connect("expose_event", self.game_area_expose_event)
        common.game_area.set_events(gtk.gdk.EXPOSURE_MASK)
        game_border.add(common.game_area)
        
        # right side
        right_side = gtk.VBox(False, 0)
        h_box.pack_start(right_side, False, False, 0)
        right_side.show()
        
        # next_block_border
        next_block_border = gtk.Frame()
        next_block_border.set_shadow_type(gtk.SHADOW_IN)
        right_side.pack_start(next_block_border, False, False, 0)
        next_block_border.show()
        # Global next block area
        common.next_block_area = gtk.DrawingArea()
        common.next_block_area.show()
        common.next_block_area.set_size_request(4*common.BLOCK_WIDTH,
                                                4*common.BLOCK_HEIGHT)
        common.next_block_area.connect("expose_event", self.next_block_area_expose_event)
        common.next_block_area.set_events(gtk.gdk.EXPOSURE_MASK)
        next_block_border.add(common.next_block_area) 
        
        # the score, level, lines
        self.score_label1 = gtk.Label("Score:")
        self.score_label1.set_justify(gtk.JUSTIFY_RIGHT)
        self.score_label1.show()
        right_side.pack_start(self.score_label1, False, False, 3)
        
        self.score_label2 = gtk.Label("0")
        self.set_gtk_color_style(self.score_label2, 0xffff, 0, 0)
        self.score_label2.set_justify(gtk.JUSTIFY_RIGHT)
        self.score_label2.show()
        right_side.pack_start(self.score_label2, False, False, 3)
        
        self.level_label1 = gtk.Label("Level:")
        self.level_label1.set_justify(gtk.JUSTIFY_RIGHT)
        self.level_label1.show()
        right_side.pack_start(self.level_label1, False, False, 3)
        
        dummy = str(common.current_level)
        
        self.level_label2 = gtk.Label(dummy)
          # ???????????????????????????????????????????????????
        self.set_gtk_color_style(self.level_label2, 0,0,0)
          #??????????????????????????????????????????
        self.level_label2.set_justify(gtk.JUSTIFY_RIGHT)
        self.level_label2.show()
        right_side.pack_start(self.level_label2, False, False, 3)

        self.line_label1 = gtk.Label("Lines:")
        self.line_label1.set_justify(gtk.JUSTIFY_RIGHT)
        self.line_label1.show()
        right_side.pack_start(self.line_label1, False, False, 3)
        
        self.line_label2 = gtk.Label("0")
        self.line_label2.set_justify(gtk.JUSTIFY_RIGHT)
        self.line_label2.show()
        right_side.pack_start(self.line_label2, False, False, 3)
        
        # the game buttons
        
        # Start_stop
        self.Start_stop_button = gtk.Button()
        self.Start_stop_button.show()
        self.Start_stop_button.connect("clicked", self.game_start_stop)
        self.Start_stop_button_label = gtk.Label(self.start_stop_str[0])
        box2 = self.label_box(right_side, self.Start_stop_button_label,
                              self.start_stop_str[0])
        box2.show()
        self.Start_stop_button.add(box2)
        right_side.pack_start(self.Start_stop_button, False, False, 3)
        self.Start_stop_button.set_flags(gtk.CAN_DEFAULT)
        self.Start_stop_button.grab_default()
        
        # Pause
        self.Pause_button = gtk.Button()
        self.Pause_button.show()
        self.Pause_button.connect("clicked", self.game_set_pause_b)
        self.Pause_button_label = gtk.Label(self.pause_str[0])
        box1 = self.label_box(right_side, self.Pause_button_label, 
                              self.pause_str[0])
        box1.show()
        self.Pause_button.add(box1)
        right_side.pack_start(self.Pause_button, False, False, 3)
        self.Pause_button.set_flags(gtk.CAN_DEFAULT)
        self.Pause_button.set_sensitive(False)
        
        main_window.add_accel_group(accel_group)
        main_window.show()
        
        # Block pixmap
        common.blocks_pixmap,mask = gtk.gdk.pixmap_create_from_xpm_d(common.game_area.window,
                                                                     None, common.blocks_xpm)
        
        gtk.main()
Esempio n. 15
0
    def __init__(self):

        #        #################################################################################################################################
        #        # Load and apply gtkrc
        #        #################################################################
        #        # No exception control because rc_parse doesn't throw exception on fail... sad but true ;)
        #        ORIGDIR = os.getcwd()
        #        os.chdir('lib/ui/data/Brave/gtk-2.0/')
        #        gtk.rc_parse('gtkrc')
        #        os.chdir(ORIGDIR)

        # Load Output Manager
        self.gom = om.OutputManager('gui')

        #################################################################################################################################
        # Create a new window
        #################################################################
        splash.push(("Creatin main window..."))
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.set_focus = True
        self.window.connect("destroy", lambda w: gtk.main_quit())
        self.window.connect("delete_event", self.quit)
        splash.push(("Loading..."))
        gtk.settings_get_default().set_long_property("gtk-button-images", True,
                                                     "main")

        # Title
        self.window.set_title(MAINTITLE)

        # Positions
        self.window.resize(800, 600)
        self.window.move(25, 25)
        # Maximize window
        self.window.maximize()

        #################################################################################################################################
        # Load core...
        #################################################################
        #Initialize KB
        splash.push(("Loading KB..."))
        self.uicore = core.UIcore()
        self.uicore.add_local_asn()
        self.uicore.set_om(self.gom)
        self.gom.set_core(self.uicore)

        #################################################################################################################################
        # Main VBox
        #################################################################
        mainvbox = gtk.VBox(False, 1)
        mainvbox.set_border_width(1)
        self.window.add(mainvbox)
        mainvbox.show()

        #################################################################################################################################
        # Tool Bars HBox
        #################################################################
        tbhbox = gtk.HBox(False, 1)
        mainvbox.pack_start(tbhbox, False, False, 1)
        tbhbox.show()

        #################################################################################################################################
        # UIManager for MAP Toolbar
        #################################################################
        # to make it nice we'll put the toolbar into the handle box,
        # so that it can be detached from the main window
        self.handlebox = gtk.HandleBox()
        tbhbox.pack_start(self.handlebox, True, True, 1)

        # Create a UIManager instance
        splash.push(("Creating menu and toolbar..."))
        uimanager = gtk.UIManager()
        accelgroup = uimanager.get_accel_group()
        self.window.add_accel_group(accelgroup)
        self._actiongroup = actiongroup = gtk.ActionGroup('UIManager')

        # Create actions
        actiongroup.add_actions([
            # xml_name, icon, real_menu_text, accelerator, tooltip, callback
            ('Load', gtk.STOCK_OPEN, ('Load'), None, (''), self.loadKB),
            ('Save', gtk.STOCK_SAVE, ('Save'), None, (''), self.saveKB),
            ('Import', gtk.STOCK_CONVERT, ('Import'), None, (''),
             self.importScan),
            ('Edit', gtk.STOCK_EDIT, ('Edit'), None, (''), self.loadEditor),
            ('Proxy', gtk.STOCK_CONNECT, ('Proxy'), None, (''), gtk.main_quit),
            ('Web Server', gtk.STOCK_EXECUTE, ('Web'), None, ('Web'),
             gtk.main_quit),

            #('Sniffer', gtk.STOCK_NETWORK, ('Sniffer'), None, (''), gtk.main_quit),
            ('Sniffer', gtk.STOCK_NETWORK, ('Sniffer'), None, (''),
             self.run_sniffer),
            ('Scapy', gtk.STOCK_HELP, ('Scapy'), None, (''), self.show_term),
            ('Add Target', gtk.STOCK_ADD, ('Add Target'), None, (''),
             self.addTarget),
            ('Preferences', gtk.STOCK_PREFERENCES, ('Preferences'), None, (''),
             self.showPref),
            ('Show Log', gtk.STOCK_DND, ('Show Log'), None, (''),
             self.show_log),
            ('Show KB', gtk.STOCK_DND, ('Show KB'), None, (''), self.show_kb),
            ('Report', gtk.STOCK_DND, ('Report'), None, (''), self.report),
            ('Quit', gtk.STOCK_QUIT, ('Quit'), None, (''), gtk.main_quit),
        ])

        # Add the actiongroup to the uimanager
        uimanager.insert_action_group(actiongroup, 0)
        uimanager.add_ui_from_string(ui_menu)

        # Toolbar
        toolbar = uimanager.get_widget('/Toolbar')
        toolbar.set_style(gtk.TOOLBAR_BOTH)

        # Disabled until I get them working
        button_proxy = uimanager.get_widget('/Toolbar/Proxy')
        button_proxy.set_sensitive(False)
        button_web = uimanager.get_widget('/Toolbar/Web Server')
        button_web.set_sensitive(False)

        # Disable if not GtkSourceView2
        if not config.HAS_SOURCEVIEW:
            button_edit = uimanager.get_widget('/Toolbar/Edit')
            button_edit.set_sensitive(False)

        # Disable if not Vte
        if not config.HAS_VTE:
            button_sniffer = uimanager.get_widget('/Toolbar/Sniffer')
            button_sniffer.set_sensitive(False)
            button_scapy = uimanager.get_widget('/Toolbar/Scapy')
            button_scapy.set_sensitive(False)

        self.handlebox.add(toolbar)
        toolbar.show()
        self.handlebox.show()

        #################################################################################################################################
        # Map tab
        #################################################################
        # Will contain on top the notebook and on bottom log window
        self.vpaned = gtk.VPaned()
        # Will contain xdot widget and kb window
        self.hpaned = gtk.HPaned()

        #################################################################
        # KB Textview
        #################################################################
        self.textview = kbwin.KBwindow()
        #self.gom.set_kbwin(self.textview)

        #################################################################
        # KB TreeView
        #################################################################
        self.treeview = kbtree.KBtree()
        self.tree = self.treeview.createTree()
        self.treeview.updateTree()
        self.gom.set_kbwin(self.treeview)
        self.tree.show()

        #################################################################
        # xdot map
        #################################################################
        from . import inxdot

        #        self.context = cmenu.contextMenu()
        #        self.context.createMenus(self.textview, self.gom)
        #
        #        self.xdotw = inxdot.MyDotWidget(self.context, self.uicore)

        # nodeMenu initialization stuff
        self.uiman = nodeMenu.UIManager(self.gom, self.uicore, config)
        self.uiman.set_data(None)
        accel = self.uiman.get_accel_group()
        self.window.add_accel_group(accel)

        # graphMenu initialization stuff
        self.graph_uiman = graphMenu.UIManager(self.gom, self.uicore)
        #self.graph_uiman.set_data(None)
        graph_accel = self.graph_uiman.get_accel_group()
        self.window.add_accel_group(graph_accel)

        self.xdotw = inxdot.MyDotWidget(self.uiman, self.graph_uiman,
                                        self.uicore)
        setattr(self.graph_uiman, 'xdot', self.xdotw)

        self.xdotw.set_size_request(900, 450)
        self.gom.set_map(self.xdotw)
        setattr(self.uicore, 'xdot', self.xdotw)
        self.uicore.getDot(doASN=True)

        self.xdotw.set_dotcode(self.uicore.get_kbfield('dotcode'))
        self.xdotw.zoom_image(1.0)

        #################################################################
        # Graph Menu
        #################################################################
        gmenu = graphTBar.GraphMenu(self.xdotw, self.uicore)
        #################################################################
        # HBox for Map and GraphMenu
        #################################################################
        menubox = gtk.HBox()
        menubox.pack_start(self.xdotw, True, True)
        menubox.pack_start(gmenu, False, False)
        # Show elements
        gmenu.show()
        menubox.show()

        #################################################################
        # Scrolled Window
        #################################################################
        self.scrolled_window = gtk.ScrolledWindow()
        self.scrolled_window.set_policy(gtk.POLICY_AUTOMATIC,
                                        gtk.POLICY_AUTOMATIC)
        self.scrolled_window.set_size_request(100, 100)

        # Add Textview to Scrolled Window
        #self.scrolled_window.add_with_viewport(self.textview)
        self.scrolled_window.add_with_viewport(self.tree)

        #################################################################
        # Map Iface
        #################################################################
        bufferf = "Map"
        frame = gtk.Frame(bufferf)
        frame.set_border_width(5)
        frame.show()
        label = gtk.Label('Map')

        # Test XDOT MAP
        frame.add(self.hpaned)
        #self.hpaned.add1(self.xdotw)
        self.hpaned.add1(menubox)
        self.hpaned.add2(self.scrolled_window)
        self.textview.show()

        # Check visibility on config preferences
        if config.SHOW_KBTREE:
            self.scrolled_window.show()
            self.scrolled_window.is_visible = True
        else:
            self.scrolled_window.is_visible = False

        self.hpaned.show()
        self.xdotw.show()

        label = gtk.Label('Map')
        label.set_angle(90)
        b_factory = gtk.VBox
        b = b_factory(spacing=1)
        i = gtk.Image()
        i.set_from_stock(gtk.STOCK_NETWORK, gtk.ICON_SIZE_SMALL_TOOLBAR)
        b.pack_start(label)
        b.pack_start(i)
        b.show_all()

        #################################################################
        # Notebook
        #################################################################
        self.notebook = gtk.Notebook()
        self.notebook.set_tab_pos(gtk.POS_LEFT)
        #notebook.append_page(frame, label)
        self.notebook.append_page(frame, b)
        self.notebook.connect("switch_page", self.onSwitch)

        #################################################################################################################################
        # Consoles Tab
        #################################################################
        label = gtk.Label('Term')
        label.set_angle(90)
        b_factory = gtk.VBox
        b = b_factory(spacing=1)
        i = gtk.Image()
        i.set_from_stock(gtk.STOCK_EXECUTE, gtk.ICON_SIZE_SMALL_TOOLBAR)
        b.pack_start(label)
        b.pack_start(i)
        b.show_all()

        term_box = gtk.VBox()
        term_button = gtk.Button("New Tab")
        # Disable if VTE not available
        if not config.HAS_VTE:
            term_button.set_sensitive(False)
        term_box.pack_start(term_button, False)
        self.term_notebook = libTerminal.TerminalNotebook()
        #term_button.connect("clicked", term_notebook.new_tab)
        term_button.connect("clicked", self.new_tab)
        term_box.pack_start(self.term_notebook)
        setattr(self.uiman, 'termnb', self.term_notebook)
        setattr(self.uiman, 'mainnb', self.notebook)

        self.notebook.append_page(term_box, b)
        term_box.show_all()

        #################################################################################################################################
        # RCE Iface
        #################################################################
        # xdot rce
        import xdot
        self.xdotr = xdot.DotWidget()
        self.xdotr.set_size_request(600, 512)
        self.xdotr.show()

        bufferf = "RCE"
        frame = gtk.Frame(bufferf)
        frame.set_border_width(5)
        frame.set_size_request(400, 400)

        label = gtk.Label('RCE')
        label.set_angle(90)
        b_factory = gtk.VBox
        b = b_factory(spacing=1)
        i = gtk.Image()
        i.set_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_SMALL_TOOLBAR)
        b.pack_start(label)
        b.pack_start(i)
        b.show_all()
        self.notebook.append_page(frame, b)

        # RCE graph menu
        self.rmenu = rceTBar.RceMenu(self.xdotr, rcecore)
        self.dasmenu = rceTBar.DasmMenu()

        #################################################################################################################################
        # UIManager for RCE Toolbar
        #################################################################
        # to make it nice we'll put the toolbar into the handle box,
        # so that it can be detached from the main window
        self.rcehb = gtk.HandleBox()
        tbhbox.pack_start(self.rcehb, True, True, 1)

        # Create a UIManager instance
        rceuiman = gtk.UIManager()
        rceaccelgroup = rceuiman.get_accel_group()
        self.window.add_accel_group(rceaccelgroup)
        self._actiongroup = actiongroup = gtk.ActionGroup('UIManager')

        # Create actions
        actiongroup.add_actions([
            # xml_name, icon, real_menu_text, accelerator, tooltip, callback
            ('New', gtk.STOCK_NEW, ('New'), None, (''), self.newBin),
            ('Load', gtk.STOCK_OPEN, ('Load'), None, (''), self.loadBin),
            ('Show Log', gtk.STOCK_DND, ('Show Log'), None, (''),
             self.show_log),
            #('Debugger', gtk.STOCK_EXECUTE, ('Debugger'), None, (''), gtk.main_quit),
            ('Debugger', gtk.STOCK_EXECUTE, ('Debugger'), None, (''),
             self.run_debugger),
            #('Report', gtk.STOCK_DND, ('Report'), None, (''), gtk.main_quit),
            ('Quit', gtk.STOCK_QUIT, ('Quit'), None, (''), gtk.main_quit),
        ])

        # Add the actiongroup to the rceuiman
        rceuiman.insert_action_group(actiongroup, 0)
        rceuiman.add_ui_from_string(rce_menu)

        # Toolbar
        rcetoolbar = rceuiman.get_widget('/RceToolbar')
        self.rcehb.add(rcetoolbar)
        self.rcehb.hide()

        #################################################################
        # RCE HBox and VBoxes
        #################################################################
        rcepaned = gtk.HPaned()
        lrcevb = gtk.VBox(False, 1)
        rrcevb = gtk.VBox(False, 1)

        rcepaned.add1(lrcevb)
        rcepaned.add2(rrcevb)

        lrcevb.pack_start(self.rmenu, False, False, 1)
        rrcevb.pack_start(self.dasmenu, False, False, 1)

        rcepaned.show_all()

        #################################################################
        # Textview RCE
        #################################################################
        rcetv = gtk.TextView(buffer=None)
        rcetv.set_wrap_mode(gtk.WRAP_NONE)
        rcetv.set_editable(False)
        fontdesc = pango.FontDescription("MonoSpace 10")
        #fontdesc = pango.FontDescription("Purisa 10")
        rcetv.modify_font(fontdesc)
        rcetv.show()
        self.textbuffer = rcetv.get_buffer()

        # Scrolled Window
        rce_scrolled_window = gtk.ScrolledWindow()
        rce_scrolled_window.set_policy(gtk.POLICY_AUTOMATIC,
                                       gtk.POLICY_AUTOMATIC)
        rce_scrolled_window.show()
        # Add Textview to Scrolled Window
        rce_scrolled_window.add_with_viewport(rcetv)

        # Add xdotr and textview to rcehbox
        lrcevb.pack_start(self.xdotr, True, True, 2)
        rrcevb.pack_start(rce_scrolled_window, True, True, 2)

        frame.add(rcepaned)
        frame.show()
        rcepaned.show()

        #################################################################################################################################
        # Xploit Iface
        #################################################################
        bufferf = "Exploit"
        frame = gtk.Frame(bufferf)
        frame.set_border_width(5)
        frame.show()
        label = gtk.Label('Exploit')
        frame.add(label)
        label.show()
        label = gtk.Label('Exploit')
        label.set_angle(90)
        b_factory = gtk.VBox
        b = b_factory(spacing=1)
        i = gtk.Image()
        i.set_from_stock(gtk.STOCK_PREFERENCES, gtk.ICON_SIZE_SMALL_TOOLBAR)
        b.pack_start(label)
        b.pack_start(i)
        b.show_all()

        self.exploitsInst = exploits.Exploits(config, self.term_notebook)
        exploitsGui = self.exploitsInst.get_widget()
        exploitsGui.show_all()
        self.notebook.append_page(exploitsGui, b)

        #mainvbox.pack_start(notebook, True, True, 1)
        self.vpaned.add1(self.notebook)
        self.notebook.show()

        #################################################################################################################################
        # Log Window
        #################################################################
        self.logtext = gtk.TextView(buffer=None)
        self.logtext.set_wrap_mode(gtk.WRAP_NONE)
        self.logtext.set_editable(False)
        #self.logtext.set_size_request(40,40)
        self.logbuffer = self.logtext.get_buffer()
        self.logbuffer.set_text('Loading Inguma...\n')
        self.logtext.show()

        #################################################################
        # Log Scrolled Window
        #################################################################
        self.log_scrolled_window = gtk.ScrolledWindow()
        self.log_scrolled_window.set_policy(gtk.POLICY_AUTOMATIC,
                                            gtk.POLICY_ALWAYS)
        self.log_scrolled_window.is_visible = True

        #Always on bottom on change
        self.vajd = self.log_scrolled_window.get_vadjustment()
        self.vajd.connect(
            'changed',
            lambda a, s=self.log_scrolled_window: self.rescroll(a, s))

        #self.log_scrolled_window.set_size_request(40,40)
        #self.logtext.set_size_request(20,20)

        # Add Textview to Scrolled Window
        self.log_scrolled_window.add_with_viewport(self.logtext)

        # Set logtext as output for gui
        self.gom.set_gui(self.logbuffer)

        # Add Scrolled Log Window to Bottom Notebook
        ############################################

        # Notebook for bottom panel
        self.bottom_nb = gtk.Notebook()
        self.bottom_nb.set_tab_pos(gtk.POS_LEFT)

        # Icon and label for Logs tab
        label = gtk.Label('Logs')
        label.set_angle(90)
        b_factory = gtk.VBox
        b = b_factory(spacing=1)
        i = gtk.Image()
        i.set_from_stock(gtk.STOCK_JUSTIFY_FILL, gtk.ICON_SIZE_SMALL_TOOLBAR)
        b.pack_start(label)
        b.pack_start(i)
        b.show_all()

        self.bottom_nb.append_page(self.log_scrolled_window, b)

        # Icon and label for Actions tab
        label = gtk.Label('Actions')
        label.set_angle(90)
        b_factory = gtk.VBox
        b = b_factory(spacing=1)
        i = gtk.Image()
        i.set_from_stock(gtk.STOCK_EXECUTE, gtk.ICON_SIZE_SMALL_TOOLBAR)
        b.pack_start(label)
        b.pack_start(i)
        b.show_all()

        # Add Threads TreeView
        self.threadsInst = threadstv.ThreadsTv()
        threadsGui = self.threadsInst.get_widget()
        threadsGui.show_all()

        self.bottom_nb.append_page(threadsGui, b)

        #self.bottom_nb.set_scrollable(True)
        self.bottom_nb.set_current_page(0)

        # Check visibility on config preferences
        if config.SHOW_LOG:
            self.bottom_nb.is_visible = True
            self.bottom_nb.show()
        else:
            self.bottom_nb.is_visible = False

        self.vpaned.add2(self.bottom_nb)
        mainvbox.pack_start(self.vpaned, True, True, 1)
        self.log_scrolled_window.show()

        # Add threadtv to core
        self.uicore.set_threadtv(self.threadsInst)
        setattr(self.graph_uiman, 'threadtv', self.threadsInst)

        #        #################################################################################################################################
        #        # Progress Bar
        #        #################################################################
        #        self.progressbar = pbar.PBar()
        #        self.progressbar.set_stopped()
        #        mainvbox.pack_start(self.progressbar, False, False, 1)

        #################################################################################################################################
        #StatusBar
        #################################################################
        statusbar = gtk.Statusbar()
        mainvbox.pack_end(statusbar, False, False, 1)
        context_id = statusbar.get_context_id("Inguma 0.2")
        message_id = statusbar.push(context_id, 'Inguma 0.2')
        statusbar.show()

        #################################################################################################################################
        # finish it
        #################################################################
        self.vpaned.show()
        self.window.show()
        splash.destroy()

        gtk.main()
Esempio n. 16
0
    def __init__(self):

        ttle1 = 'Spectrum el1'
        ttle2 = ' el2 - . el1'
        ttle3 = ' el3 - . el1'
        ttle4 = ' el1 - . el2'
        ttle5 = ' Spectrum el2'
        ttle6 = ' el3 - . el2'
        ttle7 = ' el1 - . el3'
        ttle8 = 'el2 - . el3'
        ttle9 = 'Spectrum el3'

        self.win = gtk.Window()
        self.win.set_border_width(5)
        self.win.resize(800, 400)
        vbox = gtk.VBox(spacing=3)
        self.win.add(vbox)
        vbox.show()
        self.fig = Figure(figsize=(7, 5), dpi=72)

        self.canvas = FigureCanvas(self.fig)  # a gtk.DrawingArea
        self.canvas.show()
        vbox.pack_start(self.canvas, True, True)
        (self.e1, self.e2, self.e3) = signal_gen.signal_gen(3, .1, .001)

        c = 0
        for i in self.e1:
            print i, self.e2[c]
            c += 1

        self.ax1 = self.fig.add_subplot(431, title=ttle1)
        # self.ax1.set_xlim(0,60)
        # self.ax1.set_ylim(0,1)

        self.ax2 = self.fig.add_subplot(432, title=ttle2)
        self.ax2.set_xlim(0, 60)
        self.ax2.set_ylim(0, 1)

        self.ax3 = self.fig.add_subplot(433, title=ttle3)
        self.ax3.set_xlim(0, 60)
        self.ax3.set_ylim(0, 1)

        self.ax4 = self.fig.add_subplot(434, title=ttle4)
        self.ax4.set_xlim(0, 60)
        self.ax4.set_ylim(0, 1)

        self.ax5 = self.fig.add_subplot(435, title=ttle5)
        self.ax5.set_xlim(0, 60)
        self.ax5.set_ylim(0, 1)

        self.ax6 = self.fig.add_subplot(436, title=ttle6)
        self.ax6.set_xlim(0, 60)
        self.ax6.set_ylim(0, 1)

        self.ax7 = self.fig.add_subplot(437, title=ttle7)
        self.ax7.set_xlim(0, 60)
        self.ax7.set_ylim(0, 1)

        self.ax8 = self.fig.add_subplot(438, title=ttle8)
        self.ax8.set_xlim(0, 60)
        self.ax8.set_ylim(0, 1)

        self.ax9 = self.fig.add_subplot(439, title=ttle9)
        self.ax9.set_xlim(0, 60)
        self.ax9.set_ylim(0, 1)

        self.ax10 = self.fig.add_subplot(4, 3, 10, title="el1")
        self.ax11 = self.fig.add_subplot(4, 3, 11, title="el2")
        self.ax12 = self.fig.add_subplot(4, 3, 12, title="el3")
Esempio n. 17
0
import gtk

ventana = gtk.Window()

gtk.main()
Esempio n. 18
0
alpha = 0.0

# Function for fade splash screen
def fade_window(data=None):
    global alpha
    
    data.set_opacity(alpha)
    alpha += 0.05;
    
    if alpha <= 1.0:
        gobject.timeout_add(20, fade_window, data);
    
    return False;
 
# init window
splash = gtk.Window(gtk.WINDOW_TOPLEVEL)

# enable RGBA colormap for opacity
screen = splash.get_screen()
colormap = screen.get_rgba_colormap()

if colormap:
    gtk.widget_set_default_colormap(colormap)

# Set width and height
splash.set_size_request (595, 218)
# Set window hint spashscreen
splash.set_type_hint (gtk.gdk.WINDOW_TYPE_HINT_SPLASHSCREEN)
# Set window centered
splash.set_position (gtk.WIN_POS_CENTER)
# Set window above the others
Esempio n. 19
0
    def __init__(self, hosts=None, owner=None, poll_interval=None):
        gobject.threads_init()
        set_exception_hook_dialog("cylc gscan")
        setup_icons()
        if not hosts:
            hosts = GLOBAL_CFG.get(["suite host scanning", "hosts"])
        self.hosts = hosts
        if owner is None:
            owner = USER
        self.owner = owner
        self.window = gtk.Window()
        self.window.set_title("cylc gscan")
        self.window.set_icon(get_icon())
        self.vbox = gtk.VBox()
        self.vbox.show()

        self.theme_name = gcfg.get(['use theme'])
        self.theme = gcfg.get(['themes', self.theme_name])

        self.dots = DotMaker(self.theme)
        suite_treemodel = gtk.TreeStore(str, str, bool, str, int, str, str)
        self._prev_tooltip_location_id = None
        self.suite_treeview = gtk.TreeView(suite_treemodel)

        # Construct the host column.
        host_name_column = gtk.TreeViewColumn("Host")
        cell_text_host = gtk.CellRendererText()
        host_name_column.pack_start(cell_text_host, expand=False)
        host_name_column.set_cell_data_func(
            cell_text_host, self._set_cell_text_host)
        host_name_column.set_sort_column_id(0)
        host_name_column.set_visible("host" in gsfg.get(["columns"]))
        host_name_column.set_resizable(True)

        # Construct the suite name column.
        suite_name_column = gtk.TreeViewColumn("Suite")
        cell_text_name = gtk.CellRendererText()
        suite_name_column.pack_start(cell_text_name, expand=False)
        suite_name_column.set_cell_data_func(
            cell_text_name, self._set_cell_text_name)
        suite_name_column.set_sort_column_id(1)
        suite_name_column.set_visible("suite" in gsfg.get(["columns"]))
        suite_name_column.set_resizable(True)

        # Construct the suite title column.
        suite_title_column = gtk.TreeViewColumn("Title")
        cell_text_title = gtk.CellRendererText()
        suite_title_column.pack_start(cell_text_title, expand=False)
        suite_title_column.set_cell_data_func(
            cell_text_title, self._set_cell_text_title)
        suite_title_column.set_sort_column_id(3)
        suite_title_column.set_visible("title" in gsfg.get(
            ["columns"]))
        suite_title_column.set_resizable(True)

        # Construct the update time column.
        time_column = gtk.TreeViewColumn("Updated")
        cell_text_time = gtk.CellRendererText()
        time_column.pack_start(cell_text_time, expand=False)
        time_column.set_cell_data_func(
            cell_text_time, self._set_cell_text_time)
        time_column.set_sort_column_id(4)
        time_column.set_visible("updated" in gsfg.get(["columns"]))
        time_column.set_resizable(True)

        self.suite_treeview.append_column(host_name_column)
        self.suite_treeview.append_column(suite_name_column)
        self.suite_treeview.append_column(suite_title_column)
        self.suite_treeview.append_column(time_column)

        # Construct the status column.
        status_column = gtk.TreeViewColumn("Status")
        status_column.set_sort_column_id(5)
        status_column.set_visible("status" in gsfg.get(["columns"]))
        status_column.set_resizable(True)
        status_column_info = 6
        cycle_column_info = 5
        cell_text_cycle = gtk.CellRendererText()
        status_column.pack_start(cell_text_cycle, expand=False)
        status_column.set_cell_data_func(
            cell_text_cycle, self._set_cell_text_cycle, cycle_column_info)
        self.suite_treeview.append_column(status_column)
        for i in range(len(TASK_STATUSES_ORDERED)):
            cell_pixbuf_state = gtk.CellRendererPixbuf()
            status_column.pack_start(cell_pixbuf_state, expand=False)
            status_column.set_cell_data_func(
                cell_pixbuf_state, self._set_cell_pixbuf_state,
                (status_column_info, i)
            )

        self.suite_treeview.show()
        if hasattr(self.suite_treeview, "set_has_tooltip"):
            self.suite_treeview.set_has_tooltip(True)
            try:
                self.suite_treeview.connect('query-tooltip',
                                            self._on_query_tooltip)
            except TypeError:
                # Lower PyGTK version.
                pass
        self.suite_treeview.connect("button-press-event",
                                    self._on_button_press_event)
        scrolled_window = gtk.ScrolledWindow()
        scrolled_window.set_policy(gtk.POLICY_AUTOMATIC,
                                   gtk.POLICY_AUTOMATIC)
        scrolled_window.add(self.suite_treeview)
        scrolled_window.show()
        self.vbox.pack_start(scrolled_window, expand=True, fill=True)
        self.updater = ScanAppUpdater(
            self.hosts, suite_treemodel, self.suite_treeview,
            owner=self.owner, poll_interval=poll_interval
        )
        self.updater.start()
        self.window.add(self.vbox)
        self.window.connect("destroy", self._on_destroy_event)
        self.window.set_default_size(300, 150)
        self.suite_treeview.grab_focus()
        self.window.show()
Esempio n. 20
0
    def run(self):
        warnings.simplefilter("ignore")

        self._pipe_name = '/tmp/webapp.pipe'

        self._view = view = webkit.WebView()
        view.connect('navigation-policy-decision-requested',
                     self._nav_req_handler)
        view.connect('close-web-view', self._close)
        view.connect('onload-event', self._onload)

        language = self._get_browser_lang()
        view.execute_script("window.navigator.userLanguage = '%s'" % language)

        if self._inspector:
            view.get_settings().set_property("enable-developer-extras", True)

        if hasattr(self.__class__, "_focus_in"):
            view.connect('focus-in-event', self._focus_in)

        if hasattr(self.__class__, "_focus_out"):
            view.connect('focus-out-event', self._focus_out)

        if hasattr(self.__class__, "_download"):
            view.connect('download-requested', self._download)

        splitter = gtk.VPaned()
        sw = gtk.ScrolledWindow()
        sw.add(view)
        splitter.add1(sw)

        inspector = view.get_web_inspector()
        inspector.connect("inspect-web-view", self._activate_inspector,
                          splitter)

        self._win = win = gtk.Window(gtk.WINDOW_TOPLEVEL)
        win.set_title(self._title)
        win.connect("destroy", gtk.main_quit)

        if self._app_icon is not None:
            if os.path.exists(self._app_icon):
                win.set_icon_from_file(self._app_icon)
            else:
                win.set_icon_name(self._app_icon)

        if self._taskbar is False:
            gtk.Window.set_skip_taskbar_hint(win, True)

        win.add(splitter)
        win.realize()
        win.show_all()

        gdk_window_settings(win.window, self._x, self._y, self._width,
                            self._height, self._decoration, self._maximized,
                            self._centered)

        if self._disable_minimize:
            win.connect("window-state-event", self._unminimise_if_minimised)

        view.open(self._index)

        # Start a thread that injects Javascript code coming from a filesystem pipe.
        if self._pipe == True:
            atexit.register(atexit_pipe_cleanup, self._pipe_name)
            thread.start_new_thread(thr_inject_javascript,
                                    (self._view, self._pipe_name))

        gtk.main()
Esempio n. 21
0
    def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.set_resizable(True)
        self.window.set_size_request(450,540)
        self.window.connect("destroy", self.close_application)
        self.window.connect("key_press_event", self.key_pressed)
        self.handler = self.window.connect("key_release_event", self.key_released)
        self.window.set_title("Devanagari Editor")
        self.window.set_border_width(0)
        self.window.set_icon_from_file("DElogo.ico")

        menubar = gtk.MenuBar()
        
        menu_file = gtk.Menu()
        menu_edit = gtk.Menu()
        menu_help = gtk.Menu()
        
        item_open = gtk.MenuItem("Open")
        item_open.connect("activate", self.open_devanagari_file)
        item_save = gtk.MenuItem("Save")
        item_save.connect("activate", self.save_devanagari_file)
        item_quit = gtk.MenuItem("Quit")
        item_quit.connect("activate", self.close_application)
        menu_file.append(item_open)
        menu_file.append(item_save)
        menu_file.append(item_quit)

        item_cut = gtk.MenuItem("Cut")
        item_copy = gtk.MenuItem("Copy")
        item_paste = gtk.MenuItem("Paste")
        menu_edit.append(item_cut)
        menu_edit.append(item_copy)
        menu_edit.append(item_paste)
        
        item_about = gtk.MenuItem("About")
        menu_help.append(item_about)
        
        item_file = gtk.MenuItem("File")
        item_edit = gtk.MenuItem("Edit")
        item_help = gtk.MenuItem("Help")
        
        item_file.set_submenu(menu_file)
        item_edit.set_submenu(menu_edit)
        item_help.set_submenu(menu_help)
        
        menubar.append(item_file)
        menubar.append(item_edit)
        menubar.append(item_help)
        

        self.box1 = gtk.VBox(False, 0)
        self.window.add(self.box1)
        self.box1.show()

        self.box1.pack_start(menubar, False, False, 0)
        
        box2 = gtk.VBox(False, 0)
        box2.set_border_width(0)
        self.box1.pack_start(box2, True, True, 0)
        box2.show()

        # the source text buffer
        sw = gtk.ScrolledWindow()
        sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        self.textview = gtk.TextView()
        self.textbuffer = self.textview.get_buffer()
        self.textview.set_wrap_mode(gtk.WRAP_WORD)
        self.textview.modify_font(pango.FontDescription("Sans 12"))
        sw.add(self.textview)
        sw.show()
        self.textview.show()

        box2.pack_start(sw)

        self.Mode = 'Devanagari'

        # clipboard
        self.clipboard = gtk.Clipboard(gtk.gdk.display_get_default(), "CLIPBOARD")
        
        # show the window 
        self.window.show_all()
Esempio n. 22
0
    def __init__(self):
        # Create the main window, and attach delete_event signal to terminate
        # the application.  Note that the main window will not have a titlebar
        # since we're making it a popup.
        window = gtk.Window(gtk.WINDOW_POPUP)
        window.set_flags(gtk.CAN_FOCUS | gtk.SENSITIVE)

        window.connect("delete_event", self.close_application)
        window.set_events(window.get_events() | gtk.gdk.BUTTON_PRESS_MASK)
        window.set_events(window.get_events() | gtk.gdk.KEY_PRESS_MASK
                          | gtk.gdk.KEY_RELEASE_MASK)
        window.connect("button_press_event", self.close_application)
        window.connect("key-press-event", self.close_application)

        ww = 320
        hh = 100

        #window.set_position(gtk.WIN_POS_CENTER_ALWAYS)
        window.move(gtk.gdk.screen_width() - (ww + 20), 40)
        window.show()

        # Now for the pixmap and the image widget
        #pixmap, mask = gtk.gdk.pixmap_create_from_xpm_d(
        #    window.window, None, WheelbarrowFull_xpm)

        #pixmap = gtk.gdk.pixbuf_new_from_file("/usr/share/pixmaps/gnome-logo-large.png")

        #image = gtk.image_new_from_file("/usr/share/pixmaps/gnome-logo-large.png")
        #image = gtk.image_new_from_file("/usr/share/pixmaps/gnome-background-image.png")
        image = gtk.image_new_from_file("/usr/share/pixmaps/gnome-tigert.png")
        fname = os.getcwd() + "/rect.png"
        #print fname
        #image = gtk.image_new_from_file(fname)
        #pixbuff = image.get_pixbuf()
        #print image

        #pixbuff = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, True, 8, 300, 300);
        #pixbuff.fill(0xfffaafff)

        pixmap = gtk.gdk.Pixmap(window.window, ww, hh, depth=-1)
        gc = gtk.gdk.GC(pixmap)

        colormap = window.get_colormap()
        color = colormap.alloc_color("#ff8080")
        gc.set_foreground(color)
        pixmap.draw_rectangle(gc, True, 0, 0, ww, hh)

        color = colormap.alloc_color("#000000")
        gc.set_foreground(color)
        gc.line_width = 4
        gc.cap_style = gtk.gdk.CAP_ROUND

        #pixmap.draw_line(gc, 10, 10, ww-10, hh-10)
        #pixmap.draw_line(gc, ww-10, 10, 10, hh-10)

        cairo = pixmap.cairo_create()
        lay = cairo.create_layout()
        fd = pango.FontDescription()
        fd.set_size(14 * 1024)
        lay.set_font_description(fd)

        lay.set_text("Please set Password for 'user' ")
        dim = lay.get_pixel_size()

        pixmap.draw_layout(gc,
                           pixmap.get_size()[0] / 2 - dim[0] / 2,
                           pixmap.get_size()[1] / 2 - dim[1], lay)

        lay.set_text("Please set Password for 'root'")
        dim = lay.get_pixel_size()

        pixmap.draw_layout(gc,
                           pixmap.get_size()[0] / 2 - dim[0] / 2,
                           pixmap.get_size()[1] / 2, lay)

        image2 = gtk.Image()
        image2.set_from_pixmap(pixmap, None)
        image2.show()

        #rect = gtk.gdk.Rectangle(100, 100, 200, 200)
        #region = gtk.gdk.region_rectangle(rect)
        #window.shape_combine_region(region, 0, 0)

        # To display the image, we use a fixed widget to place the image
        fixed = gtk.Fixed()
        fixed.put(image, 0, 0)
        window.add(fixed)
        fixed.show()

        maskmap = gtk.gdk.Pixmap(window.window, ww, hh, depth=-1)
        gc = gtk.gdk.GC(maskmap)

        gc.set_rgb_fg_color(gtk.gdk.Color(0, 0, 0))
        maskmap.draw_rectangle(gc, True, 0, 0, ww, hh)

        gc.set_rgb_fg_color(gtk.gdk.Color(0xffff, 0xffff, 0xffff))
        maskmap.draw_rectangle(gc, True, 20, 20, ww - 40, hh - 40)

        maskbuff = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, True, 8, ww, hh)
        maskbuff.get_from_drawable(maskmap,  gtk.gdk.colormap_get_system(), \
                        0, 0, 0, 0, ww, hh)

        maskbuff.add_alpha(True, 0, 0, 0)

        mask2, mask3 = maskbuff.render_pixmap_and_mask()

        #image3 = gtk.Image()
        #image3.set_from_pixmap(mask2, None)
        #image3.show()
        #fixed.put(image3, 0, 0)
        # This masks out everything except for the image itself
        #window.shape_combine_mask(mask3, 0, 0)

        # show the window
        window.show()
Esempio n. 23
0
    def __init__(self, mainWindow):
        self.runcmd = mainWindow.runcmd
        # Create a new window

        self.window = gtk.Window()  #hadjustment=None, vadjustment=None)
        self.swindow = gtk.ScrolledWindow(hadjustment=None, vadjustment=None)
        self.swindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
        self.window.set_title("AGOOEY Process Selector")

        self.window.set_size_request(600, 240)

        self.window.connect("delete_event", self.delete_event)
        self.vbox = gtk.VBox(homogeneous=False, spacing=0)
        self.hbox = gtk.HBox(homogeneous=False, spacing=0)
        rows = 6
        cols = 6
        self.table = gtk.Table(rows, cols, False)

        button_strings = [
            'm__readfiles', 's__readfiles', 'coarseorb', 'demassist',
            'subtrrefpha', 'dinsar', 'm__porbits', 's__porbits', 'coarsecorr',
            'coregpm', 'comprefdem', 'slant2h', 'm__crop', 's__crop',
            'm__filtazi', 'resample', 'subtrrefdem', 'geocode', 'm__simamp',
            '', 's__filtazi', 'filtrange', 'coherence', '', 'm__timing', '',
            'fine', 'interfero', 'filtphase', '', 'm__ovs', 's__ovs',
            'reltiming', 'comprefpha', 'unwrap'
        ]
        button = map(lambda i: gtk.Button(button_strings[i]),
                     range(len(button_strings)))

        ##### SET THE HBOX #####
        self.processEntry = gtk.Entry()
        self.processEntry.set_editable(False)
        self.processEntry.show()

        self.applyButton = gtk.Button(label='Apply',
                                      stock=None,
                                      use_underline=True)
        self.applyButton.connect("clicked", self.applyButtonClicked)
        self.applyButton.set_flags(gtk.CAN_DEFAULT)
        self.applyButton.show()

        self.refreshButton = gtk.Button(label='Clear',
                                        stock=None,
                                        use_underline=True)
        self.refreshButton.connect("clicked", self.refreshButtonClicked)
        self.refreshButton.set_flags(gtk.CAN_DEFAULT)
        self.refreshButton.show()

        self.advancedChkBtn = gtk.CheckButton("Advanced")
        self.advancedChkBtn.connect("toggled", self.advancedChkBtnToggled)
        self.advancedChkBtn.show()

        self.hbox.pack_start(self.refreshButton,
                             expand=False,
                             fill=False,
                             padding=10)
        self.hbox.pack_start(self.applyButton,
                             expand=False,
                             fill=False,
                             padding=10)
        self.hbox.pack_end(self.advancedChkBtn,
                           expand=False,
                           fill=False,
                           padding=20)

        #### SET THE TABLE ####
        for i in range(len(button_strings)):
            y, x = divmod(i, cols)
            if not button_strings[i]:
                continue
            button[i].connect("clicked", self.processButtonClicked)
            self.table.attach(button[i], x, x + 1, y, y + 1)
            button[i].show()

        ### SET THE VBOX ####
        self.vbox.pack_start(
            self.processEntry,
            expand=False,
            fill=False,
        )
        self.vbox.pack_start(
            self.hbox,
            expand=False,
            fill=False,
        )
        self.vbox.pack_start(
            self.table,
            expand=False,
            fill=False,
        )
        self.window.set_default(self.applyButton)

        self.swindow.add_with_viewport(self.vbox)
        self.window.add(self.swindow)
        #self.vbox.show()
        self.window.show_all()
Esempio n. 24
0
    def ssh_sessions(self, _widget, terminal):
        """
            Main Process. Preparing all buttons and window
        """
        global window

        window = gtk.Window()
        window.set_decorated(False)
        window.set_size_request(500, -1)
        window.set_title("Opened SSH Sessions")
        window.connect("destroy", self.destroy)
        total_session = len(self.proc.ssh_sessions)

        if total_session == 0:
            message = gtk.MessageDialog(
                type=gtk.MESSAGE_INFO, buttons=gtk.BUTTONS_OK)
            message.set_markup("NO SSH Connection FOUND")
            message.run()
            message.destroy()
        else:
            self.mainbox = gtk.VBox()
            label = gtk.Label("Select the opened ssh session:")
            label.set_alignment(0, 0)
            self.mainbox.pack_start(label, padding=10)
            label.show()

            check_button = gtk.CheckButton("Copy SSH Keygen to Server?")
            check_button.connect("clicked", self.check_box, "")
            self.mainbox.pack_end(check_button, expand=False)
            check_button.show()

            #radio1 = gtk.RadioButton(None, self.return_item(0))
            #self.mainbox.pack_start(radio1, expand=False)
            # radio1.show()
            # {'terminal' : terminal, 'command' : command['command']
            #radio1.connect("clicked", self.action, {'terminal': terminal, 'command': self.return_item(0)})

            for i in range(total_session):
                radio = gtk.RadioButton(None, self.return_item(i))
                self.mainbox.pack_start(radio, expand=False)
                radio.connect("clicked", self.action, {
                              'terminal': terminal, 'command': self.return_item(i)})
                radio.show()

            self.label = gtk.Label()
            self.mainbox.pack_start(self.label, padding=10)
            self.label.show()

            separator = gtk.HSeparator()
            self.mainbox.pack_start(separator, False, True, 0)
            separator.show()

            radio = gtk.VBox(False, 10)
            self.mainbox.set_border_width(10)
            radio.show()

            # hbox_open = gtk.HBox(False, 0)

            # button_open = gtk.Button(label='Open')
            # button_open.connect("clicked", lambda w: self.action())
            # button_open.set_flags(gtk.CAN_DEFAULT)
            # hbox_open.pack_start(button_open, True, False, 0)
            # button_open.show()

            hbox_close = gtk.HBox(False, 0)

            button_close = gtk.Button(stock=gtk.STOCK_CLOSE)
            button_close.connect("clicked", lambda w: window.hide())
            button_close.set_flags(gtk.CAN_DEFAULT)
            hbox_close.pack_end(button_close, False, False, 0)
            button_close.show()

            # hbox_open.show()
            hbox_close.show()
            self.mainbox.add(hbox_close)
            window.add(self.mainbox)

            window.show_all()
Esempio n. 25
0
show how to add a matplotlib FigureCanvasGTK or FigureCanvasGTKAgg widget to a
gtk.Window
"""

import gtk

from matplotlib.figure import Figure
from numpy import arange, sin, pi

# uncomment to select /GTK/GTKAgg/GTKCairo
from matplotlib.backends.backend_gtk import FigureCanvasGTK as FigureCanvas
#from matplotlib.backends.backend_gtkagg import FigureCanvasGTKAgg as FigureCanvas
#from matplotlib.backends.backend_gtkcairo import FigureCanvasGTKCairo as FigureCanvas


win = gtk.Window()
win.connect("destroy", lambda x: gtk.main_quit())
win.set_default_size(400,300)
win.set_title("Embedding in GTK")

f = Figure(figsize=(5,4), dpi=100)
a = f.add_subplot(111)
t = arange(0.0,3.0,0.01)
s = sin(2*pi*t)
a.plot(t,s)

canvas = FigureCanvas(f)  # a gtk.DrawingArea
win.add(canvas)

win.show_all()
gtk.main()
Esempio n. 26
0
    def __init__(self, sourceview, sv_changed):
        self.sourceview = sourceview
        sv_changed.append(self.on_sv_changed)
        
        # Widgets
        self.textview = tv = gtk.TextView()
        self.hscrollbar = hs = gtk.HScrollbar()
        self.vscrollbar = vs = gtk.VScrollbar()
        self.resizegrip = rg = gtk.EventBox()
        self.vbox1 = vb1 = gtk.VBox()
        self.vbox2 = vb2 = gtk.VBox()
        self.hbox = hb = gtk.HBox()
        self.window = win = gtk.Window(gtk.WINDOW_POPUP)
        
        self.char_width, self.char_height = self.get_char_size(tv)
        
        # Dragging vars
        self.is_dragging = None
        self.drag_x = None
        self.drag_y = None
        self.drag_left = None
        self.drag_top = None
        self.was_dragged = None
        
        # Resizing vars
        self.is_resizing = None
        self.resize_x = None
        self.resize_y = None
        self.resize_width = None
        self.resize_height = None
        
        self.was_displayed = False
        
        # Initialization
        
        style = gtk.rc_get_style_by_paths(
            tv.get_settings(), 'gtk-tooltip', 'gtk-tooltip', TYPE_NONE)
        tv.modify_text(gtk.STATE_NORMAL, style.fg[gtk.STATE_NORMAL])
        tv.modify_base(gtk.STATE_NORMAL, style.bg[gtk.STATE_NORMAL])
        tv.set_size_request(0,0)
        tv.props.editable = False
        
        tv.connect('event', self.on_textview_event)
        
        tv.set_scroll_adjustments(hs.props.adjustment, vs.props.adjustment)
        
        tv.connect('scroll-event', self.on_textview_scroll)
        
        hs.props.adjustment.connect('changed', self.on_hadj_changed)

        rg.add_events(gdk.BUTTON_PRESS_MASK
                      | gdk.BUTTON_MOTION_MASK
                      | gdk.BUTTON_RELEASE_MASK
                      | gdk.EXPOSURE_MASK)
        
        rg.connect('event', self.on_resizegrip_event)
        rg.set_size_request(vs.size_request()[0], vs.size_request()[0])
        
        vb1.pack_start(tv, True, True)
        vb1.pack_start(hs, False, False)
        vb2.pack_start(vs, True, True)
        vb2.pack_end(rg, False, False)
        hb.pack_start(vb1, True, True)
        hb.pack_start(vb2, False, False)
        win.add(hb)
        
        # Make all widgets except the window visible, so that a simple "show"
        # will suffice to show the window
        hb.show_all()
        
        # We define this handler here so that it will be defined before
        # the default key-press handler, and so will have higher priority.
        self.keypress_handler = self.sourceview.connect(
            'key-press-event', self.on_keypress)
        self.sourceview.handler_block(self.keypress_handler)
        self.keypress_handler_blocked = True
Esempio n. 27
0
    def __init__(self, fb):
        self.needsReboot = []
        self.xserver_pid = fb.xserver_pid
        self.wm_pid = fb.wm_pid
        self.doReconfig = fb.doReconfig
        self.doDebug = fb.doDebug
        self.lowRes = fb.lowRes
        self.autoscreenshot = fb.autoscreenshot

        self.moduleList = []
        self.moduleDict = {}
        self.pageHistory = []
        self.nextPage = None

        # Create the initial window and a vbox to fill it with.
        self.win = gtk.Window()
        self.win.set_position(gtk.WIN_POS_CENTER)
        self.win.set_decorated(False)

        if not self.doReconfig:
            self.win.set_keep_below(True)

        self.x_screen = gtk.gdk.screen_width()
        self.y_screen = gtk.gdk.screen_height()

        # Create a box that will hold all other widgets.
        self.mainHBox = gtk.HBox(False, 10)

        # leftVBox holds the labels for the various modules.
        self.leftVBox = gtk.VBox()
        self.leftVBox.set_border_width(5)

        # leftEventBox exists only so we have somewhere to paint an image.
        self.leftEventBox = gtk.EventBox()
        self.leftEventBox.add(self.leftVBox)
        self.leftEventBox.connect("realize", self.leb_realized)

        # rightVBox holds the notebook and the button box.
        self.rightVBox = gtk.VBox()
        self.rightVBox.set_border_width(5)

        # If we're in low res mode, grow the right hand box to take up the
        # entire window.
        if self.x_screen >= 800:
            self.leftEventBox.set_size_request(int(0.2 * self.x_screen),
                                               self.y_screen)
            self.rightVBox.set_size_request(int(0.8 * self.x_screen),
                                            self.y_screen)
            self.win.fullscreen()
        else:
            self.rightVBox.set_size_request(self.x_screen, self.y_screen)
            self.win.set_size_request(self.x_screen, self.y_screen)
            self.lowRes = 1

        # Create a button box to handle navigation.
        self.buttonBox = gtk.HButtonBox()
        self.buttonBox.set_layout(gtk.BUTTONBOX_END)
        self.buttonBox.set_spacing(10)

        # Create the "go back" button, marking it insensitive by default.
        self.backButton = gtk.Button(use_underline=True,
                                     stock='gtk-go-back',
                                     label=_("_Back"))
        self.backButton.set_sensitive(False)
        self.backButton.connect('clicked', self.backClicked)

        self.buttonBox.set_border_width(10)
        self.buttonBox.pack_start(self.backButton)

        # Create the "go forward" button.
        self.nextButton = gtk.Button(use_underline=True,
                                     stock='gtk-go-forward',
                                     label=_("_Forward"))
        self.nextHandler = self.nextButton.connect('clicked', self.nextClicked)
        self.buttonBox.pack_start(self.nextButton)

        # Create the notebook.  We use a ListView to control which page in the
        # notebook is displayed.
        self.notebook = gtk.Notebook()
        if self.doDebug:
            #self.modulePath = ('/usr/src/rhn/up2date/firstboot')
            self.modulePath = ('/usr/share/firstboot/modules')
            self.notebook.set_show_tabs(False)
            self.notebook.set_scrollable(True)
            self.notebook.set_show_border(False)
        else:
            self.modulePath = ('/usr/share/firstboot/modules')
            self.notebook.set_show_tabs(False)
            self.notebook.set_show_border(False)

        self.notebook.connect("switch-page", self.switchPage)

        sys.path.append(self.modulePath)

        self.loadModules()

        self.notebook.set_current_page(0)
        self.setPointer(0)

        # Add the widgets into the right side.
        self.rightVBox.pack_start(self.notebook)
        self.rightVBox.pack_start(self.buttonBox, expand=False)

        # Add the widgets into the main widget.
        if not self.lowRes:
            self.mainHBox.pack_start(self.leftEventBox)

        self.mainHBox.pack_start(self.rightVBox)
        self.win.add(self.mainHBox)

        self.win.connect("destroy", self.destroy)
        self.winHandler = self.win.connect("key-release-event",
                                           self.keyRelease)

        # This should really be in firstboot.py, but something about
        # importing all the modules screws the keyboard up only when we
        # start from rhgb.  So here it is.
        if not fb.doDebug:
            from rhpl.keyboard import Keyboard
            kbd = Keyboard()
            kbd.read()
            kbd.activate()

        self.win.show_all()
        self.win.present()
        self.nextButton.grab_focus()
        gtk.main()
    def __init__(self):
        
        #Vetana - - - - -
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.set_resizable(False)
        self.window.set_title("Temas del Burg")
        self.window.set_position(gtk.WIN_POS_CENTER)
        self.window.set_border_width(0)
        self.window.set_size_request(550, 540)
        self.window.connect("delete_event", self.delete_event)
        self.window.connect("destroy", self.destroy)
        self.window.set_icon_from_file('/usr/share/pixmaps/canaima-burg-icon.png')
        
        #Contenedor - - - - -
        self.fixed = gtk.Fixed()
        
        #Etiqueta Descripción - - - - -
        self.label_description = gtk.Label()
        self.label_description.set_markup(
        "Modifica los temas existentes del burg.")
        self.fixed.put(self.label_description, 130,10)
        self.label_description.show()
		
		#Etiqueta tema - - - - -
        self.label_tema_selec= gtk.Label()
        self.label_tema_selec.set_markup(
        "Seleccione el Thema : ")
        self.fixed.put(self.label_tema_selec, 110, 50)
        self.label_tema_selec.show()
        
        #Pestaña desplegable - - - - -
        ruta_burg = next(os.walk(self.RUTA_BUG))[1]
        ruta_burg.sort(key=lambda x: x.upper())
        self.combox_themas = gtk.combo_box_new_text()
        self.combox_themas.set_size_request(180, 35)
        for datos_ruta in ruta_burg:
			if datos_ruta == "icons" or datos_ruta == "conf.d" or datos_ruta == "burg" or datos_ruta == "radiance":
				False
			else:
				self.combox_themas.append_text(datos_ruta)        
        self.fixed.put(self.combox_themas, 280, 40)
        self.combox_themas.show()
        self.combox_themas.connect('changed', self.emulando_thema_burg)
        
        #Imagen Monitor - - - - -
        self.image_pc = gtk.Image()
        self.image_pc.set_from_file(self.MONITOR_IMG)
        self.fixed.put(self.image_pc, 54, 90)
        self.image_pc.show()
        
        #Boton Aplicar - - - - -
        self.button_aplicar = gtk.Button(stock=gtk.STOCK_APPLY)
        self.button_aplicar.set_size_request(80, 30)
        self.button_aplicar.connect("clicked",self.aplicar_thema_burg)
        self.fixed.put(self.button_aplicar, 460,500)
        self.button_aplicar.show()
        
        #~ #Boton Atras - - - - -
        #~ self.button_atras = gtk.Button(stock=gtk.STOCK_GO_BACK)
        #~ self.button_atras.set_size_request(80, 30)
        #~ self.button_atras.connect("clicked",self.atras_inicio)
        #~ self.fixed.put(self.button_atras, 370,500)
        #~ self.button_atras.show()
        
        #Boton Ayuda - - - - -
        self.button_ayuda = gtk.Button(stock=gtk.STOCK_HELP)
        self.button_ayuda.set_size_request(70, 30)
        self.button_ayuda.connect("clicked",self.ayuda_thema_burg)
        self.fixed.put(self.button_ayuda, 110,500)
        self.button_ayuda.show()
        
        #Boton Cerrar - - - - -
        self.button_cerrar = gtk.Button(stock=gtk.STOCK_QUIT)
        self.button_cerrar.set_size_request(80, 30)
        self.button_cerrar.connect("clicked",self.destroy)
        self.fixed.put(self.button_cerrar, 15,500)
        self.button_cerrar.show()
        
        #WebKit - - - -
        self.view = webkit.WebView()
        
        self.window.add(self.fixed)
        self.window.show_all()
        self.window.show()
Esempio n. 29
0
 def test_constructor(self):
     m = hildon.FileSystemModel(root_dir="/")
     d = hildon.FileChooserDialog(gtk.Window(),
                                  gtk.FILE_CHOOSER_ACTION_OPEN, m)
     self.assertTrue(isinstance(d, hildon.FileChooserDialog))
def main():
    PY2 = sys.version_info[0] == 2
    if PY2:
        import gtk
        w = gtk.Window(gtk.WINDOW_TOPLEVEL)
        w.set_default_size(499, 316)
        w.set_title("xterm size hints")
        w.connect("delete_event", gtk.main_quit)
        da = gtk.DrawingArea()
        w.add(da)
        hints = {
            "min_width": 25,
            "min_height": 17,
            "base_width": 19,
            "base_height": 4,
            "width_inc": 6,
            "height_inc": 13,
        }
        w.set_geometry_hints(None, **hints)
    else:
        import gi
        gi.require_version('Gdk', '3.0')
        gi.require_version('Gtk', '3.0')
        from gi.repository import Gtk, Gdk
        w = Gtk.Window(type=Gtk.WindowType.TOPLEVEL)
        w.set_default_size(499, 316)
        w.set_title("xterm size hints")
        w.connect("delete_event", Gtk.main_quit)
        da = gtk.DrawingArea()
        w.add(da)
        geom = Gdk.Geometry()
        wh = Gdk.WindowHints
        geom.min_width = 25
        geom.min_height = 17
        geom.base_width = 19
        geom.base_height = 4
        geom.width_inc = 6
        geom.height_inc = 13
        mask = wh.MIN_SIZE | wh.BASE_SIZE | wh.RESIZE_INC
        if sys.platform.startswith("linux"):
            geom.max_width = 32767
            geom.max_height = 32764
            mask |= wh.MAX_SIZE
        gdk_hints = Gdk.WindowHints(mask)
        w.set_geometry_hints(None, geom, gdk_hints)
        gtk = Gtk

    def configure_event(w, event):
        #print("configure_event(%s, %s)" % (w, event))
        print("event geometry:        %s" %
              ((event.x, event.y, event.width, event.height), ))
        if PY2:
            gdkwindow = w.get_window()
            x, y = gdkwindow.get_origin()
        else:
            gdkwindow = da.get_window()
            x, y = gdkwindow.get_origin()[1:]
        w, h = w.get_size()
        print("drawing area geometry: %s" % ((x, y, w, h), ))

    w.connect("configure_event", configure_event)
    w.show_all()
    gtk.main()