root/lib/octofuss/packages/__init__.py @ 1b199fe83ee128f0fb335fc1f0baca893dac8f82

Revision 1b199fe83ee128f0fb335fc1f0baca893dac8f82, 27.4 KB (checked in by cgabriel <cgabriel@…>, 6 years ago)

code & names cleanup

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