Changes via pygi-convert.sh for gtk2 to gtk3 to the tuna/gui/ directory

Signed-off-by: John Kacur <jka...@redhat.com>
---
 tuna/gui/commonview.py  |  70 ++++++++++----------
 tuna/gui/cpuview.py     |  62 +++++++++---------
 tuna/gui/irqview.py     |  54 +++++++--------
 tuna/gui/procview.py    | 142 ++++++++++++++++++++--------------------
 tuna/gui/profileview.py | 100 ++++++++++++++--------------
 tuna/gui/util.py        |  28 ++++----
 tuna/tuna_gui.py        |   7 +-
 7 files changed, 232 insertions(+), 231 deletions(-)

diff --git a/tuna/gui/commonview.py b/tuna/gui/commonview.py
index a8b475b63538..1a43f41ed438 100644
--- a/tuna/gui/commonview.py
+++ b/tuna/gui/commonview.py
@@ -1,5 +1,5 @@
-import pygtk
-import gtk
+import gi
+from gi.repository import Gtk
 from tuna import tuna, gui
 
 class commonview:
@@ -32,8 +32,8 @@ class commonview:
                        catCntr = 0
                        contentCntr = 0
                        self.contentTable.resize(row+3,2)
-                       
self.contentTable.attach(self.ctrl,0,2,1,2,gtk.FILL,gtk.FILL)
-                       
self.contentTable.attach(self.selector,0,2,0,1,gtk.FILL,gtk.FILL)
+                       
self.contentTable.attach(self.ctrl,0,2,1,2,Gtk.AttachOptions.FILL,Gtk.AttachOptions.FILL)
+                       
self.contentTable.attach(self.selector,0,2,0,1,Gtk.AttachOptions.FILL,Gtk.AttachOptions.FILL)
                        cur = self.profileview.configFileCombo.get_model()
                        for val in cur:
                                if val[0] == self.config.cacheFileName:
@@ -47,8 +47,8 @@ class commonview:
                                        except TypeError as e:
                                                pass
                        while catCntr < catListlenght:
-                               frames[catCntr] = gtk.Frame()
-                               tLabel = 
gtk.Label('<b>'+self.config.categories[catCntr]+'</b>')
+                               frames[catCntr] = Gtk.Frame()
+                               tLabel = 
Gtk.Label(label='<b>'+self.config.categories[catCntr]+'</b>')
                                tLabel.set_use_markup(True)
                                frames[catCntr].set_label_widget(tLabel)
                                frameContent[catCntr] = {}
@@ -58,39 +58,39 @@ class commonview:
                                currentCol = catCntr%2
                                currentRow = (catCntr/2)+2
                                if len(self.config.ctlParams[catCntr]) > 0:
-                                       frameContent[catCntr]['table'] = 
gtk.Table(len(self.config.ctlParams[catCntr]),2,False)
+                                       frameContent[catCntr]['table'] = 
Gtk.Table(len(self.config.ctlParams[catCntr]),2,False)
                                else:
-                                       frameContent[catCntr]['table'] = 
gtk.Table(1,2,False)
+                                       frameContent[catCntr]['table'] = 
Gtk.Table(1,2,False)
                                contentCntr = 0
                                for val in 
sorted(self.config.ctlParams[catCntr], key=str.lower):
                                        if self.config.getSystemValue(val) != 
self.config.ctlParams[catCntr][val]:
                                                star = "*"
                                        else:
                                                star = ""
-                                       
frameContent[catCntr]['labels'][contentCntr] = 
gtk.Label(self.config.originalToAlias(val)+star)
+                                       
frameContent[catCntr]['labels'][contentCntr] = 
Gtk.Label(label=self.config.originalToAlias(val)+star)
                                        
frameContent[catCntr]['labels'][contentCntr].set_alignment(0,0.5)
                                        
frameContent[catCntr]['tooltips'][contentCntr] = tuna.proc_sys_help(val)
                                        if 
len(frameContent[catCntr]['tooltips'][contentCntr]):
                                                
frameContent[catCntr]['labels'][contentCntr].set_tooltip_text(frameContent[catCntr]['tooltips'][contentCntr])
                                        if val in 
self.config.ctlGuiParams[catCntr]:
                                                # scale control
-                                               
frameContent[catCntr]['texts'][contentCntr] = gtk.HScale()
+                                               
frameContent[catCntr]['texts'][contentCntr] = Gtk.HScale()
                                                
frameContent[catCntr]['texts'][contentCntr].set_range(self.config.ctlGuiParams[catCntr][val][0],
 self.config.ctlGuiParams[catCntr][val][1])
-                                               
frameContent[catCntr]['texts'][contentCntr].set_update_policy(gtk.UPDATE_CONTINUOUS)
+                                               
frameContent[catCntr]['texts'][contentCntr].set_update_policy(Gtk.UPDATE_CONTINUOUS)
                                                
frameContent[catCntr]['texts'][contentCntr].set_value(int(self.config.ctlParams[catCntr][val]))
                                                
frameContent[catCntr]['texts'][contentCntr].set_digits(0)
                                        else:
                                                # input field
-                                               
frameContent[catCntr]['texts'][contentCntr] = gtk.Entry(256)
+                                               
frameContent[catCntr]['texts'][contentCntr] = Gtk.Entry(256)
                                                
frameContent[catCntr]['texts'][contentCntr].set_alignment(0)
                                                
frameContent[catCntr]['texts'][contentCntr].set_text(self.config.ctlParams[catCntr][val])
                                        
frameContent[catCntr]['texts'][contentCntr].connect("button-release-event", 
self.checkStar, catCntr, contentCntr, val, 
frameContent[catCntr]['labels'][contentCntr])
                                        
frameContent[catCntr]['texts'][contentCntr].connect("focus-out-event", 
self.checkStar, catCntr,contentCntr,val, 
frameContent[catCntr]['labels'][contentCntr])
-                                       
frameContent[catCntr]['table'].attach(frameContent[catCntr]['labels'][contentCntr],0,1,contentCntr,contentCntr+1,gtk.FILL,xpadding=5)
+                                       
frameContent[catCntr]['table'].attach(frameContent[catCntr]['labels'][contentCntr],0,1,contentCntr,contentCntr+1,Gtk.AttachOptions.FILL,xpadding=5)
                                        
frameContent[catCntr]['table'].attach(frameContent[catCntr]['texts'][contentCntr],1,2,contentCntr,contentCntr+1,xpadding=10)
                                        contentCntr = contentCntr+1
                                
frames[catCntr].add(frameContent[catCntr]['table'])
-                               
self.contentTable.attach(frames[catCntr],currentCol,currentCol+1,currentRow,currentRow+1,gtk.FILL
 | gtk.EXPAND,gtk.FILL,1,1)
+                               
self.contentTable.attach(frames[catCntr],currentCol,currentCol+1,currentRow,currentRow+1,Gtk.AttachOptions.FILL
 | Gtk.AttachOptions.EXPAND,Gtk.AttachOptions.FILL,1,1)
                                catCntr = catCntr+1
                        self.ctrl.set_padding(5,5,0,5)
                        self.contentTable.set_border_width(5)
@@ -151,9 +151,9 @@ class commonview:
                        self.config.applyChanges(self.config.backup)
                        self.updateCommonView()
                except:
