root/trunk/umit/inventory/Viewer.py @ 4338

Revision 4338, 29.1 kB (checked in by gpolo, 4 years ago)

Fixed old references to the documentation.
Line 
1# Copyright (C) 2007 Adriano Monteiro Marques
2#
3# Authors: Guilherme Polo <ggpolo@gmail.com>
4#
5# This program is free software; you can redistribute it and/or modify
6# it under the terms of the GNU General Public License as published by
7# the Free Software Foundation; either version 2 of the License, or
8# (at your option) any later version.
9#
10# This program is distributed in the hope that it will be useful,
11# but WITHOUT ANY WARRANTY; without even the implied warranty of
12# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13# GNU General Public License for more details.
14#
15# You should have received a copy of the GNU General Public License
16# along with this program; if not, write to the Free Software
17# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
18# USA
19
20"""
21Inventories Viewer main window.
22"""
23
24import os
25import gtk
26import gobject
27import webbrowser
28
29from higwidgets.higwindows import HIGMainWindow
30from higwidgets.hignotebooks import HIGNotebook, HIGAnimatedTabLabel
31from higwidgets.higscrollers import HIGScrolledWindow
32from higwidgets.higboxes import HIGHBox
33
34from umit.core.I18N import _
35from umit.core.Paths import Path
36from umit.core.DataDecay import get_decays
37from umit.core.Utils import open_url_as
38
39from umit.db.Retrieve import ConnectInventoryDB
40from umit.db.Search import SearchDB
41
42from umit.gui.BugReport import BugReport
43from umit.gui.SchedulerControl import SchedControl
44
45from umit.inventory.StartupSettings import startup_options
46from umit.inventory.NewInventory import NewInventory
47from umit.inventory.SearchBar import SearchBar
48from umit.inventory.ChangesList import ChangesList
49from umit.inventory.ChangesDiff import ChangesDiff
50from umit.inventory.InventoryTree import InventoryTree
51from umit.inventory.Timeline import TLHolder
52from umit.inventory.DataRemoval import ConfigureDataRemoval, RemoveOldData
53from umit.inventory.SchedulerLog import SchedLog
54from umit.inventory.SettingsWin import NISettings
55from umit.inventory.About import About
56from umit.inventory.InventoryException import NoInventory
57from umit.inventory.Utils import append_s
58
59
60umitdb = Path.umitdb_ng
61inventory_info = _("Info")
62
63class InventoryNB(gtk.Notebook):
64    """
65    Inventory Notebook for each Inventory.
66    """
67
68    def __init__(self, daddy):
69        gtk.Notebook.__init__(self)
70        self.set_scrollable(True)
71        self.popup_enable()
72
73        self.daddy = daddy
74        self.pages = [ ]
75
76        self.__layout()
77
78
79    def append_inv(self, title="Info", box=None):
80        """
81        Add info page.
82        """
83        if self.page_exists(title):
84            return
85
86        custom_title = self.__create_custom_title(title, box)
87        box.show()
88        custom_title.show()
89        self.append_page(box, custom_title)
90        self.pages.append(title)
91
92        self.__layout()
93
94
95    def append_host(self, host_addr, box):
96        """
97        Add host page.
98        """
99        if self.page_exists(host_addr):
100            return
101
102        custom_title = self.__create_custom_title(host_addr, box)
103        box.show()
104        custom_title.show()
105        self.append_page(box, custom_title)
106        self.pages.append(host_addr)
107
108        self.__layout()
109
110
111    def page_exists(self, pagetitle):
112        """
113        Check if there is a page with pagetitle in this notebook.
114        """
115        if pagetitle in self.pages:
116            return True
117
118        return False
119
120
121    def remove_page(self, button, page, text):
122        """
123        Remove a page from notebook and from self.pages
124        """
125        del self.pages[self.pages.index(text)]
126        self.remove(page)
127
128        if not len(self.pages): # last page in this inventory was just removed
129            self.daddy._delete_inventory_page() # delete notebook
130
131
132    def __add_close_icon_to_button(self, button):
133        """
134        Adds a close image to the page title close button.
135        """
136        image = gtk.Image()
137        image.set_from_stock(gtk.STOCK_CLOSE, gtk.ICON_SIZE_MENU)
138        image.show()
139
140        gtk.Button.set_relief(button, gtk.RELIEF_NONE)
141        settings = gtk.Widget.get_settings(button)
142
143        (w,h) = gtk.icon_size_lookup_for_settings(settings, gtk.ICON_SIZE_MENU)
144
145        gtk.Widget.set_size_request(button, w + 4, h + 4)
146
147        icon_hbox = gtk.HBox(False, 0)
148        icon_hbox.pack_start(image, True, False, 0)
149        icon_hbox.show()
150
151        button.add(icon_hbox)
152
153
154    def __create_custom_title(self, title, widget):
155        """
156        Creates a title with close button.
157        """
158        title_eb = gtk.EventBox()
159
160        label = gtk.Label(title)
161        label.show()
162
163        title_hbox = gtk.HBox(False)
164        title_hbox.pack_start(label, False, False, 0)
165
166        title_eb.add(title_hbox)
167
168        if self.daddy.invnb_close_btn:
169            button = gtk.Button()
170            button.connect('clicked', self.remove_page, widget, title)
171            button.show()
172
173            self.__add_close_icon_to_button(button)
174            title_hbox.pack_end(button, False, False, 0)
175
176        title_hbox.show()
177
178        return title_eb
179
180
181    def __layout(self):
182        """
183        Update notebook.
184        """
185        self.show()
186
187
188class InventoryViewer(HIGMainWindow):
189    """
190    UMIT Network Inventory, Main Window.
191    """
192
193    def __init__(self, daddy=None):
194        HIGMainWindow.__init__(self)
195
196        self.daddy = daddy
197
198        self.tip_timer = -1
199        self.main_accel_group = gtk.AccelGroup()
200        self.add_accel_group(self.main_accel_group)
201
202        self.viewernb = HIGNotebook()
203
204        self.invsearch = SearchDB(umitdb)
205        self.invdb = ConnectInventoryDB(umitdb)
206        self.invtree = InventoryTree(self)
207        self.invnb = HIGNotebook()
208        self.invnb_close_btn = startup_options()["tabs_close_btn"]
209        self.invnbpages_titles = [ ]
210        self.invnbpages_objects = [ ]
211
212        # timeline tab
213        self.timeline = TLHolder()
214
215        # statusbars
216        self.std_statusbar = gtk.Statusbar()
217        self.std_sb = self.std_statusbar.get_context_id("stdbar")
218        self._write_statusbar("                              ")
219
220        self.tip_statusbar = gtk.Statusbar()
221        self.tip_statusbar.set_has_resize_grip(False)
222        self.tip_sb = self.tip_statusbar.get_context_id("tipbar")
223        self.write_tips = startup_options()["tips"]
224
225        # timer for checking updates
226        self.db_stat = os.stat(umitdb).st_mtime
227        self.schema_stat = os.stat(Path.sched_schemas).st_mtime
228        self.timer_updater = gobject.timeout_add(4200, # nice number
229            self.__check_for_updates)
230
231        # gui scheduler controller
232        self.schedctrl = SchedControl(self)
233
234
235        self.inventories = self.invtree.fill_tree()
236        self._create_ui_manager()
237        self.__set_props()
238        self.__do_layout()
239
240        self.connect('inventory-activated', self._inventory_activated)
241        self.connect('delete-event', self._exit_ni)
242        self.connect('realize', self.on_realize)
243
244
245    def on_realize(self, event):
246        """
247        After realizing, change to first page in main notebook (Historic page).
248        """
249        self.viewernb.set_current_page(0)
250
251
252    def _close_current_hosttab(self, event):
253        """
254        Closes current active Host tab.
255        """
256        holder = self.invnb.get_nth_page(self.invnb.get_current_page())
257        if holder:
258            title = self.invnb.get_tab_label_text(holder)
259            p = self.invnbpages_objects[self.invnbpages_titles.index(title)]
260
261            if len(p.pages):
262                tab_label = p.pages[p.get_current_page()]
263                content = p.get_nth_page(p.get_current_page())
264                p.remove_page(None, content, tab_label)
265
266
267    def _close_current_invtab(self, event):
268        """
269        Closes current active inventory notebook.
270        """
271        holder = self.invnb.get_nth_page(self.invnb.get_current_page())
272        if holder:
273            label = self.invnb.get_tab_label_text(holder)
274            del_index = self.invnbpages_titles.index(label)
275
276            page = self.invnbpages_objects[del_index]
277            for p in xrange(page.get_n_pages()-1):
278                tab_label = page.pages[p]
279                content = page.get_nth_page(p)
280                page.remove_page(None, content, tab_label)
281            self._delete_inventory_page()
282
283
284    def _delete_inventory_page(self):
285        """
286        Removed last page from an Inventory notebook, now remove the Inventory
287        notebook.
288        """
289        cur_page = self.invnb.get_current_page()
290        page = self.invnb.get_nth_page(cur_page)
291        page_label = self.invnb.get_tab_label_text(page)
292        del_index = self.invnbpages_titles.index(page_label)
293        del self.invnbpages_titles[del_index]
294        del self.invnbpages_objects[del_index]
295
296        self.invnb.remove_page(cur_page)
297
298
299    def _inventory_activated(self, event, data):
300        """
301        Activated some item on Inventory tree.
302        """
303        if not data['host_addr']: # empty inventory was selected
304            # clicked on Inventory title, dont do nothing
305            return
306
307        title = data["root"] # inventory name
308
309        # check if activated inventory isnt open already
310        if not title in self.invnbpages_titles:
311            # create new notebook to hold this Inventory
312            newinvnb = InventoryNB(self)
313            self.invnb.append_page(newinvnb, gtk.Label(title))
314
315            self.invnbpages_titles.append(title)
316            self.invnbpages_objects.append(newinvnb)
317
318            # check if a host was activated
319            if data["host_addr"][0] != inventory_info:
320                box = self._load_inventory_host_data(title,
321                    data["host_addr"][1])
322                newinvnb.append_host(data["host_addr"][0], box)
323            else:
324                # inventory info
325                box = self._load_inventory_data(title)
326                if box:
327                    newinvnb.append_inv(box=box)
328
329        else:
330            # get Inventory notebook
331            p = self.invnbpages_objects[self.invnbpages_titles.index(title)]
332
333            # check if a host was activated
334            if data["host_addr"][0] != inventory_info and \
335                not p.page_exists(data["host_addr"]):
336                box = self._load_inventory_host_data(title,
337                    data["host_addr"][1])
338                p.append_host(data["host_addr"][0], box)
339
340            # if it is not a host, it was inventory info
341            elif data["host_addr"][0] == inventory_info:
342                box = self._load_inventory_data(title)
343                if box:
344                    p.append_inv(box=box)
345
346
347    def _load_inventory_data(self, inventory_name):
348        """
349        Load data for activated Inventory.
350        """
351        fk_inventory = self.invdb.get_inventory_id_for_name(inventory_name)
352        scans = self.invdb.get_scans_id_for_inventory(fk_inventory)
353        last_scan_id = scans[len(scans)-1][0]
354        hosts = self.invtree.invdata[inventory_name]
355
356        box = gtk.VBox()
357
358        # scan info
359        hb = gtk.HBox()
360        hb.pack_start(gtk.Label(_("Scan count:") + (" %d" % len(scans))),
361                False, False, 0)
362        box.pack_start(hb, False, False, 0)
363
364        hb = gtk.HBox()
365        last_scan_date = self.invdb.get_finish_timestamp_for_scan_from_db(
366                last_scan_id)
367        hb.pack_start(
368                gtk.Label(_("Last scan date:") + (" %s" % last_scan_date)),
369                False, False, 0)
370        box.pack_start(hb, False, False, 0)
371
372        details = self.invdb.get_scan_details_for_scan_from_db(scans[0][0])
373        detc = [
374            _("Scan args"), _("XML output version"), _("Verbose"),
375            _("Debugging"), _("Scanner name"), _("Scanner version")
376            ]
377        for indx, item in enumerate(details):
378            hb = gtk.HBox()
379            hb.pack_start(gtk.Label("%s: %s" % (detc[indx], item)), False,
380                False, 0)
381            box.pack_start(hb, False, False, 0)
382
383        # "separator"
384        box.pack_start(gtk.HSeparator(), False, False, 6)
385
386        # hosts info
387        hb = gtk.HBox()
388        hb.pack_start(gtk.Label(
389            _("Hosts: ") +
390            ', '.join([host[0] for host in hosts])), False, False, 0)
391        box.pack_start(hb, False, False, 0)
392
393        hb = gtk.HBox()
394        hb.pack_start(gtk.Label(_("Host count:") + (" %s" % len(hosts))),
395                False, False, 0)
396        box.pack_start(hb, False, False, 0)
397
398        sw = gtk.ScrolledWindow()
399        sw.add_with_viewport(box)
400        sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
401        sw.show_all()
402
403        return sw
404
405
406    def _load_inventory_host_data(self, inventory_name, host_addr):
407        """
408        Load data for a host in an inventory.
409        """
410        changesd = ChangesDiff(self.invdb)
411        changesl = ChangesList(self, self.invdb, changesd,
412            data={-1: (inventory_name, host_addr)})
413
414        paned = gtk.VPaned()
415        paned.add1(changesl)
416        paned.add2(changesd)
417
418        return paned
419
420
421    def _write_statusbar(self, msg):
422        """
423        Write some message at standard statusbar.
424        """
425        self.std_statusbar.pop(self.std_sb)
426        self.std_statusbar.push(self.std_sb, msg)
427
428
429    def _clear_statusbar(self):
430        """
431        Clear standard statusbar.
432        """
433        self.std_statusbar.pop(self.std_sb)
434
435
436    def _write_statusbar_tip(self, tipmsg, timeout=True):
437        """
438        Write a tip at statusbar.
439        """
440        if not self.write_tips:
441            # tips disabled
442            return
443
444        if not self.window: # widget being destroyed
445            gobject.source_remove(self.tip_timer)
446            return
447
448        self.tip_statusbar.pop(self.tip_sb)
449        self.tip_statusbar.push(self.tip_sb, tipmsg)
450
451        if self.tip_timer != -1:
452            gobject.source_remove(self.tip_timer)
453
454        if timeout:
455            # remove tip after 15 seconds
456            self.tip_timer = gobject.timeout_add(15000,
457                self._clear_tip_statusbar)
458
459
460    def _clear_tip_statusbar(self):
461        """
462        Clear statusbar.
463        """
464        self.tip_statusbar.pop(self.tip_sb)
465        gobject.source_remove(self.tip_timer)
466        self.tip_timer = -1
467
468        return False
469
470
471    def _update_viewer(self):
472        """
473        Call this when needed to update Network Inventory Viewer.
474        """
475        inventories = self.invtree.fill_tree()
476
477        # update Edit Inventories menu
478        new_inventories = set(inventories).difference(set(self.inventories))
479        self.inventories = inventories
480
481        for inv in new_inventories:
482            self.main_action_group.add_actions([("_" + inv, None, inv,
483                None, inv, self._edit_inventory)])
484
485            self.ui_manager.add_ui(self.ui_manager.new_merge_id(),
486                "/menubar/Edit/Inventory", inv, "_" + inv, "menuitem", False)
487
488
489    def _build_results_view(self, query, returned, buildnow=False):
490        """
491        Build a TreeView with returned results from search or perform search
492        and then Build TreeView.
493        """
494        def close_page(widget, data):
495            """
496            Close search page.
497            """
498            page_num = self.viewernb.page_num(data)
499            self.viewernb.remove_page(page_num)
500
501
502        def row_activated(tv, path, tvcolumn):
503            """
504            Activated some row in results treeview.
505            """
506            # create page at "Inventory"
507            model = tv.get_model()
508            tv_iter = model.get_iter(path)
509            host_addr = model.get_value(tv_iter, 1)
510
511            data = { }
512            root = model[path[0]][0]
513            data["root"] = root
514            data["host_addr"] = (host_addr, host_addr) # new format
515
516            self.emit('inventory-activated', data)
517
518            # write tip to statusbar
519            self._write_statusbar_tip(_("A page was open at Historic tab!"))
520
521
522        def buildtv(*args):
523            """
524            Build treeview and append results.
525            """
526            lsmodel = gtk.ListStore(str, str, str, str)
527            tview = gtk.TreeView(lsmodel)
528            columns = 4
529            columns_text = (
530                _("Inventory"), _("Host"),
531                _("First Matched Category"), _("Entry Date")
532                )
533            tview.columns = [None]*columns
534
535            for n in range(columns):
536                tview.columns[n] = gtk.TreeViewColumn(columns_text[n])
537                tview.columns[n].cell = gtk.CellRendererText()
538                tview.columns[n].pack_start(tview.columns[n].cell, True)
539                tview.columns[n].set_attributes(tview.columns[n].cell, text=n)
540
541                tview.append_column(tview.columns[n])
542
543            tview.connect('row-activated', row_activated)
544
545            # layout
546            matches = len(args[1])
547            word = append_s(_("result"), matches)
548            upper_title = gtk.Label()
549            upper_title.set_markup(
550                    ("<b>%d " % matches) + word + _(" found.") +
551                    "</b>")
552            hutbox = HIGHBox()
553            hutbox._pack_noexpand_nofill(upper_title)
554            sw = HIGScrolledWindow()
555            sw.add(tview)
556            vbox = gtk.VBox()
557            vbox.pack_start(hutbox, False, False, 3)
558            vbox.pack_start(sw, True, True, 0)
559
560            vbox.show_all()
561
562            # append results to treeview
563            results = args[1]
564
565            for res, date in results.items():
566                invname = self.invdb.get_inventory_name_for_id(res[0])
567                lsmodel.append((invname, res[1], res[2], str(date)))
568
569            title = _("Search: %s") % args[0]
570            tab_label = HIGAnimatedTabLabel(title)
571            tab_label.connect("close-clicked", close_page, vbox)
572            self.viewernb.append_page(vbox, tab_label)
573
574
575        if buildnow:
576            # uhm.. nice, we already have the results.
577            buildtv(query, returned)
578
579        else:
580            # no results yet, will get them now!
581            host_matches = { }
582
583            for key, values in returned.items():
584                host_id = key
585                inv_id = values[0]
586                host_addr = values[1]
587                date = values[2]
588                res = self.invsearch.search(host_id, query)
589                if res: # res = category returned
590                    host_matches[(inv_id, host_addr, res)] = date
591
592            # build treeview now
593            buildtv(query, host_matches)
594
595
596    def _create_ui_manager(self):
597        """
598        Set up user interface.
599        """
600        self.ui_manager = gtk.UIManager()
601        self.main_action_group = gtk.ActionGroup("MainActionGroup")
602
603        about_icon = None
604        try: about_icon = gtk.STOCK_ABOUT
605        except: pass
606
607        main_actions = [ \
608            ("File", None, _("_File"), None),
609            ("Edit", None, _("_Edit"), None),
610            ("Scheduler", None, _("_Scheduler"), None),
611            ("Help", None, _("_Help"), None),
612
613            ("ToolbarOpt", None, _("Tool_bar"), None),
614            ("InvTabs", None, _("Devices _tab"), None),
615            ("Inventory", None, _("_Inventories"), None),
616
617            # File
618            ("New",
619             gtk.STOCK_NEW, _("_New Inventory"),
620             None, _("Create new Inventory"),
621             self._create_new),
622
623            ("CloseHostTab",
624             None, _("Close Device tab"),
625             "<Control>W", _("Close current host tab"),
626             self._close_current_hosttab),
627
628            ("CloseInvTab",
629             None, _("Close Inventory tab"),
630             "<Shift><Control>W", _("Close current Inventory tab"),
631             self._close_current_invtab),
632
633            ("Quit",
634             gtk.STOCK_QUIT, _("_Quit"),
635             None, _("Close Network Inventory"),
636             self._exit_ni),
637
638            # Edit
639            ('Control Data Removal',
640             None, _("Data Removal"),
641             None, _("Data Removal"),
642             self._edit_data_removal),
643
644            ('Startup',
645             None, _("Startup settings"),
646             None, _("Startup settings"),
647             self._edit_startup),
648
649            # Scheduler
650            # Scheduler log
651            ('Sched Log',
652             None, _("Scheduler log"),
653             None, _("View Scheduler log"),
654             self._open_sched_log),
655
656            # Scheduler status
657            ('Sched Control',
658             self.schedctrl.stock_icon, self.schedctrl.status_text,
659             None, self.schedctrl.status_text,
660             self.schedctrl._scheduler_control),
661
662            # Help
663            ('Show Help',
664             gtk.STOCK_HELP, _('_Help'),
665             None, _('Shows the application help'),
666             self._show_help),
667
668            ('Report a bug',
669             gtk.STOCK_DIALOG_INFO, _('_Report a bug'),
670             '<Control>b', _("Report a bug"),
671             self._show_bug_report),
672
673            ('About',
674             about_icon, _("_About"),
675             '<Control>a', _("About UMIT Network Inventory"),
676             self._show_about)
677
678        ]
679
680        toggle_actions = [
681            # Edit
682            ("ShowTips",
683             None, _("Show ti_ps"),
684             None, _("Enable disable tip showing"),
685             lambda c: self.set_write_tips(not self.write_tips),
686             self.write_tips),
687
688            # Edit/Notebooks
689            ("TabCloseBtn",
690             None, _("Place close button"),
691             None, _("Place a close button upon tab creation"),
692             lambda c: self.set_invnb_cbtn(not self.invnb_close_btn),
693             self.invnb_close_btn)
694        ]
695
696        default_ui = """
697            <menubar>
698                <menu action='File'>
699                    <menuitem action='New' />
700                    <separator />
701                    <menuitem action='CloseHostTab' />
702                    <menuitem action='CloseInvTab' />
703                    <menuitem action='Quit' />
704                </menu>
705                <menu action='Edit'>
706                    <menu action='InvTabs'>
707                         <menuitem action='TabCloseBtn' />
708                    </menu>
709                    <menu action='Inventory'>
710                    </menu>
711                    <menuitem action='ShowTips' />
712                    <menuitem action='Control Data Removal' />
713                    <menuitem action='Startup' />
714                </menu>
715                <menu action='Scheduler'>
716                    <menuitem action='Sched Log' />
717                    <menuitem action='Sched Control' />
718                </menu>
719                <menu action='Help'>
720                    <menuitem action='Show Help' />
721                    <menuitem action='Report a bug' />
722                    <menuitem action='About' />
723                </menu>
724            </menubar>
725            <toolbar>
726                <toolitem action='Sched Control' />
727                <separator />
728            </toolbar>
729            """
730
731        self.main_action_group.add_actions(main_actions)
732        self.main_action_group.add_toggle_actions(toggle_actions)
733
734        for action in self.main_action_group.list_actions():
735            action.set_accel_group(self.main_accel_group)
736            action.connect_accelerator()
737
738        self.ui_manager.insert_action_group(self.main_action_group, 0)
739        self.ui_manager.add_ui_from_string(default_ui)
740
741        self.schedctrl.ui_action = self.main_action_group.get_action(
742            'Sched Control')
743
744        # add Inventories to edit menu
745        for inv in self.inventories:
746            self.main_action_group.add_actions([("_" + inv, None, inv,
747                None, inv, self._edit_inventory)])
748
749            self.ui_manager.add_ui(self.ui_manager.new_merge_id(),
750                "/menubar/Edit/Inventory", inv, "_" + inv, "menuitem", False)
751
752
753    def _edit_data_removal(self, event):
754        """
755        Open window for editing data removal for Inventories.
756        """
757        w = ConfigureDataRemoval()
758        w.show_all()
759
760
761    def _edit_inventory(self, event):
762        """
763        Open inventory for editing.
764        """
765        try:
766            w = NewInventory(event.get_name()[1:], edit_mode=True)
767        except NoInventory:
768            return
769        w.show_all()
770
771
772    def _create_new(self, event):
773        """
774        Open dialog for creating New Inventory.
775        """
776        w = NewInventory()
777        w.show_all()
778
779
780    def _open_sched_log(self, event):
781        """
782        Open scheduler log.
783        """
784        winlog = SchedLog()
785        winlog.show_all()
786
787
788    def _edit_startup(self, event):
789        """
790        Open window for editing startup settings.
791        """
792        settwin = NISettings()
793        settwin.show_all()
794
795
796    def _show_help(self, event):
797        """
798        Open help manual.
799        """
800        webbrowser.open("file://%s" % os.path.join(Path.docs_dir,
801            "index.html"), new=open_url_as())
802
803
804    def _show_bug_report(self, event):
805        """
806        Open bug report window.
807        """
808        bug = BugReport()
809        bug.show_all()
810
811
812    def _show_about(self, event):
813        """
814        Open about window.
815        """
816        awin = About()
817        awin.show_all()
818
819
820    def _exit_ni(self, *args):
821        """
822        Do necessary cleanup before destroying window.
823        """
824        # remove tip timer if still running
825        if self.tip_timer != -1:
826            gobject.source_remove(self.tip_timer)
827            self._clear_tip_statusbar()
828
829        # stop updater timer
830        gobject.source_remove(self.timer_updater)
831
832        self.hide()
833
834        # remove old data
835        if get_decays()[1]:
836            win = RemoveOldData()
837            win.show_all()
838            win.connect('destroy', self.__leave_ni)
839        else:
840            self.__leave_ni()
841
842
843    def __leave_ni(self, *args):
844        """
845        If you are here, Network Inventory has been cleanedup succesfully.
846        """
847        if self.daddy:
848            self.daddy.running_ni = False
849            self.destroy()
850        else:
851            gtk.main_quit()
852
853
854    def __check_for_updates(self):
855        """
856        Check for some possible visual update needed to be done.
857        """
858        do_update = False
859
860        # check for database changes
861        prev_stat = self.db_stat
862        try:
863            possibly_new = os.stat(umitdb).st_mtime
864        except OSError:
865            return True
866
867        if prev_stat != possibly_new:
868            do_update = True
869            self.db_stat = possibly_new
870
871        # check for changes in schemas
872        prev_state = self.schema_stat
873        try:
874            possibly_new = os.stat(Path.sched_schemas).st_mtime
875        except OSError:
876            return True
877
878        if prev_state != possibly_new:
879            do_update = True
880            self.schema_stat = possibly_new
881
882
883        if do_update:
884            self._update_viewer()
885
886        return True
887
888
889    def __set_props(self):
890        """
891        Set window properties.
892        """
893        self.set_title(_("UMIT Network Inventory"))
894        self.invnb.set_scrollable(True)
895        self.viewernb.set_scrollable(True)
896        # a size for testing
897        self.set_position(gtk.WIN_POS_CENTER)
898        width, height = gtk.gdk.get_default_root_window().get_size()
899        self.set_default_size((width * 3) / 4, (height * 3) / 4)
900
901
902    def __do_layout(self):
903        """
904        Layout window widgets.
905        """
906        main_vbox = gtk.VBox()
907        main_hpaned = gtk.HPaned()
908        nb_tl_hpaned = gtk.HPaned()
909
910        menubar = self.ui_manager.get_widget('/menubar')
911        main_vbox.pack_start(menubar, False, False, 0)
912
913        schedbar = self.ui_manager.get_widget('/toolbar')
914        schedbar.set_show_arrow(False)
915        schedbar.set_style(gtk.TOOLBAR_ICONS)
916        toolbar = SearchBar(self, self.invdb)
917
918        toolbar_box = gtk.HBox()
919        toolbar_box.pack_start(schedbar, False, False, 0)
920        toolbar_box.pack_start(toolbar, True, True, 0)
921        main_vbox.pack_start(toolbar_box, False, False, 0)
922
923        left_pane_box = gtk.VBox()
924        left_pane_box.pack_start(self.invtree, True, True, 0)
925
926        main_hpaned.add1(left_pane_box)
927        main_hpaned.add2(nb_tl_hpaned)
928
929        # inventories notebook
930        nb_tl_hpaned.pack1(self.invnb, True, False)
931
932        self.viewernb.append_page(main_hpaned, gtk.Label(_(" Historic ")))
933        self.viewernb.append_page(self.timeline, gtk.Label(_(" Timeline ")))
934
935        self.timeline.show_all()
936
937        main_vbox.pack_start(self.viewernb, True, True, 0)
938
939        sbs_box = gtk.HBox()
940        sbs_box.add(self.tip_statusbar)
941        sbs_box.add(self.std_statusbar)
942        main_vbox.pack_end(sbs_box, False, False, 0)
943
944        self.add(main_vbox)
945
946
947    def get_write_tips(self):
948        """
949        Returns True if tips should be written at statusbar, otherwise, False.
950        """
951        return self.__wtips
952
953
954    def set_write_tips(self, write):
955        """
956        Sets to write tips or not at statusbar.
957        """
958        self.__wtips = write
959        if not self.write_tips:
960            self.tip_statusbar.pop(self.tip_sb)
961
962
963    def get_invnb_cbtn(self):
964        """
965        Returns True if Inventory tabs have a close button placed on them.
966        """
967        return self.__invcbtn
968
969
970    def set_invnb_cbtn(self, enable):
971        """
972        Sets to show or not close button in each Inventory tab.
973        """
974        self.__invcbtn = enable
975
976
977    # Properties
978    write_tips = property(get_write_tips, set_write_tips)
979    invnb_close_btn = property(get_invnb_cbtn, set_invnb_cbtn)
980
981
982gobject.signal_new("inventory-activated", InventoryViewer,
983                   gobject.SIGNAL_RUN_LAST,
984                   gobject.TYPE_NONE,
985                   (gobject.TYPE_PYOBJECT,))
Note: See TracBrowser for help on using the browser.