root/lib/octofuss/packages/packagesAdmin.py @ 313bab594cb442fd8114dded9f53e3b7fac5f0bc

Revision 313bab594cb442fd8114dded9f53e3b7fac5f0bc, 28.5 KB (checked in by iacopo <iacopo@…>, 6 years ago)

Set resizable

git-svn-id:  https://labs.truelite.it/svn/octofuss/trunk@94 5a101938-5c21-0410-9b5a-a83d6f3706a9
  • Property mode set to 100755
Line 
1#!/usr/bin/env python
2#
3#  File: packagesAdmin.py
4#
5#  Copyright (C) 2006 Iacopo Pecchi <iacopo@truelite.it>
6#
7#  This program is free software; you can redistribute it and/or modify
8#  it under the terms of the GNU General Public License as published by
9#  the Free Software Foundation; either version 2 of the License, or
10#  (at your option) any later version.
11#
12# -*- coding: latin-1 -*-
13import re
14import pygtk
15import gtk
16import gobject
17pygtk.require('2.0')
18from packagesParser import *
19from octofuss.error import DbEntry
20from octofuss.cluster import *
21from  packagesUtils import *
22
23
24(
25  COLOR_RED,
26  COLOR_GREEN,
27  COLOR_BLUE
28) = range(3)
29
30(
31  SHAPE_SQUARE,
32  SHAPE_RECTANGLE,
33  SHAPE_OVAL,
34) = range(3)
35
36#   columns
37(
38  COLUMN_NAME,
39  COLUMN_VERSION,
40  COLUMN_SECTION
41) = range(3)
42
43ui_info = \
44'''<ui>
45  <menubar name='MenuBar'>
46    <menu action='FileMenu'>
47      <menuitem action='New'/>
48      <menuitem action='Open'/>
49      <menuitem action='Save'/>
50      <menuitem action='SaveAs'/>
51      <separator/>
52      <menuitem action='Quit'/>
53    </menu>
54    <menu action='PreferencesMenu'>
55    </menu>
56    <menu action='HelpMenu'>
57      <menuitem action='About'/>
58    </menu>
59  </menubar>
60</ui>'''
61
62class PackagesAdmin:
63     
64      def __init__(self, cluster):
65            self.clu = cluster
66            self.db = PackagesUtils() 
67            #self.win = gtk.Window(gtk.WINDOW_TOPLEVEL)
68            #self.win.set_resizable(False)
69            #self.win.set_title("Packages Admin")
70            #try:
71            #     self.win.set_screen(gtk.parent.get_screen())
72            #except AttributeError:
73            #      self.win.connect('destroy', lambda *w: gtk.main_quit())
74            #self.win.set_default_size(1024,620)
75 
76
77
78            self.pack = PackagesParser("./Packages")
79           
80         
81            #Box principale che contiene tutti i widgets
82            self.hboxMain = gtk.HBox(homogeneous=False, spacing=0) 
83 
84     
85            #Box di sinistra che contiene una lista di opzioni ed i bottoni sotto
86            vboxLeft = gtk.VBox(homogeneous=False, spacing=0)       
87            #Box di destra che contiene la lista dei pacchetti e la loro descrizione
88            vboxRight = gtk.VBox(homogeneous=False, spacing=0) 
89
90
91            #Box che contiene i bottoni che andranno in basso a sinistra
92            hbox1Left = gtk.HBox(homogeneous=False, spacing=0) 
93            hbox2Left = gtk.HBox(homogeneous=False, spacing=0)
94           
95
96           
97            #---------------------------------------------------Campo testo che descrive i singoli pacchetti
98            text = gtk.TextBuffer()           
99            text.set_text('Nessun pacchetto selezionato')
100            view1 = gtk.TextView(text);
101            view1.set_editable(False)
102
103            swText = gtk.ScrolledWindow()
104            swText.set_shadow_type(gtk.SHADOW_ETCHED_IN)
105            swText.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
106            swText.add(view1)
107            swText.set_size_request(800,300)
108           
109
110            #---------------------------------------------------Lista che mostra i pacchetti all'interno del file Packages
111            # Viene inserita in alto nel box verticale di destra
112            sw = gtk.ScrolledWindow()
113            sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
114            sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
115     
116            # create model
117            model   = self.__create_model()
118     
119            # create tree view
120            treeview = gtk.TreeView(model)
121            treeview.set_rules_hint(True)
122            treeview.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
123            treeview.connect("cursor-changed",self.cursor_changed, view1)
124
125            self.__add_columns(treeview)
126
127            sw.add(treeview)
128            sw.set_size_request(800,300)
129            #----------------------------------------------------Colonna unica che permette all'utente di selezionare un sottoinsieme di pacchetti
130            # Viene inserita in alto nel box verticale di sinistra
131            # L'evento cursor-change provoca un ridisegnamento della lista di pacchetti a seconda della riga selezionata
132            swType = gtk.ScrolledWindow()
133            swType.set_size_request(220,300)
134            swType.set_shadow_type(gtk.SHADOW_ETCHED_IN)
135            swType.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
136     
137            # create model
138            model2   = self.__create_model2()
139     
140            # create tree view
141            treeview2 = gtk.TreeView(model2)
142            treeview2.set_size_request(220,400)
143            treeview2.set_rules_hint(True)
144            treeview2.get_selection().set_mode(gtk.SELECTION_SINGLE)
145            treeview2.connect("cursor-changed",self.cursor_changed2, treeview)
146
147            self.__add_columns2(treeview2)
148
149            swType.add(treeview2)
150
151            #---------------------------------------------------Ricerca in base al testo inserito nel nome dei pachetti
152            label = gtk.Label()
153            label2 = gtk.Label()
154            label.set_markup("Search in package names:          ")
155            label.set_justify(gtk.JUSTIFY_LEFT)
156            label2.set_justify(gtk.JUSTIFY_LEFT)
157            label2.set_markup("Search in package descriptions:")
158
159
160            vboxSearch = gtk.VBox(homogeneous=False, spacing=0)   
161            vboxSearch.pack_start(label,False,False,0)
162            vboxSearch2 = gtk.VBox(homogeneous=False, spacing=0)   
163            vboxSearch2.pack_start(label2,False,False,0)
164
165            #hbox2Left.pack_start(label, False, False, 0)
166
167            # Create our entry
168            entry = gtk.Entry()
169            #entryTmp = gtk.Entry()
170            entry2 = gtk.Entry()
171            #entryTmp.connect("changed", self.changed, treeview, entry)
172            entry.connect("changed",self.insert,treeview, entry)
173            #entry.connect("backspace",self.backspace,treeview)
174            entry2.connect("changed",self.insert2,treeview, entry2)
175            #entry2.connect("backspace",self.backspace2,treeview)
176 
177            # Create the completion object
178            ##completion = gtk.EntryCompletion()
179            #completion.set_popup_single_match(True)
180            #completion.set_popup_set_width(False)
181           
182            ##completion.set_inline_completion(True)
183            # Assign the completion to the entry
184            ##entry.set_completion(completion)
185
186           
187            # Create a tree model and use it as the completion model
188            ##completion_model = self.__create_model()
189            ##completion.set_model(completion_model)
190     
191
192            # Use model column 0 as the text column
193            ##completion.set_text_column(0)
194            ##completion.connect("match-selected",self.update_list,treeview) 
195            ##completion.connect("insert-prefix",self.update_list2,treeview) 
196     
197            vboxSearch.pack_start(entry,False,False,0)
198
199            vboxSearch2.pack_start(entry2,False,False,0)
200            #vboxSearch2.pack_end(entryTmp,False,False,0)
201
202            vboxSearch.show()     
203            vboxSearch2.show()
204           
205           
206            #----------------------------------------------------Bottoni installazione
207            #si passa alla callback la lista dei pacchetti "treeview" per fargli prendere il selezionato
208            butInstall = gtk.Button("Install Package")
209            butInstall.set_size_request(100,50)
210            butInstall.connect("clicked", self.install_clicked, treeview)
211            butRemove =  gtk.Button("Remove")
212            butRemove.set_size_request(100,50)
213
214            butRemove.connect("clicked", self.remove_clicked, treeview)
215                 
216
217
218
219            #-----------------------------------------------
220            #hbox2Left.pack_start(vboxSearch, False, False, 3)
221            #hbox2Left.show()
222            vboxSearch.show_all()
223            vboxLeft.pack_start(swType,True,True,3)
224            #vboxLeft.pack_end(butRemove,False,False,3)
225            vboxLeft.pack_end(butInstall,False,False,5)
226            vboxLeft.pack_end(vboxSearch2,False,False,5)
227            vboxLeft.pack_end(vboxSearch,False,False,3)
228
229            vboxRight.pack_start(sw,False,False,3) 
230            vboxRight.pack_end(swText,False,False,3)
231           
232            #vboxLeft.pack_start(listPackages,False, False, 0 )
233            #vboxleft.pack_start(hboxPackages,False, False,0)
234            #vboxRight.set_size_request(800,400)
235            vboxRight.show()
236            vboxLeft.show()
237           
238
239           
240
241            #Aggiungo i box verticali al box orizzontale
242            self.hboxMain.pack_start(vboxLeft,False,False,3)
243            self.hboxMain.pack_end(vboxRight,False,False,3)
244            #vboxAll = gtk.VBox()
245            #hboxMainMenu = gtk.HBox()
246            #bar = self.create_menu()
247
248            #hboxMainMenu.pack_start(bar,False,False,0)
249            #vboxAll.pack_start(hboxMainMenu,False,False,0)
250            #vboxAll.pack_start(hboxMain,False,False,0)
251
252            #self.win.add(self.hboxMain)
253            #self.win.show_all()
254     
255      def get_container(self):
256            """ Return the container that show the package administration panel """
257            return self.hboxMain
258           
259      def create_menu(self):
260            merge = gtk.UIManager()
261            self.win.set_data("ui-manager", merge)
262            merge.insert_action_group(self.__create_action_group(), 0)
263            self.win.add_accel_group(merge.get_accel_group())
264
265            try:
266                  mergeid = merge.add_ui_from_string(ui_info)
267            except gobject.GError, msg:
268                  print "building menus failed: %s" % msg
269            bar = merge.get_widget("/MenuBar")
270            bar.show()
271            return bar
272
273      def activate_action(self, action):
274            dialog = gtk.MessageDialog(self.win, 0, gtk.MESSAGE_INFO, gtk.BUTTONS_YES_NO," Exit? " )
275            dialog.show()
276
277            # Close dialog on user response
278
279            resp = dialog.run()
280            if resp == -8:
281                  dialog.destroy()
282                  self.win.destroy() 
283            if resp == -9:
284                  dialog.destroy()
285           
286           
287      def resp(self,response):
288            print response
289
290
291      def activate_about(self, action):
292            dialog = gtk.AboutDialog()
293            dialog.set_name("Octofuss Cluster Packages Installation")
294            dialog.set_website("http://www.octofuss.org./")
295            ## Close dialog on user response
296            dialog.connect ("response", lambda d, r: d.destroy())
297            dialog.show()
298
299
300      def __create_action_group(self):
301            # GtkActionEntry
302            entries = (
303            ( "FileMenu", None, "_File" ),               # name, stock id, label
304            ( "PreferencesMenu", None, "_Preferences" ), # name, stock id, label
305            #( "ColorMenu", None, "_Color"  ),            # name, stock id, label
306            #( "ShapeMenu", None, "_Shape" ),             # name, stock id, label
307            ( "HelpMenu", None, "_Help" ),               # name, stock id, label
308            ( "New", gtk.STOCK_NEW,                      # name, stock id
309            "_New", "<control>N",                      # label, accelerator
310            "Create a new file",                       # tooltip
311            self.activate_action ),
312            ( "Open", gtk.STOCK_OPEN,                    # name, stock id
313            "_Open","<control>O",                      # label, accelerator
314            "Open a file",                             # tooltip
315            self.activate_action ),
316            ( "Save", gtk.STOCK_SAVE,                    # name, stock id
317            "_Save","<control>S",                      # label, accelerator
318            "Save current file",                       # tooltip
319            self.activate_action ),
320            ( "SaveAs", gtk.STOCK_SAVE,                  # name, stock id
321            "Save _As...", None,                       # label, accelerator
322            "Save to a file",                          # tooltip
323            self.activate_action ),
324            ( "Quit", gtk.STOCK_QUIT,                    # name, stock id
325            "_Quit", "<control>Q",                     # label, accelerator
326            "Quit",                                    # tooltip
327            self.activate_action ),
328            ( "About", None,                             # name, stock id
329            "_About", "<control>A",                    # label, accelerator
330            "About",                                   # tooltip
331            self.activate_about ),
332            ( "Logo", "demo-gtk-logo",                   # name, stock id
333             None, None,                              # label, accelerator
334            "GTK+",                                    # tooltip
335            self.activate_action ),
336            );
337
338            # Create the menubar and toolbar
339            action_group = gtk.ActionGroup("AppWindowActions")
340            action_group.add_actions(entries)
341
342            return action_group
343
344
345      def activate_radio_action(self, action, current):
346            active = current.get_active()
347            value = current.get_current_value()
348
349            if active:
350                  dialog = gtk.MessageDialog(self, gtk.DIALOG_DESTROY_WITH_PARENT,
351                      gtk.MESSAGE_INFO, gtk.BUTTONS_CLOSE,
352                      "You activated radio action: \"%s\" of type \"%s\".\nCurrent value: %d" %
353                      (current.get_name(), type(current), value))
354
355            # Close dialog on user response
356            dialog.connect("response", lambda d, r: d.destroy())
357            dialog.show()
358
359      def update_statusbar(self, buffer):
360            # clear any previous message, underflow is allowed
361            self.statusbar.pop(0)
362            count = buffer.get_char_count()
363            iter = buffer.get_iter_at_mark(buffer.get_insert())
364            row = iter.get_line()
365            col = iter.get_line_offset()
366            self.statusbar.push(0,
367            'Cursor at row %d column %d - %d chars in document' % (row, col, count))
368
369      def update_resize_grip(self, widget, event):
370            mask = gtk.gdk.WINDOW_STATE_MAXIMIZED | gtk.gdk.WINDOW_STATE_FULLSCREEN
371            if (event.changed_mask & mask):
372                  self.statusbar.set_has_resize_grip(not (event.new_window_state & mask))
373
374      def __create_model(self):
375
376            # create list store
377            model = gtk.ListStore(
378            gobject.TYPE_STRING,
379            gobject.TYPE_STRING,
380            gobject.TYPE_STRING
381            )
382            packages = self.pack.getAllPackages()
383            sortKeyList = sorted(packages.keys())
384            # add items
385            for item in sortKeyList:
386                  iter = model.append()
387                  model.set (iter,
388                  COLUMN_NAME, packages[item]['Package'],
389                  COLUMN_VERSION, packages[item]['Version'],
390                  COLUMN_SECTION, packages[item]['Priority']
391                 )
392            return model
393
394      def __create_model2(self):
395
396            # create list store
397            model = gtk.ListStore(
398            gobject.TYPE_STRING,
399            )
400
401            packages = self.pack.getAllPackages()
402           
403            # add items
404            sections = self.pack.sections()
405
406            iter = model.append()
407            model.set(iter, 0,"TUTTI")
408            for sec in sections:
409                  iter = model.append()
410                  model.set (iter, 0, sec )
411
412
413            return model
414
415      def __add_columns(self, treeview):
416            model = treeview.get_model()
417            # Name column
418            renderer = gtk.CellRendererText()
419            #renderer.connect("edited", self.on_cell_edited, model)
420            renderer.set_data("column", COLUMN_NAME)
421
422            column = gtk.TreeViewColumn("Name", renderer, text=COLUMN_NAME)
423            #column.set_sort_order(gtk.SORT_ASCENDING) 
424            #column.set_sort_column_id(COLUMN_NAME)
425
426            treeview.append_column(column)
427
428            # Version column
429            renderer = gtk.CellRendererText()
430            #renderer.connect("edited", self.on_cell_edited, model)
431            renderer.set_data("column", COLUMN_VERSION)
432
433            column = gtk.TreeViewColumn("Version", renderer, text=COLUMN_VERSION)
434            treeview.append_column(column)
435
436            # Section column
437            renderer = gtk.CellRendererText()
438            #renderer.connect("edited", self.on_cell_edited, model)
439            renderer.set_data("column", COLUMN_SECTION)
440
441            column = gtk.TreeViewColumn("Priority", renderer, text=COLUMN_SECTION)
442            treeview.append_column(column)
443
444
445      def __add_columns2(self, treeview):
446            model = treeview.get_model()
447            # Selection column
448            renderer = gtk.CellRendererText()
449            renderer.set_data("column", 0)
450
451            column = gtk.TreeViewColumn("Sections", renderer, text=0)
452            #column.set_sort_column_id(0)
453
454            treeview.append_column(column)
455
456
457      def on_add_item_clicked(self, button, model):
458            new_item = [0, "Description here", True]
459            articles.append(new_item)
460            iter = model.append()
461            model.set (iter,
462                  COLUMN_NUMBER, new_item[COLUMN_NUMBER],
463                  COLUMN_PRODUCT, new_item[COLUMN_PRODUCT],
464                  COLUMN_EDITABLE, new_item[COLUMN_EDITABLE]
465            )
466
467      def cursor_changed(self, treeview, textViewText ):
468            buffer = gtk.TextBuffer()
469           
470            #Stampa la descrizione del pacchetto selezionato
471            treeSelection = treeview.get_selection()
472            selections = treeSelection.get_selected_rows()
473            numRows = treeSelection.count_selected_rows()
474            try:
475                  numSel = selections[1][0][0]
476            except IndexError:
477                  print "You must select a valid row!"
478                  return
479                             
480            name= selections[0][numSel][COLUMN_NAME]
481                       
482           
483            package = self.pack.findPackage(name)
484            packageDescription = '\n'
485            packageDescription += "Package: %s" %  package['Package']
486            packageDescription += '\n'
487            packageDescription += "Priority: %s" %  package['Priority']
488            packageDescription += '\n'
489            packageDescription += "Section: %s" %  package['Section']
490            packageDescription += '\n'
491            packageDescription += "Installed-Size: %s" %  package['Installed-Size']
492            packageDescription += '\n'
493            packageDescription += "Maintainer: %s" %  package['Maintainer']
494            packageDescription += '\n'
495            packageDescription += "Architecture: %s" %  package['Architecture']
496            packageDescription += '\n'
497            packageDescription += "Version: %s" %  package['Version']
498            packageDescription += '\n'
499            if package.has_key('Depends'):
500                  packageDescription += "Depends: %s" %  package['Depends']
501                  packageDescription += '\n'
502            packageDescription += "Filename: %s" %  package['Filename']
503            packageDescription += '\n'
504            packageDescription += "Size: %s" %  package['Size']
505            packageDescription += '\n'
506            packageDescription += "MD5sum: %s" %  package['MD5sum']
507            packageDescription += '\n'
508            packageDescription += "SHA1: %s" %  package['SHA1']
509            packageDescription += '\n'
510            packageDescription += "SHA256: %s" %  package['SHA256']
511            packageDescription += '\n'
512            packageDescription += "Description: %s" %  package['Description']
513
514            buffer.set_text(packageDescription)
515            textViewText.set_buffer(buffer)
516            textViewText.show()
517
518      def cursor_changed2(self, treeviewEventGen, treeViewToUpdate ):
519            buffer = gtk.TextBuffer()
520           
521            #Stampa la descrizione del pacchetto selezionato
522            treeSelection = treeviewEventGen.get_selection()
523            selection = treeSelection.get_selected()
524           
525            modelTreeView = treeviewEventGen.get_model()
526            num = int(modelTreeView.get_string_from_iter(selection[1]))
527
528
529           
530
531             # create list store
532
533            model = gtk.ListStore(
534            gobject.TYPE_STRING,
535            gobject.TYPE_STRING,
536            gobject.TYPE_STRING
537            )
538
539            packages = self.pack.bySection(selection[0][num][0])
540            if num == 0:
541                  # create list store
542                  model = gtk.ListStore(
543                  gobject.TYPE_STRING,
544                  gobject.TYPE_STRING,
545                  gobject.TYPE_STRING
546                  )
547                  packages = self.pack.getAllPackages()
548                  sortKeyList = sorted(packages.keys())
549                  # add items
550                  for item in sortKeyList:
551                        iter = model.append()
552                        model.set (iter,
553                        COLUMN_NAME, packages[item]['Package'],
554                        COLUMN_VERSION, packages[item]['Version'],
555                        COLUMN_SECTION, packages[item]['Priority']
556                       )
557                  treeViewToUpdate.set_model(model)
558                  treeViewToUpdate.show()
559            else:
560                  sort = sorted(packages.keys())
561                  # add items
562                  for item in sort:
563                        iter = model.append()
564
565                        model.set (iter,
566                        COLUMN_NAME, packages[item]['Package'],
567                        COLUMN_VERSION, packages[item]['Version'],
568                        COLUMN_SECTION, packages[item]['Priority']
569                       )
570                  treeViewToUpdate.set_model(model)
571                  treeViewToUpdate.show()
572
573
574
575      def update_list(self, completion, model, iter, treeview):
576            treeview.set_model(model)
577            treeview.show()
578
579      def update_list2(self, completion, prefix, treeview):
580             # create list store
581
582            model = gtk.ListStore(
583            gobject.TYPE_STRING,
584            gobject.TYPE_STRING,
585            gobject.TYPE_STRING
586            )
587
588            packages = self.pack.byKeyword(completion.get_entry().get_text())
589            sort = sorted(packages.keys())
590            # add items
591            for item in sort:
592                  iter = model.append()
593
594                  model.set (iter,
595                  COLUMN_NAME, packages[item]['Package'],
596                  COLUMN_VERSION, packages[item]['Version'],
597                  COLUMN_SECTION, packages[item]['Section']
598                 )
599            treeview.set_model(model)
600            treeview.show()
601           
602   
603      def backspace(self, entry,treeview):
604             # create list store
605
606            model = gtk.ListStore(
607            gobject.TYPE_STRING,
608            gobject.TYPE_STRING,
609            gobject.TYPE_STRING
610            )
611
612            packages = self.pack.byKeyword(entry.get_text())
613            sort = sorted(packages.keys())
614            # add items
615            for item in sort:
616                  iter = model.append()
617
618                  model.set (iter,
619                  COLUMN_NAME, packages[item]['Package'],
620                  COLUMN_VERSION, packages[item]['Version'],
621                  COLUMN_SECTION, packages[item]['Priority']
622                 )
623            treeview.set_model(model)
624            treeview.show()
625
626      def changed(self , editable, treeview, entry):
627            print editable.get_chars(0,-1)
628
629      def insert(self, editable, treeview, entry):
630             # create list store
631            model = gtk.ListStore(
632            gobject.TYPE_STRING,
633            gobject.TYPE_STRING,
634            gobject.TYPE_STRING
635            )
636
637            packages = self.pack.byKeyword(editable.get_chars(0,-1))
638            sort = sorted(packages.keys())
639            # add items
640            for item in sort:
641                  iter = model.append()
642
643                  model.set (iter,
644                  COLUMN_NAME, packages[item]['Package'],
645                  COLUMN_VERSION, packages[item]['Version'],
646                  COLUMN_SECTION, packages[item]['Priority']
647                 )
648            treeview.set_model(model)
649            treeview.show()
650
651      def backspace2(self, entry,treeview):
652             # create list store
653
654            model = gtk.ListStore(
655            gobject.TYPE_STRING,
656            gobject.TYPE_STRING,
657            gobject.TYPE_STRING
658            )
659
660            packages = self.pack.byDescription(entry.get_text())
661            sort = sorted(packages.keys())
662            # add items
663            for item in sort:
664                  iter = model.append()
665
666                  model.set (iter,
667                  COLUMN_NAME, packages[item]['Package'],
668                  COLUMN_VERSION, packages[item]['Version'],
669                  COLUMN_SECTION, packages[item]['Priority']
670                 )
671            treeview.set_model(model)
672            treeview.show()
673
674
675
676      def insert2(self, editable, treeview, entry):
677             # create list store
678
679            model = gtk.ListStore(
680            gobject.TYPE_STRING,
681            gobject.TYPE_STRING,
682            gobject.TYPE_STRING
683            )
684
685            packages = self.pack.byDescription(editable.get_chars(0,-1))
686            sort = sorted(packages.keys())
687            # add items
688            for item in sort:
689                  iter = model.append()
690
691                  model.set (iter,
692                  COLUMN_NAME, packages[item]['Package'],
693                  COLUMN_VERSION, packages[item]['Version'],
694                  COLUMN_SECTION, packages[item]['Priority']
695                 )
696            treeview.set_model(model)
697            treeview.show()
698
699      def sortDictValues(self,adict):
700            """ sort the packages dictionary """
701            dict = {}
702            dict =  [ adict[key] for key in sorted(adict.keys()) ] 
703            print dict.keys()
704            return dict
705
706      def sortDictValues2(self,adict):
707            keys = adict.keys()
708            keys.sort()
709            return map(adict.get, keys)
710
711      def install_clicked(self, button, treeview):
712            try:
713                  treeSelection = treeview.get_selection()
714                  selections = treeSelection.get_selected_rows()
715                  numRows = treeSelection.count_selected_rows()
716                  if numRows == 0:
717                        self.showDialog("No package selected!",gtk.MESSAGE_INFO)
718                        return
719                  for i in range(numRows):
720                        numSel = selections[1][i][0]
721                        self.db.insert_package(selections[0][numSel][COLUMN_NAME], self.clu)
722                  if numRows > 1:
723                        self.showDialog("Packages added to installation queue.",gtk.MESSAGE_INFO)
724                  else:
725                        self.showDialog("Package added to installation queue.",gtk.MESSAGE_INFO)
726            except DbEntry:
727                  self.showDialog("Error: package already present.",gtk.MESSAGE_WARNING)
728           
729                             
730
731      def remove_clicked(self,button, treeview):
732            print "Da implementare"
733     
734      def showDialog(self, message, type):
735            dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,type, gtk.BUTTONS_OK, message)
736            dialog.run()
737            dialog.destroy()     
738
739      """     
740      def showDialogInstallation(self,packageList):
741            dialog = gtk.Dialog("Packages installation")
742            try:
743                  dialog.set_screen(self.win.get_screen())
744            except AttributeError:
745                  dialog.connect('destroy', lambda *w: gtk.main_quit())
746            dialog.connect("response", lambda d, r: d.destroy())
747            dialog.set_resizable(False)
748
749            vbox = gtk.VBox(False, 5)
750            dialog.vbox.pack_start(vbox, True, True, 0)
751            vbox.set_border_width(5)
752
753            label = gtk.Label()
754            label.set_markup("Packages installation")
755            vbox.pack_start(label, False, False, 0)
756
757            # Create the expander
758            expander = gtk.Expander("Installation done")
759            vbox.pack_start(expander, False, False, 0)
760
761            # The Label for the expander
762            label = gtk.Label("ciao")       
763            label2= gtk.Label("Mondo")
764            expander.add(label)
765
766            dialog.show_all()
767      """
768
769
770
771def main():
772      c = Cluster()
773      host1 = Host("iacopopecchi")
774      c.add_host(host1)
775      pack = PackagesAdmin(c)
776      win = gtk.Window(gtk.WINDOW_TOPLEVEL)
777      win.set_resizable(True)
778      win.set_title("Packages Admin")
779      try:
780           win.set_screen(gtk.parent.get_screen())
781      except AttributeError:
782           win.connect('destroy', lambda *w: gtk.main_quit())
783      win.set_default_size(1024,620)
784      win.add(pack.get_container())
785      win.show_all()     
786      gtk.main()
787
788if __name__ == '__main__':
789      main()
790
Note: See TracBrowser for help on using the browser.