-                       dialog = gtk.MessageDialog(None,
-                                       gtk.DIALOG_MODAL | 
gtk.DIALOG_DESTROY_WITH_PARENT,
-                                       gtk.MESSAGE_WARNING, gtk.BUTTONS_OK,
+                       dialog = Gtk.MessageDialog(None,
+                                       Gtk.DialogFlags.MODAL | 
Gtk.DialogFlags.DESTROY_WITH_PARENT,
+                                       Gtk.MessageType.WARNING, 
Gtk.ButtonsType.OK,
                                        _("Backup not found, this button is 
useable after click on apply"))
                        ret = dialog.run()
                        dialog.destroy()
@@ -168,25 +168,25 @@ class commonview:
 
        def on_saveTunedChanges_clicked(self,widget):
                if not self.config.checkTunedDaemon():
-                       dialog = gtk.MessageDialog(None,gtk.DIALOG_MODAL | 
gtk.DIALOG_DESTROY_WITH_PARENT,
-                                               gtk.MESSAGE_WARNING, 
gtk.BUTTONS_OK, _("Tuned daemon undetected!\nFor this function you must have 
installed Tuned daemon."))
+                       dialog = Gtk.MessageDialog(None,Gtk.DialogFlags.MODAL | 
Gtk.DialogFlags.DESTROY_WITH_PARENT,
+                                               Gtk.MessageType.WARNING, 
Gtk.ButtonsType.OK, _("Tuned daemon undetected!\nFor this function you must 
have installed Tuned daemon."))
                        ret = dialog.run()
                        dialog.destroy()
                        return False
-               dialog = gtk.MessageDialog(None,
-                          gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
-                          gtk.MESSAGE_WARNING, gtk.BUTTONS_YES_NO,
+               dialog = Gtk.MessageDialog(None,
+                          Gtk.DialogFlags.MODAL | 
Gtk.DialogFlags.DESTROY_WITH_PARENT,
+                          Gtk.MessageType.WARNING, Gtk.ButtonsType.YES_NO,
                           _("This function can create new profile for tuned 
daemon and apply config permanently after reboot.\nProfile will be permanently 
saved and rewrite all old profiles created by tuna!\nUsing this only if you 
know that config cant corrupt your system!\nRealy can do it?"))
                ret = dialog.run()
                dialog.destroy()
-               if ret == gtk.RESPONSE_NO:
+               if ret == Gtk.ResponseType.NO:
                        return False
                try:
                        ret = self.guiSnapshot()
                        self.config.saveTuned(ret)
                except RuntimeError as e:
-                       dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL | 
gtk.DIALOG_DESTROY_WITH_PARENT,
-                               gtk.MESSAGE_ERROR, gtk.BUTTONS_OK,str(e))
+                       dialog = Gtk.MessageDialog(None, Gtk.DialogFlags.MODAL 
| Gtk.DialogFlags.DESTROY_WITH_PARENT,
+                               Gtk.MessageType.ERROR, 
Gtk.ButtonsType.OK,str(e))
                        ret = dialog.run()
                        dialog.destroy()
                self.profileview.setProfileFileList()
@@ -199,27 +199,27 @@ class commonview:
                err = 
self.config.checkConfigFile(self.config.config['root']+ret[1])
                if err != '':
                        self.restoreConfig = True
-                       dialog = gtk.MessageDialog(None,
-                               gtk.DIALOG_MODAL | 
gtk.DIALOG_DESTROY_WITH_PARENT,
-                               gtk.MESSAGE_WARNING, gtk.BUTTONS_YES_NO,
+                       dialog = Gtk.MessageDialog(None,
+                               Gtk.DialogFlags.MODAL | 
Gtk.DialogFlags.DESTROY_WITH_PARENT,
+                               Gtk.MessageType.WARNING, Gtk.ButtonsType.YES_NO,
                                _("Config file contain errors: \n%s\nRun 
autocorrect?") % _(err))
                        dlgret = dialog.run()
                        dialog.destroy()
-                       if dlgret == gtk.RESPONSE_YES:
+                       if dlgret == Gtk.ResponseType.YES:
                                
self.config.fixConfigFile(self.config.config['root'] + ret[1])
                                err = 
self.config.checkConfigFile(self.config.config['root'] + ret[1])
                                if err != '':
-                                       dialog = gtk.MessageDialog(None,
-                                               gtk.DIALOG_DESTROY_WITH_PARENT,
-                                               gtk.MESSAGE_ERROR, 
gtk.BUTTONS_OK,
+                                       dialog = Gtk.MessageDialog(None,
+                                               
Gtk.DialogFlags.DESTROY_WITH_PARENT,
+                                               Gtk.MessageType.ERROR, 
Gtk.ButtonsType.OK,
                                                _("Config file contain errors: 
\n%s\nAutocorrect failed!") % _(err))
                                        dialog.run()
                                        dialog.destroy()
                                        self.restoreConfig = True
                                else:
-                                       dialog = gtk.MessageDialog(None,
-                                               gtk.DIALOG_DESTROY_WITH_PARENT,
-                                               gtk.MESSAGE_INFO, 
gtk.BUTTONS_OK,
+                                       dialog = Gtk.MessageDialog(None,
+                                               
Gtk.DialogFlags.DESTROY_WITH_PARENT,
+                                               Gtk.MessageType.INFO, 
Gtk.ButtonsType.OK,
                                                _("Autocorrect OK"))
                                        dialog.run()
                                        dialog.destroy()
diff --git a/tuna/gui/cpuview.py b/tuna/gui/cpuview.py
index 7a048fb1c356..78775c0882da 100755
--- a/tuna/gui/cpuview.py
+++ b/tuna/gui/cpuview.py
@@ -1,18 +1,18 @@
 # -*- python -*-
 # -*- coding: utf-8 -*-
 
-import pygtk
+import gi
 from functools import reduce
-pygtk.require("2.0")
+gi.require_version("Gtk", "3.0")
 
 import gtk, gobject, math, os, procfs, schedutils
 from tuna import sysfs, tuna, gui
 
 def set_affinity_warning(tid, affinity):
-        dialog = gtk.MessageDialog(None,
-                                   gtk.DIALOG_MODAL | 
gtk.DIALOG_DESTROY_WITH_PARENT,
-                                   gtk.MESSAGE_WARNING,
-                                   gtk.BUTTONS_OK,
+        dialog = Gtk.MessageDialog(None,
+                                   Gtk.DialogFlags.MODAL | 
Gtk.DialogFlags.DESTROY_WITH_PARENT,
+                                   Gtk.MessageType.WARNING,
+                                   Gtk.ButtonsType.OK,
                                    _("Couldn't change the affinity of %(tid)d 
to %(affinity)s!") % \
                                         {"tid": tid, "affinity": affinity})
         dialog.run()
@@ -37,53 +37,53 @@ def drop_handler_move_irqs_to_cpu(cpus, data):
         # in the irqview, now we always refresh.
         return True
 
-class cpu_socket_frame(gtk.Frame):
+class cpu_socket_frame(Gtk.Frame):
 
         ( COL_FILTER, COL_CPU, COL_USAGE ) = list(range(3))
 
         def __init__(self, socket, cpus, creator):
 
                 if creator.nr_sockets > 1:
-                        gtk.Frame.__init__(self, _("Socket %s") % socket)
+                        GObject.GObject.__init__(self, _("Socket %s") % socket)
                 else:
-                        gtk.Frame.__init__(self)
+                        GObject.GObject.__init__(self)
 
                 self.socket = socket
                 self.cpus = cpus
                 self.nr_cpus = len(cpus)
                 self.creator = creator
 
-                self.list_store = gtk.ListStore(gobject.TYPE_BOOLEAN,
-                                                gobject.TYPE_UINT,
-                                                gobject.TYPE_UINT)
+                self.list_store = Gtk.ListStore(GObject.TYPE_BOOLEAN,
+                                                GObject.TYPE_UINT,
+                                                GObject.TYPE_UINT)
 
-                self.treeview = gtk.TreeView(self.list_store)
+                self.treeview = Gtk.TreeView(self.list_store)
 
                 # Filter column
-                renderer = gtk.CellRendererToggle()
+                renderer = Gtk.CellRendererToggle()
                 renderer.connect('toggled', self.filter_toggled, 
self.list_store)
-                column = gtk.TreeViewColumn(_('Filter'), renderer, active = 
self.COL_FILTER)
+                column = Gtk.TreeViewColumn(_('Filter'), renderer, active = 
self.COL_FILTER)
                 self.treeview.append_column(column)
 
                 # CPU# column
-                column = gtk.TreeViewColumn(_('CPU'), gtk.CellRendererText(),
+                column = Gtk.TreeViewColumn(_('CPU'), Gtk.CellRendererText(),
                                             text = self.COL_CPU)
                 self.treeview.append_column(column)
 
                 # CPU usage column
                 try:
-                        column = gtk.TreeViewColumn(_('Usage'), 
gtk.CellRendererProgress(),
+                        column = Gtk.TreeViewColumn(_('Usage'), 
Gtk.CellRendererProgress(),
                                                     text = self.COL_USAGE, 
value = self.COL_USAGE)
                 except:
                         # CellRendererProgress needs pygtk2 >= 2.6
-                        column = gtk.TreeViewColumn(_('Usage'), 
gtk.CellRendererText(),
+                        column = Gtk.TreeViewColumn(_('Usage'), 
Gtk.CellRendererText(),
                                                     text = self.COL_USAGE)
                 self.treeview.append_column(column)
 
                 self.add(self.treeview)
 
                 self.treeview.enable_model_drag_dest(gui.DND_TARGETS,
-                                                     gtk.gdk.ACTION_DEFAULT)
+                                                     Gdk.DragAction.DEFAULT)
                 self.treeview.connect("drag_data_received",
                                        self.on_drag_data_received_data)
                 self.treeview.connect("button_press_event",
@@ -92,8 +92,8 @@ class cpu_socket_frame(gtk.Frame):
                 self.drop_handlers = { "pid": 
(drop_handler_move_threads_to_cpu, self.creator.procview),
                                        "irq": (drop_handler_move_irqs_to_cpu, 
self.creator.irqview), }
 
-                self.drag_dest_set(gtk.DEST_DEFAULT_ALL, gui.DND_TARGETS,
-                                   gtk.gdk.ACTION_DEFAULT | 
gtk.gdk.ACTION_MOVE)
+                self.drag_dest_set(Gtk.DestDefaults.ALL, gui.DND_TARGETS,
+                                   Gdk.DragAction.DEFAULT | 
Gdk.DragAction.MOVE)
                 self.connect("drag_data_received",
                              self.on_frame_drag_data_received_data)
 
@@ -187,20 +187,20 @@ class cpu_socket_frame(gtk.Frame):
                 self.creator.include_cpus(cpus)
 
         def on_cpu_socket_frame_button_press_event(self, treeview, event):
-                if event.type != gtk.gdk.BUTTON_PRESS or event.button != 3:
+                if event.type != Gdk.EventType.BUTTON_PRESS or event.button != 
3:
                         return
 
                 self.last_x = int(event.x)
                 self.last_y = int(event.y)
 
-                menu = gtk.Menu()
+                menu = Gtk.Menu()
 
-                include = gtk.MenuItem(_("I_nclude CPU"))
-                isolate = gtk.MenuItem(_("_Isolate CPU"))
+                include = Gtk.MenuItem(_("I_nclude CPU"))
+                isolate = Gtk.MenuItem(_("_Isolate CPU"))
                 if self.creator.nr_sockets > 1:
-                        include_socket = gtk.MenuItem(_("I_nclude CPU Socket"))
-                        isolate_socket = gtk.MenuItem(_("_Isolate CPU Socket"))
-                restore = gtk.MenuItem(_("_Restore CPU"))
+                        include_socket = Gtk.MenuItem(_("I_nclude CPU Socket"))
+                        isolate_socket = Gtk.MenuItem(_("_Isolate CPU Socket"))
+                restore = Gtk.MenuItem(_("_Restore CPU"))
 
                 menu.add(include)
                 menu.add(isolate)
@@ -263,7 +263,7 @@ class cpuview:
                 if self.nr_sockets > 1:
                         columns = math.ceil(math.sqrt(self.nr_sockets))
                         rows = math.ceil(self.nr_sockets / columns)
-                        box = gtk.HBox()
+                        box = Gtk.HBox()
                         vbox.pack_start(box, True, True)
                 else:
                         box = vbox
@@ -277,7 +277,7 @@ class cpuview:
                         self.socket_frames[socket_id] = frame
                         if self.nr_sockets > 1:
                                 if column == columns:
-                                        box = gtk.HBox()
+                                        box = Gtk.HBox()
                                         vbox.pack_start(box, True, True)
                                         column = 1
                                 else:
@@ -302,7 +302,7 @@ class cpuview:
                 vpaned.set_position(int(height))
                 hpaned.set_position(int(width))
 
-                self.timer = gobject.timeout_add(3000, self.refresh)
+                self.timer = GObject.timeout_add(3000, self.refresh)
 
         def isolate_cpus(self, cpus):
                 self.previous_pid_affinities, \
diff --git a/tuna/gui/irqview.py b/tuna/gui/irqview.py
index df19f6ee0b66..147809064ca5 100755
--- a/tuna/gui/irqview.py
+++ b/tuna/gui/irqview.py
@@ -1,9 +1,9 @@
 # -*- python -*-
 # -*- coding: utf-8 -*-
 
-import pygtk
+import gi
 from functools import reduce
-pygtk.require("2.0")
+gi.require_version("Gtk", "3.0")
 
 from tuna import tuna, gui
 import ethtool, gobject, gtk, os, procfs, schedutils
@@ -14,10 +14,10 @@ class irq_druid:
                self.irqs = irqs
                self.ps = ps
                self.irq = irq
-               self.window = gtk.glade.XML(gladefile, "set_irq_attributes", 
"tuna")
+               self.window = Gtk.glade.XML(gladefile, "set_irq_attributes", 
"tuna")
                self.dialog = self.window.get_widget("set_irq_attributes")
-               pixbuf = self.dialog.render_icon(gtk.STOCK_PREFERENCES,
-                                                gtk.ICON_SIZE_SMALL_TOOLBAR)
+               pixbuf = self.dialog.render_icon(Gtk.STOCK_PREFERENCES,
+                                                Gtk.IconSize.SMALL_TOOLBAR)
                self.dialog.set_icon(pixbuf)
                event_handlers = { "on_irq_affinity_text_changed" : 
self.on_irq_affinity_text_changed,
                                   "on_sched_policy_combo_changed": 
self.on_sched_policy_combo_changed }
@@ -53,9 +53,9 @@ class irq_druid:
 
        def create_policy_model(self, policy):
                ( COL_TEXT, COL_SCHED ) = list(range(2))
-               list_store = gtk.ListStore(gobject.TYPE_STRING,
-                                          gobject.TYPE_UINT)
-               renderer = gtk.CellRendererText()
+               list_store = Gtk.ListStore(GObject.TYPE_STRING,
+                                          GObject.TYPE_UINT)
+               renderer = Gtk.CellRendererText()
                policy.pack_start(renderer, True)
                policy.add_attribute(renderer, "text", COL_TEXT)
                for pol in range(4):
@@ -77,7 +77,7 @@ class irq_druid:
 
        def run(self):
                changed = False
-               if self.dialog.run() == gtk.RESPONSE_OK:
+               if self.dialog.run() == Gtk.ResponseType.OK:
                        new_policy = self.sched_policy.get_active()
                        new_prio = int(self.sched_pri.get_value())
                        new_affinity = self.affinity.get_text()
@@ -118,12 +118,12 @@ class irqview:
        ( COL_NUM, COL_PID, COL_POL, COL_PRI,
          COL_AFF, COL_EVENTS, COL_USERS ) = list(range(nr_columns))
        columns = (gui.list_store_column(_("IRQ")),
-                  gui.list_store_column(_("PID"), gobject.TYPE_INT),
-                  gui.list_store_column(_("Policy"), gobject.TYPE_STRING),
-                  gui.list_store_column(_("Priority"), gobject.TYPE_INT),
-                  gui.list_store_column(_("Affinity"), gobject.TYPE_STRING),
+                  gui.list_store_column(_("PID"), GObject.TYPE_INT),
+                  gui.list_store_column(_("Policy"), GObject.TYPE_STRING),
+                  gui.list_store_column(_("Priority"), GObject.TYPE_INT),
+                  gui.list_store_column(_("Affinity"), GObject.TYPE_STRING),
                   gui.list_store_column(_("Events")),
-                  gui.list_store_column(_("Users"), gobject.TYPE_STRING))
+                  gui.list_store_column(_("Users"), GObject.TYPE_STRING))
 
        def __init__(self, treeview, irqs, ps, cpus_filtered, gladefile):
 
@@ -140,25 +140,25 @@ class irqview:
                          self.COL_EVENTS,
                          self.COL_USERS ) = list(range(self.nr_columns))
                        self.columns = (gui.list_store_column(_("IRQ")),
-                                       gui.list_store_column(_("Affinity"), 
gobject.TYPE_STRING),
+                                       gui.list_store_column(_("Affinity"), 
GObject.TYPE_STRING),
                                        gui.list_store_column(_("Events")),
-                                       gui.list_store_column(_("Users"), 
gobject.TYPE_STRING))
+                                       gui.list_store_column(_("Users"), 
GObject.TYPE_STRING))
 
-               self.list_store = 
gtk.ListStore(*gui.generate_list_store_columns_with_attr(self.columns))
+               self.list_store = 
Gtk.ListStore(*gui.generate_list_store_columns_with_attr(self.columns))
 
                # Allow selecting multiple rows
                selection = treeview.get_selection()
-               selection.set_mode(gtk.SELECTION_MULTIPLE)
+               selection.set_mode(Gtk.SelectionMode.MULTIPLE)
 
                # Allow enable drag and drop of rows
-               self.treeview.enable_model_drag_source(gtk.gdk.BUTTON1_MASK,
+               
self.treeview.enable_model_drag_source(Gdk.ModifierType.BUTTON1_MASK,
                                                       gui.DND_TARGETS,
-                                                      gtk.gdk.ACTION_DEFAULT | 
gtk.gdk.ACTION_MOVE)
+                                                      Gdk.DragAction.DEFAULT | 
Gdk.DragAction.MOVE)
                self.treeview.connect("drag_data_get", 
self.on_drag_data_get_data)
-               self.renderer = gtk.CellRendererText()
+               self.renderer = Gtk.CellRendererText()
 
                for col in range(self.nr_columns):
-                       column = gtk.TreeViewColumn(self.columns[col].name,
+                       column = Gtk.TreeViewColumn(self.columns[col].name,
                                                    self.renderer, text = col)
                        column.set_sort_column_id(col)
                        column.add_attribute(self.renderer, "weight",
@@ -289,19 +289,19 @@ class irqview:
                        self.refresh()
 
        def on_irqlist_button_press_event(self, treeview, event):
-               if event.type != gtk.gdk.BUTTON_PRESS or event.button != 3:
+               if event.type != Gdk.EventType.BUTTON_PRESS or event.button != 
3:
                        return
 
                self.last_x = int(event.x)
                self.last_y = int(event.y)
 
-               menu = gtk.Menu()
+               menu = Gtk.Menu()
 
-               setattr = gtk.MenuItem(_("_Set IRQ attributes"))
+               setattr = Gtk.MenuItem(_("_Set IRQ attributes"))
                if self.refreshing:
-                       refresh = gtk.MenuItem(_("Sto_p refreshing the IRQ 
list"))
+                       refresh = Gtk.MenuItem(_("Sto_p refreshing the IRQ 
list"))
                else:
-                       refresh = gtk.MenuItem(_("_Refresh the IRQ list"))
+                       refresh = Gtk.MenuItem(_("_Refresh the IRQ list"))
 
                menu.add(setattr)
                menu.add(refresh)
diff --git a/tuna/gui/procview.py b/tuna/gui/procview.py
index 9b2a21a8bb58..790bc31208ff 100755
--- a/tuna/gui/procview.py
+++ b/tuna/gui/procview.py
@@ -1,5 +1,5 @@
-import pygtk
-pygtk.require("2.0")
+import gi
+gi.require_version("Gtk", "3.0")
 
 from tuna import tuna, gui
 import gobject, gtk, procfs, re, schedutils
@@ -21,10 +21,10 @@ class process_druid:
                self.pid = pid
                self.pid_info = pid_info
                self.nr_cpus = nr_cpus
-               self.window = gtk.glade.XML(gladefile, 
"set_process_attributes", "tuna")
+               self.window = Gtk.glade.XML(gladefile, 
"set_process_attributes", "tuna")
                self.dialog = self.window.get_widget("set_process_attributes")
-               pixbuf = self.dialog.render_icon(gtk.STOCK_PREFERENCES,
-                                                gtk.ICON_SIZE_SMALL_TOOLBAR)
+               pixbuf = self.dialog.render_icon(Gtk.STOCK_PREFERENCES,
+                                                Gtk.IconSize.SMALL_TOOLBAR)
                self.dialog.set_icon(pixbuf)
                event_handlers = { "on_cmdline_regex_changed" : 
self.on_cmdline_regex_changed,
                                   "on_affinity_text_changed" : 
self.on_affinity_text_changed,
@@ -69,12 +69,12 @@ class process_druid:
        def create_matching_process_model(self, processes):
                labels = [ "PID", "Name" ]
 
-               self.process_list_store = gtk.ListStore(gobject.TYPE_UINT,
-                                                       gobject.TYPE_STRING)
-               renderer = gtk.CellRendererText()
+               self.process_list_store = Gtk.ListStore(GObject.TYPE_UINT,
+                                                       GObject.TYPE_STRING)
+               renderer = Gtk.CellRendererText()
 
                for col in range(len(labels)):
-                       column = gtk.TreeViewColumn(labels[col], renderer, text 
= col)
+                       column = Gtk.TreeViewColumn(labels[col], renderer, text 
= col)
                        column.set_sort_column_id(col)
                        processes.append_column(column)
 
@@ -82,9 +82,9 @@ class process_druid:
 
        def create_policy_model(self, policy):
                ( COL_TEXT, COL_SCHED ) = list(range(2))
-               list_store = gtk.ListStore(gobject.TYPE_STRING,
-                                          gobject.TYPE_UINT)
-               renderer = gtk.CellRendererText()
+               list_store = Gtk.ListStore(GObject.TYPE_STRING,
+                                          GObject.TYPE_UINT)
+               renderer = Gtk.CellRendererText()
                policy.pack_start(renderer, True)
                policy.add_attribute(renderer, "text", COL_TEXT)
                for pol in range(4):
@@ -166,7 +166,7 @@ class process_druid:
 
        def run(self):
                changed = False
-               if self.dialog.run() == gtk.RESPONSE_OK:
+               if self.dialog.run() == Gtk.ResponseType.OK:
                        new_policy = int(self.sched_policy.get_active())
                        new_prio = int(self.sched_pri.get_value())
                        new_affinity = self.affinity.get_text()
@@ -201,13 +201,13 @@ class procview:
        nr_columns = 8
        ( COL_PID, COL_POL, COL_PRI, COL_AFF, COL_VOLCTXT, COL_NONVOLCTXT, 
COL_CGROUP, COL_CMDLINE ) = list(range(nr_columns))
        columns = (gui.list_store_column(_("PID")),
-                  gui.list_store_column(_("Policy"), gobject.TYPE_STRING),
+                  gui.list_store_column(_("Policy"), GObject.TYPE_STRING),
                   gui.list_store_column(_("Priority")),
-                  gui.list_store_column(_("Affinity"), gobject.TYPE_STRING),
-                  gui.list_store_column(_("VolCtxtSwitch"), gobject.TYPE_UINT),
-                  gui.list_store_column(_("NonVolCtxtSwitch"), 
gobject.TYPE_UINT),
-                  gui.list_store_column(_("CGroup"), gobject.TYPE_STRING),
-                  gui.list_store_column(_("Command Line"), 
gobject.TYPE_STRING))
+                  gui.list_store_column(_("Affinity"), GObject.TYPE_STRING),
+                  gui.list_store_column(_("VolCtxtSwitch"), GObject.TYPE_UINT),
+                  gui.list_store_column(_("NonVolCtxtSwitch"), 
GObject.TYPE_UINT),
+                  gui.list_store_column(_("CGroup"), GObject.TYPE_STRING),
+                  gui.list_store_column(_("Command Line"), 
GObject.TYPE_STRING))
 
        def __init__(self, treeview, ps,
                     show_kthreads, show_uthreads,
@@ -234,45 +234,45 @@ class procview:
                        pass
 
                self.columns = (gui.list_store_column(_("PID")),
-                                               
gui.list_store_column(_("Policy"), gobject.TYPE_STRING),
+                                               
gui.list_store_column(_("Policy"), GObject.TYPE_STRING),
                                                
gui.list_store_column(_("Priority")),
-                                               
gui.list_store_column(_("Affinity"), gobject.TYPE_STRING))
+                                               
gui.list_store_column(_("Affinity"), GObject.TYPE_STRING))
 
                if self.nr_columns==5:
                        ( self.COL_PID, self.COL_POL, self.COL_PRI, 
self.COL_AFF, self.COL_CMDLINE ) = list(range(self.nr_columns))
-                       self.columns = self.columns + 
(gui.list_store_column(_("Command Line"), gobject.TYPE_STRING))
+                       self.columns = self.columns + 
(gui.list_store_column(_("Command Line"), GObject.TYPE_STRING))
 
                elif self.nr_columns==6:
                        ( self.COL_PID, self.COL_POL, self.COL_PRI, 
self.COL_AFF, self.COL_CGROUP, self.COL_CMDLINE ) = list(range(self.nr_columns))
-                       self.columns = self.columns + 
(gui.list_store_column(_("CGroup"), gobject.TYPE_STRING),
-                                                                               
   gui.list_store_column(_("Command Line"), gobject.TYPE_STRING))
+                       self.columns = self.columns + 
(gui.list_store_column(_("CGroup"), GObject.TYPE_STRING),
+                                                                               
   gui.list_store_column(_("Command Line"), GObject.TYPE_STRING))
 
                elif self.nr_columns==7:
                        ( self.COL_PID, self.COL_POL, self.COL_PRI, 
self.COL_AFF, self.COL_VOLCTXT,
                                self.NONVOLCTXT, self.COL_CMDLINE ) = 
list(range(self.nr_columns))
-                       self.columns = self.columns + 
(gui.list_store_column(_("VolCtxtSwitch"), gobject.TYPE_UINT),
-                                                                               
   gui.list_store_column(_("NonVolCtxtSwitch"), gobject.TYPE_UINT),
-                                                                               
   gui.list_store_column(_("Command Line"), gobject.TYPE_STRING))
+                       self.columns = self.columns + 
(gui.list_store_column(_("VolCtxtSwitch"), GObject.TYPE_UINT),
+                                                                               
   gui.list_store_column(_("NonVolCtxtSwitch"), GObject.TYPE_UINT),
+                                                                               
   gui.list_store_column(_("Command Line"), GObject.TYPE_STRING))
 
                elif self.nr_columns==8:
                        ( self.COL_PID, self.COL_POL, self.COL_PRI, 
self.COL_AFF, self.COL_VOLCTXT,
                                self.COL_NONVOLCTXT, self.COL_CGROUP, 
self.COL_CMDLINE ) = list(range(self.nr_columns))
-                       self.columns = self.columns + 
(gui.list_store_column(_("VolCtxtSwitch"), gobject.TYPE_UINT),
-                                                                               
   gui.list_store_column(_("NonVolCtxtSwitch"), gobject.TYPE_UINT),
-                                                                               
   gui.list_store_column(_("CGroup"), gobject.TYPE_STRING),
-                                                                               
   gui.list_store_column(_("Command Line"), gobject.TYPE_STRING))
+                       self.columns = self.columns + 
(gui.list_store_column(_("VolCtxtSwitch"), GObject.TYPE_UINT),
+                                                                               
   gui.list_store_column(_("NonVolCtxtSwitch"), GObject.TYPE_UINT),
+                                                                               
   gui.list_store_column(_("CGroup"), GObject.TYPE_STRING),
+                                                                               
   gui.list_store_column(_("Command Line"), GObject.TYPE_STRING))
 
-               self.tree_store = 
gtk.TreeStore(*gui.generate_list_store_columns_with_attr(self.columns))
+               self.tree_store = 
Gtk.TreeStore(*gui.generate_list_store_columns_with_attr(self.columns))
                self.treeview.set_model(self.tree_store)
 
                # Allow selecting multiple rows
                selection = treeview.get_selection()
-               selection.set_mode(gtk.SELECTION_MULTIPLE)
+               selection.set_mode(Gtk.SelectionMode.MULTIPLE)
 
                # Allow enable drag and drop of rows
-               self.treeview.enable_model_drag_source(gtk.gdk.BUTTON1_MASK,
+               
self.treeview.enable_model_drag_source(Gdk.ModifierType.BUTTON1_MASK,
                                                       gui.DND_TARGETS,
-                                                      gtk.gdk.ACTION_DEFAULT | 
gtk.gdk.ACTION_MOVE)
+                                                      Gdk.DragAction.DEFAULT | 
Gdk.DragAction.MOVE)
                self.treeview.connect("drag_data_get", 
self.on_drag_data_get_data)
                try:
                        self.treeview.connect("query-tooltip", 
self.on_query_tooltip)
@@ -280,15 +280,15 @@ class procview:
                        # old versions of pygtk2+ doesn't have this signal
                        pass
 
-               self.renderer = gtk.CellRendererText()
+               self.renderer = Gtk.CellRendererText()
                for col in range(self.nr_columns):
-                       column = gtk.TreeViewColumn(self.columns[col].name,
+                       column = Gtk.TreeViewColumn(self.columns[col].name,
                                                    self.renderer, text = col)
                        column.add_attribute(self.renderer, "weight",
                                             col + self.nr_columns)
                        column.set_sort_column_id(col)
                        if(col == self.COL_CGROUP):
-                               column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
+                               
column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
                                column.set_fixed_width(130)
                        try:
                                self.treeview.set_tooltip_column(col)
@@ -348,7 +348,7 @@ class procview:
                self.evlist.mmap()
                self.pollfd = self.evlist.get_pollfd()
                for f in self.pollfd:
-                       gobject.io_add_watch(f, gtk.gdk.INPUT_READ, 
self.perf_process_events)
+                       GObject.io_add_watch(f, Gdk.INPUT_READ, 
self.perf_process_events)
                self.perf_counter = {}
 
        def on_query_tooltip(self, treeview, x, y, keyboard_mode, tooltip):
@@ -551,10 +551,10 @@ class procview:
                cmdline = self.tree_store.get_value(row, self.COL_CMDLINE)
                help, title = tuna.kthread_help_plain_text(pid, cmdline)
 
-               dialog = gtk.MessageDialog(None,
-                                          gtk.DIALOG_MODAL | 
gtk.DIALOG_DESTROY_WITH_PARENT,
-                                          gtk.MESSAGE_INFO,
-                                          gtk.BUTTONS_OK, _(help))
+               dialog = Gtk.MessageDialog(None,
+                                          Gtk.DialogFlags.MODAL | 
Gtk.DialogFlags.DESTROY_WITH_PARENT,
+                                          Gtk.MessageType.INFO,
+                                          Gtk.ButtonsType.OK, _(help))
                dialog.set_title(title)
                ret = dialog.run()
                dialog.destroy()
@@ -563,26 +563,26 @@ class procview:
                self.refreshing = not self.refreshing
 
        def save_kthreads_tunings(self, a):
-               dialog = gtk.FileChooserDialog(_("Save As"),
+               dialog = Gtk.FileChooserDialog(_("Save As"),
                                               None,
-                                              gtk.FILE_CHOOSER_ACTION_SAVE,
-                                              (gtk.STOCK_CANCEL, 
gtk.RESPONSE_CANCEL,
-                                               gtk.STOCK_OK, gtk.RESPONSE_OK))
-               dialog.set_default_response(gtk.RESPONSE_OK)
+                                              Gtk.FileChooserAction.SAVE,
+                                              (Gtk.STOCK_CANCEL, 
Gtk.ResponseType.CANCEL,
+                                               Gtk.STOCK_OK, 
Gtk.ResponseType.OK))
+               dialog.set_default_response(Gtk.ResponseType.OK)
 
                try:
                        dialog.set_do_overwrite_confirmation(True)
                except:
                        pass
 
-               filter = gtk.FileFilter()
+               filter = Gtk.FileFilter()
                filter.set_name("rtctl config files")
                filter.add_pattern("*.rtctl")
                filter.add_pattern("*.tuna")
                filter.add_pattern("*rtgroup*")
                dialog.add_filter(filter)
 
-               filter = gtk.FileFilter()
+               filter = Gtk.FileFilter()
                filter.set_name("All files")
                filter.add_pattern("*")
                dialog.add_filter(filter)
@@ -592,7 +592,7 @@ class procview:
                filename = dialog.get_filename()
                dialog.destroy()
 
-               if response != gtk.RESPONSE_OK:
+               if response != Gtk.ResponseType.OK:
                        return
 
                self.refresh()
@@ -600,10 +600,10 @@ class procview:
                tuna.generate_rtgroups(filename, kthreads, self.nr_cpus)
 
                if filename != "/etc/rtgroups":
-                       dialog = gtk.MessageDialog(None,
-                                                  gtk.DIALOG_MODAL | 
gtk.DIALOG_DESTROY_WITH_PARENT,
-                                                  gtk.MESSAGE_INFO,
-                                                  gtk.BUTTONS_YES_NO,
+                       dialog = Gtk.MessageDialog(None,
+                                                  Gtk.DialogFlags.MODAL | 
Gtk.DialogFlags.DESTROY_WITH_PARENT,
+                                                  Gtk.MessageType.INFO,
+                                                  Gtk.ButtonsType.YES_NO,
                                                   "Kernel thread tunings 
saved!\n\n"
                                                   "Now you can use it with 
rtctl:\n\n"
                                                   "rtctl --file %s reset\n\n"
@@ -613,46 +613,46 @@ class procview:
                                                   "Do you want to do that 
now?" % (filename, filename))
                        response = dialog.run()
                        dialog.destroy()
-                       if response == gtk.RESPONSE_YES:
+                       if response == Gtk.ResponseType.YES:
                                filename = "/etc/rtgroups"
                                tuna.generate_rtgroups(filename, kthreads, 
self.nr_cpus)
 
-               dialog = gtk.MessageDialog(None,
-                                          gtk.DIALOG_MODAL | 
gtk.DIALOG_DESTROY_WITH_PARENT,
-                                          gtk.MESSAGE_INFO,
-                                          gtk.BUTTONS_OK,
+               dialog = Gtk.MessageDialog(None,
+                                          Gtk.DialogFlags.MODAL | 
Gtk.DialogFlags.DESTROY_WITH_PARENT,
+                                          Gtk.MessageType.INFO,
+                                          Gtk.ButtonsType.OK,
                                           _("Kernel thread tunings saved to 
%s!") % filename)
                dialog.run()
                dialog.destroy()
 
        def on_processlist_button_press_event(self, treeview, event):
-               if event.type != gtk.gdk.BUTTON_PRESS or event.button != 3:
+               if event.type != Gdk.EventType.BUTTON_PRESS or event.button != 
3:
                        return
 
                self.last_x = int(event.x)
                self.last_y = int(event.y)
 
-               menu = gtk.Menu()
+               menu = Gtk.Menu()
 
-               setattr = gtk.MenuItem(_("_Set process attributes"))
+               setattr = Gtk.MenuItem(_("_Set process attributes"))
                if self.refreshing:
-                       refresh = gtk.MenuItem(_("Sto_p refreshing the process 
list"))
+                       refresh = Gtk.MenuItem(_("Sto_p refreshing the process 
list"))
                else:
-                       refresh = gtk.MenuItem(_("_Refresh the process list"))
+                       refresh = Gtk.MenuItem(_("_Refresh the process list"))
 
                if self.show_kthreads:
-                       kthreads = gtk.MenuItem(_("_Hide kernel threads"))
+                       kthreads = Gtk.MenuItem(_("_Hide kernel threads"))
                else:
-                       kthreads = gtk.MenuItem(_("_Show kernel threads"))
+                       kthreads = Gtk.MenuItem(_("_Show kernel threads"))
 
                if self.show_uthreads:
-                       uthreads = gtk.MenuItem(_("_Hide user threads"))
+                       uthreads = Gtk.MenuItem(_("_Hide user threads"))
                else:
-                       uthreads = gtk.MenuItem(_("_Show user threads"))
+                       uthreads = Gtk.MenuItem(_("_Show user threads"))
 
-               help = gtk.MenuItem(_("_What is this?"))
+               help = Gtk.MenuItem(_("_What is this?"))
 
-               save_kthreads_tunings = gtk.MenuItem(_("_Save kthreads 
tunings"))
+               save_kthreads_tunings = Gtk.MenuItem(_("_Save kthreads 
tunings"))
 
                menu.add(save_kthreads_tunings)
                menu.add(setattr)
diff --git a/tuna/gui/profileview.py b/tuna/gui/profileview.py
index fe670bfca3c7..96ae1ea1bab4 100644
--- a/tuna/gui/profileview.py
+++ b/tuna/gui/profileview.py
@@ -1,5 +1,5 @@
-import pygtk
-import gtk
+import gi
+from gi.repository import Gtk
 
 from tuna import tuna, gui
 
@@ -7,17 +7,17 @@ import os, shutil
 
 class profileview:
        def on_loadProfileButton_clicked(self, button):
-               self.dialog = gtk.FileChooserDialog("Open...", None,
-                       gtk.FILE_CHOOSER_ACTION_OPEN, (gtk.STOCK_CANCEL,
-                       gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK))
-               self.dialog.set_default_response(gtk.RESPONSE_OK)
-               filter = gtk.FileFilter()
+               self.dialog = Gtk.FileChooserDialog("Open...", None,
+                       Gtk.FileChooserAction.OPEN, (Gtk.STOCK_CANCEL,
+                       Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN, 
Gtk.ResponseType.OK))
+               self.dialog.set_default_response(Gtk.ResponseType.OK)
+               filter = Gtk.FileFilter()
                filter.set_name("All files")
                filter.add_pattern("*")
                self.dialog.add_filter(filter)
                self.dialog.set_current_folder(self.config.config["root"])
                self.response = self.dialog.run()
-               if self.response == gtk.RESPONSE_OK:
+               if self.response == Gtk.ResponseType.OK:
                        self.addFile(self.dialog.get_filename())
                        self.setProfileFileList()
                self.dialog.destroy()
@@ -67,14 +67,14 @@ class profileview:
                        self.configs
                        self.configFileCombo
                except AttributeError:
-                       self.config_store = gtk.ListStore(str)
+                       self.config_store = Gtk.ListStore(str)
                        self.configs = self.configFileTree
-                       
self.configFileTree.append_column(gtk.TreeViewColumn('Profile Name', 
gtk.CellRendererText(), text=0))
+                       
self.configFileTree.append_column(Gtk.TreeViewColumn('Profile Name', 
Gtk.CellRendererText(), text=0))
                        self.configHandler = 
self.configs.connect('cursor_changed', self.changeProfile)
                        self.configs.set_model(self.config_store)
-                       self.combo_store = gtk.ListStore(str)
+                       self.combo_store = Gtk.ListStore(str)
                        self.configFileCombo.set_model(self.combo_store)
-                       cell = gtk.CellRendererText()
+                       cell = Gtk.CellRendererText()
                        self.configFileCombo.pack_start(cell, True)
                        self.configFileCombo.add_attribute(cell, "text", 0)
                self.config_store.append([config])
@@ -90,17 +90,17 @@ class profileview:
                        self.profileContentBuffer = 
self.profileContent.get_buffer()
                        buff = 
self.profileContentBuffer.get_text(self.profileContentBuffer.get_start_iter(),self.profileContentBuffer.get_end_iter())
                        if temp != buff:
-                               dialog = gtk.MessageDialog(None,
-                                       gtk.DIALOG_MODAL | 
gtk.DIALOG_DESTROY_WITH_PARENT,
-                                               gtk.MESSAGE_WARNING,
-                                               gtk.BUTTONS_YES_NO,
+                               dialog = Gtk.MessageDialog(None,
+                                       Gtk.DialogFlags.MODAL | 
Gtk.DialogFlags.DESTROY_WITH_PARENT,
+                                               Gtk.MessageType.WARNING,
+                                               Gtk.ButtonsType.YES_NO,
                                                "%s\n\n%s\n%s" % \
                                                (_("Config file was changed!"),
                                                _("All changes will be lost"),
                                                _("Realy continue?"),))
                                ret = dialog.run()
                                dialog.destroy()
-                               if ret == gtk.RESPONSE_NO:
+                               if ret == Gtk.ResponseType.NO:
                                        old = 
self.config.cacheFileName.rfind("/")
                                        old = 
self.config.cacheFileName[old+1:len(self.config.cacheFileName)]
                                        self.set_current_tree_selection(old)
@@ -148,13 +148,13 @@ class profileview:
                        else:
                                self.frame.hide()
                except RuntimeError as e:
-                       dialog = gtk.MessageDialog(None,
-                               gtk.DIALOG_MODAL | 
gtk.DIALOG_DESTROY_WITH_PARENT,
-                               gtk.MESSAGE_WARNING, gtk.BUTTONS_YES_NO,
+                       dialog = Gtk.MessageDialog(None,
+                               Gtk.DialogFlags.MODAL | 
Gtk.DialogFlags.DESTROY_WITH_PARENT,
+                               Gtk.MessageType.WARNING, Gtk.ButtonsType.YES_NO,
                                _("%s\nRun autocorect?") % _(str(e)))
                        dlgret = dialog.run()
                        dialog.destroy()
-                       if dlgret == gtk.RESPONSE_YES:
+                       if dlgret == Gtk.ResponseType.YES:
                                if 'lastfile' in self.config.config:
                                        
self.config.fixConfigFile(self.config.config['root'] + 
self.config.config['lastfile'])
                                        err = 
self.config.checkConfigFile(self.config.config['root'] + 
self.config.config['lastfile'])
@@ -178,39 +178,39 @@ class profileview:
                                path, col, cellx, celly = pthinfo
                                treeview.grab_focus()
                                treeview.set_cursor( path, col, 0)
-                               context = gtk.Menu()
+                               context = Gtk.Menu()
 
-                               item = gtk.ImageMenuItem(_("New profile"))
+                               item = Gtk.ImageMenuItem(_("New profile"))
                                item.connect("activate", self.on_menu_new)
-                               img = gtk.image_new_from_stock(gtk.STOCK_NEW, 
gtk.ICON_SIZE_MENU)
+                               img = Gtk.Image.new_from_stock(Gtk.STOCK_NEW, 
Gtk.IconSize.MENU)
                                img.show()
                                item.set_image(img)
                                context.append(item)
 
-                               item = gtk.ImageMenuItem(_("Rename"))
+                               item = Gtk.ImageMenuItem(_("Rename"))
                                item.connect("activate", self.on_menu_rename)
-                               img = gtk.image_new_from_stock(gtk.STOCK_FILE, 
gtk.ICON_SIZE_MENU)
+                               img = Gtk.Image.new_from_stock(Gtk.STOCK_FILE, 
Gtk.IconSize.MENU)
                                img.show()
                                item.set_image(img)
                                context.append(item)
 
-                               item = gtk.ImageMenuItem(_("Copy"))
+                               item = Gtk.ImageMenuItem(_("Copy"))
                                item.connect("activate", self.on_menu_copy)
-                               img = gtk.image_new_from_stock(gtk.STOCK_COPY, 
gtk.ICON_SIZE_MENU)
+                               img = Gtk.Image.new_from_stock(Gtk.STOCK_COPY, 
Gtk.IconSize.MENU)
                                img.show()
                                item.set_image(img)
                                context.append(item)
 
-                               item = gtk.ImageMenuItem(_("Delete"))
+                               item = Gtk.ImageMenuItem(_("Delete"))
                                item.connect("activate", self.on_menu_delete)
-                               img = 
gtk.image_new_from_stock(gtk.STOCK_DELETE, gtk.ICON_SIZE_MENU)
+                               img = 
Gtk.Image.new_from_stock(Gtk.STOCK_DELETE, Gtk.IconSize.MENU)
                                img.show()
                                item.set_image(img)
                                context.append(item)
 
-                               item = gtk.ImageMenuItem(_("Check"))
+                               item = Gtk.ImageMenuItem(_("Check"))
                                item.connect("activate", self.on_menu_check)
-                               img = 
gtk.image_new_from_stock(gtk.STOCK_SPELL_CHECK, gtk.ICON_SIZE_MENU)
+                               img = 
Gtk.Image.new_from_stock(Gtk.STOCK_SPELL_CHECK, Gtk.IconSize.MENU)
                                img.show()
                                item.set_image(img)
                                context.append(item)
@@ -270,8 +270,8 @@ class profileview:
                        self.show_mbox_warning("%s\n%s" % (_("Config file 
contain errors:"), _(err)))
                        return False
                else:
-                       dialog = gtk.MessageDialog(None, 0, gtk.MESSAGE_INFO,\
-                        gtk.BUTTONS_OK, "%s\n" % (_("Config file looks OK")))
+                       dialog = Gtk.MessageDialog(None, 0, 
Gtk.MessageType.INFO,\
+                        Gtk.ButtonsType.OK, "%s\n" % (_("Config file looks 
OK")))
                        ret = dialog.run()
                        dialog.destroy()
                self.set_current_tree_selection(filename)
@@ -317,13 +317,13 @@ class profileview:
 
        def on_menu_delete(self, widget):
                filename = self.get_current_tree_selection()
-               dialog = gtk.MessageDialog(None,
-                          gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
-                          gtk.MESSAGE_WARNING, gtk.BUTTONS_YES_NO,
+               dialog = Gtk.MessageDialog(None,
+                          Gtk.DialogFlags.MODAL | 
Gtk.DialogFlags.DESTROY_WITH_PARENT,
+                          Gtk.MessageType.WARNING, Gtk.ButtonsType.YES_NO,
                           _("Profile %s will be deleted!\nReally?" % 
(filename)))
                ret = dialog.run()
                dialog.destroy()
-               if ret == gtk.RESPONSE_YES:
+               if ret == Gtk.ResponseType.YES:
                        try:
                                os.unlink(self.config.config['root'] + filename)
                        except OSError as oe:
@@ -340,28 +340,28 @@ class profileview:
                return False
 
        def get_text_dialog(self, message, default=''):
-               d = gtk.MessageDialog(None,
-                       gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
-                       gtk.MESSAGE_QUESTION,
-                       gtk.BUTTONS_OK_CANCEL,
+               d = Gtk.MessageDialog(None,
+                       Gtk.DialogFlags.MODAL | 
Gtk.DialogFlags.DESTROY_WITH_PARENT,
+                       Gtk.MessageType.QUESTION,
+                       Gtk.ButtonsType.OK_CANCEL,
                        message)
-               entry = gtk.Entry()
+               entry = Gtk.Entry()
                entry.set_text(default)
                entry.show()
-               d.vbox.pack_end(entry)
-               entry.connect('activate', lambda _: d.response(gtk.RESPONSE_OK))
-               d.set_default_response(gtk.RESPONSE_OK)
+               d.vbox.pack_end(entry, True, True, 0)
+               entry.connect('activate', lambda _: 
d.response(Gtk.ResponseType.OK))
+               d.set_default_response(Gtk.ResponseType.OK)
                r = d.run()
                text = entry.get_text().decode('utf8')
                d.destroy()
-               if r == gtk.RESPONSE_OK:
+               if r == Gtk.ResponseType.OK:
                        return text
                else:
                        return None
 
        def show_mbox_warning(self, message):
-               dialog = gtk.MessageDialog(None,
-                               gtk.DIALOG_MODAL | 
gtk.DIALOG_DESTROY_WITH_PARENT,
-                               gtk.MESSAGE_WARNING, gtk.BUTTONS_OK, 
_((str(message))))
+               dialog = Gtk.MessageDialog(None,
+                               Gtk.DialogFlags.MODAL | 
Gtk.DialogFlags.DESTROY_WITH_PARENT,
+                               Gtk.MessageType.WARNING, Gtk.ButtonsType.OK, 
_((str(message))))
                ret = dialog.run()
                dialog.destroy()
diff --git a/tuna/gui/util.py b/tuna/gui/util.py
index 9e30ed92bd4c..79c49a221363 100755
--- a/tuna/gui/util.py
+++ b/tuna/gui/util.py
@@ -1,11 +1,11 @@
-import pygtk
-pygtk.require("2.0")
+import gi
+gi.require_version("Gtk", "3.0")
 
 import gobject, gtk, pango, procfs, schedutils
 from tuna import tuna
 
 class list_store_column:
-       def __init__(self, name, type = gobject.TYPE_UINT):
+       def __init__(self, name, type = GObject.TYPE_UINT):
                self.name = name
                self.type = type
 
@@ -13,7 +13,7 @@ def generate_list_store_columns_with_attr(columns):
        for column in columns:
                yield column.type
        for column in columns:
-               yield gobject.TYPE_UINT
+               yield GObject.TYPE_UINT
 
 def set_store_columns(store, row, new_value):
        nr_columns = len(new_value)
@@ -21,9 +21,9 @@ def set_store_columns(store, row, new_value):
                col_weight = col + nr_columns
                cur_value = store.get_value(row, col)
                if cur_value == new_value[col]:
-                       new_weight = pango.WEIGHT_NORMAL
+                       new_weight = Pango.Weight.NORMAL
                else:
-                       new_weight = pango.WEIGHT_BOLD
+                       new_weight = Pango.Weight.BOLD
 
                store.set(row, col, new_value[col], col_weight, new_weight)
 
@@ -44,10 +44,10 @@ def on_affinity_text_changed(self):
                self.affinity_text = new_affinity_text
 
 def invalid_affinity():
-       dialog = gtk.MessageDialog(None,
-                                  gtk.DIALOG_MODAL | 
gtk.DIALOG_DESTROY_WITH_PARENT,
-                                  gtk.MESSAGE_WARNING,
-                                  gtk.BUTTONS_OK,
+       dialog = Gtk.MessageDialog(None,
+                                  Gtk.DialogFlags.MODAL | 
Gtk.DialogFlags.DESTROY_WITH_PARENT,
+                                  Gtk.MessageType.WARNING,
+                                  Gtk.ButtonsType.OK,
                                   _("Invalid affinity, specify a list of 
CPUs!"))
        dialog.run()
        dialog.destroy()
@@ -64,10 +64,10 @@ def thread_set_attributes(pid_info, new_policy, new_prio, 
new_affinity, nr_cpus)
                try:
                        schedutils.set_scheduler(pid, new_policy, new_prio)
                except:
-                       dialog = gtk.MessageDialog(None,
-                                                  gtk.DIALOG_MODAL | 
gtk.DIALOG_DESTROY_WITH_PARENT,
-                                                  gtk.MESSAGE_WARNING,
-                                                  gtk.BUTTONS_OK,
+                       dialog = Gtk.MessageDialog(None,
+                                                  Gtk.DialogFlags.MODAL | 
Gtk.DialogFlags.DESTROY_WITH_PARENT,
+                                                  Gtk.MessageType.WARNING,
+                                                  Gtk.ButtonsType.OK,
                                                   _("Invalid parameters!"))
                        dialog.run()
                        dialog.destroy()
diff --git a/tuna/tuna_gui.py b/tuna/tuna_gui.py
index 008f55b5df35..c57533153ca4 100755
--- a/tuna/tuna_gui.py
+++ b/tuna/tuna_gui.py
@@ -1,9 +1,8 @@
 # -*- python -*-
 # -*- coding: utf-8 -*-
 
-import os
-import procfs
 import sys
+import os
 
 import gi
 gi.require_version("Gtk", "3.0")
@@ -11,7 +10,7 @@ from gi.repository import Gtk
 
 from gi.repository import GObject
 import Gtk.glade
-from gtk import ListStore
+from Gtk import ListStore
 from .gui.cpuview import cpuview
 from .gui.irqview import irqview
 from .gui.procview import procview
@@ -19,6 +18,8 @@ from .gui.commonview import commonview
 from .gui.profileview import profileview
 from .config import Config
 
+import procfs
+
 tuna_glade_dirs = [".", "tuna", "/usr/share/tuna"]
 tuna_glade = None
 
-- 
2.26.2
_______________________________________________
tuna-devel mailing list -- tuna-devel@lists.fedorahosted.org
To unsubscribe send an email to tuna-devel-le...@lists.fedorahosted.org
Fedora Code of Conduct: 
https://docs.fedoraproject.org/en-US/project/code-of-conduct/
List Guidelines: https://fedoraproject.org/wiki/Mailing_list_guidelines
List Archives: 
https://lists.fedorahosted.org/archives/list/tuna-devel@lists.fedorahosted.org

Reply via email to