← Back to branch summary

~ubuntu-branches/ubuntu/maverick/rapache/maverick

« back to all changes in this revision

Viewing changes to RapacheGtk/VirtualHostGui.py

  • Committer: Bazaar Package Importer
  • Author(s): Emanuele Gentili
  • Date: 2008-10-15 15:44:27 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20081015154427-sc86e7urpacfwppr
Tags: 0.7-0ubuntu1
https://launchpad.net/bugs/283770
* rapache version bump (LP: #283770)
* debian/patches:
 + removed 01_surf_this_button.patch, fixed in bzr branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
RapacheGtk/VirtualHostGui.py
31
31
import sys
32
32
import re
33
33
 
 
34
 
34
35
try:
35
36
     import pygtk
36
37
     pygtk.require("2.0")
50
51
from RapacheCore.VirtualHost import *
51
52
from RapacheGtk import GuiUtils
52
53
from EditDomainNameGui import EditDomainNameWindow
53
 
        
 
54
import RapacheGtk.DesktopEnvironment as Desktop
 
55
 
 
56
class UnexpectedCase( Exception ):        
 
57
    pass
 
58
    
54
59
class VirtualHostWindow:
55
60
    
56
61
    def __init__ ( self, parent = None):
57
62
           
58
 
        self.vhost = None
59
 
        self.create_new = True
 
63
        
60
64
        self.parent = parent
61
65
        self.plugins = []
 
66
        self.vhost = None
62
67
 
63
68
        gladefile = os.path.join(Configuration.GLADEPATH, "edit_vhost.glade")
64
69
        wtree = gtk.glade.XML(gladefile)
69
74
        self.button_location = wtree.get_widget("button_location")
70
75
        self.treeview_domain = wtree.get_widget("treeview_domain")
71
76
        self.checkbutton_hosts = wtree.get_widget("checkbutton_hosts")
 
77
        self.label_hosts = wtree.get_widget("label_hosts")
72
78
        self.toolbutton_domain_add = wtree.get_widget("toolbutton_domain_add")
73
79
        self.toolbutton_domain_edit = wtree.get_widget("toolbutton_domain_edit")
74
80
        self.toolbutton_domain_delete = wtree.get_widget("toolbutton_domain_delete")
 
81
        self.combobox_vhost_backups = wtree.get_widget("combobox_vhost_backups")
75
82
        self.notebook = wtree.get_widget("notebook")
76
83
        self.button_save = wtree.get_widget("button_save")
77
84
        self.error_area = wtree.get_widget("error_area")
 
85
        self.label_path = wtree.get_widget("label_path")
 
86
        self.message_text = wtree.get_widget("message_text")
 
87
        self.error_area = wtree.get_widget("error_area")
 
88
        self.treeview_menu = wtree.get_widget("treeview_menu")
78
89
        signals = {
79
 
            "on_toolbutton_domain_add_clicked"       : self.on_toolbutton_domain_add_clicked,
80
 
            "on_toolbutton_domain_edit_clicked"     : self.on_toolbutton_domain_edit_clicked,
81
 
            "on_toolbutton_domain_delete_clicked"   : self.on_toolbutton_domain_delete_clicked,
 
90
            "on_toolbutton_domain_add_clicked"  : self.on_toolbutton_domain_add_clicked,
 
91
            "on_toolbutton_domain_edit_clicked" : self.on_toolbutton_domain_edit_clicked,
 
92
            "on_toolbutton_domain_delete_clicked": self.on_toolbutton_domain_delete_clicked,
82
93
            "on_button_save_clicked"            : self.on_button_save_clicked,
83
94
            "on_button_cancel_clicked"          : self.on_button_cancel_clicked,
84
 
            "on_entry_domain_changed"              : self.on_entry_domain_changed,
 
95
            "on_entry_domain_changed"           : self.on_entry_domain_changed,
85
96
            "on_button_location_clicked"        : self.on_button_location_clicked,
86
 
            "on_entry_domain_focus_out_event"    : self.on_entry_domain_focus_out_event,
87
 
            "on_button_location_clear_clicked"    : self.on_button_location_clear_clicked
 
97
            "on_entry_domain_focus_out_event"   : self.on_entry_domain_focus_out_event,
 
98
            "on_button_location_clear_clicked"  : self.on_button_location_clear_clicked,
 
99
            "on_button_restore_version_clicked" : self.on_button_restore_version_clicked,
 
100
            "on_linkbutton_documentation_clicked" : self.on_linkbutton_documentation_clicked,
 
101
            "on_notebook_switch_page"           : self.on_notebook_switch_page,
 
102
            "on_treeview_menu_cursor_changed"   :   self.on_treeview_menu_cursor_changed,
 
103
            "on_button_error_close_clicked"     : self.on_button_error_close_clicked
88
104
        }
89
105
        wtree.signal_autoconnect(signals)
 
106
        # add on destroy to quit loop
 
107
        self.window.connect("destroy", self.on_destroy)  
 
108
        
 
109
        self.combobox_vhost_backups.set_active(0)
90
110
        
91
111
        self.text_view_vhost_source = GuiUtils.new_apache_sourceview()
92
112
        wtree.get_widget( 'text_view_vhost_source_area' ).add( self.text_view_vhost_source )
93
 
        self.text_view_vhost_source.set_editable( False )
94
113
        self.text_view_vhost_source.show()
95
 
                
96
 
        self.notebook.get_nth_page( 1 ).hide()
97
 
        self.notebook.get_nth_page( 2 ).hide()
98
 
        
99
 
        # add on destroy to quit loop
100
 
        self.window.connect("destroy", self.on_destroy)
101
114
        
102
115
        # Setup tree
103
116
        column = gtk.TreeViewColumn(('Domains'))
113
126
        GuiUtils.style_as_tooltip( self.error_area )
114
127
        self.on_entry_domain_changed()
115
128
        
116
 
    def run(self):
117
 
 
118
 
        # Load UI Plugins
119
 
        if self.vhost:
120
 
            site = self.vhost
121
 
        else:
122
 
            # load default  
123
 
            site = VirtualHostModel( "", self.parent.plugin_manager)
124
 
            
 
129
        
 
130
        #Setup Menu Tree
 
131
        column = gtk.TreeViewColumn(('Icon'))
 
132
        column.set_spacing(4)
 
133
        cell = gtk.CellRendererPixbuf()
 
134
        column.pack_start(cell, expand=False)
 
135
        column.set_attributes(cell, pixbuf=0)
 
136
        self.treeview_menu.append_column(column)
 
137
        
 
138
        column = gtk.TreeViewColumn(('Title'))
 
139
        column.set_spacing(4)
 
140
        cell = gtk.CellRendererText()
 
141
        column.pack_start(cell, True)
 
142
        column.set_attributes(cell, markup=1)
 
143
        self.treeview_menu.append_column(column)
 
144
        
 
145
        store = gtk.ListStore(gtk.gdk.Pixbuf, str, int)
 
146
        self.treeview_menu.set_model(store)  
 
147
        
 
148
        icon_theme = gtk.icon_theme_get_default()
 
149
        store.append((icon_theme.lookup_icon("applications-internet", 24, 0).load_icon(), "Domain", 0))  
 
150
        
 
151
        # init enabled plugins
125
152
        for plugin in self.parent.plugin_manager.plugins:
126
153
                try:
127
154
                    if plugin.is_enabled():                     
128
 
                        plugin.load_vhost_properties(self.notebook, site.data)
 
155
                        content, title, pixbuf = plugin.init_vhost_properties()
 
156
                        tab_count = self.notebook.get_n_pages() - 1
 
157
                        plugin._tab_number = self.notebook.insert_page(content, gtk.Label(title), tab_count)
 
158
                        store.append((pixbuf, title, tab_count))
 
159
                        content.show()
129
160
                        self.plugins.append(plugin)
130
161
                except Exception:
131
162
                        traceback.print_exc(file=sys.stdout)
132
 
 
133
 
        self.window.show()           
 
163
                        
 
164
        store.append((icon_theme.load_icon(gtk.STOCK_EDIT, 24, 0), "Definition File", self.notebook.get_n_pages() - 1))  
 
165
        
 
166
        select = self.treeview_menu.get_selection()
 
167
        select.select_path(0)
 
168
        
 
169
        
 
170
        self.__previous_active_tab = 0
 
171
        
 
172
        self.accel_group = gtk.AccelGroup()
 
173
        self.window.add_accel_group(self.accel_group)
 
174
        
 
175
        self.button_save.add_accelerator("clicked", self.accel_group, 13, 0, 0)
 
176
 
 
177
        self.vhost =  VirtualHostModel( "")
 
178
        
 
179
    def on_treeview_menu_cursor_changed(self, widget):
 
180
        model, iter =  self.treeview_menu.get_selection().get_selected()
 
181
        if not iter: return
 
182
        page_number = model.get_value(iter, 2)
 
183
        
 
184
        # Save 
 
185
        result = True
 
186
        error = ""
 
187
        if self.__previous_active_tab == self.notebook.get_n_pages() - 1:
 
188
            result, error =  self.save_edit_tab()
 
189
        elif self.__previous_active_tab == 0:
 
190
            self.save_domain_tab()
 
191
            result = True
 
192
        else:
 
193
            result, error = self.save_plugin_tab(self.__previous_active_tab)
 
194
        
 
195
        # process     
 
196
        if not result:
 
197
            self.show_error("Sorry can not change tabs, " + error)
 
198
            select = self.treeview_menu.get_selection()
 
199
            select.select_path((self.__previous_active_tab))
 
200
            return
 
201
 
 
202
        self.clear_error()
 
203
        
 
204
        # Load
 
205
        if page_number == self.notebook.get_n_pages() - 1:
 
206
            self.load_edit_tab()
 
207
        elif page_number == 0:
 
208
            self.load_domain_tab()    
 
209
        else:
 
210
            self.update_plugin_tab(page_number)
 
211
 
 
212
        self.window.set_title("VirtualHost Editor - " + self.vhost.get_server_name() )
 
213
 
 
214
        self.__previous_active_tab = page_number
 
215
        self.notebook.set_current_page(page_number)  
 
216
 
 
217
    def on_notebook_switch_page(self, notebook, page, page_num):
 
218
       return
 
219
 
 
220
    def on_linkbutton_documentation_clicked(self, widget):
 
221
        Desktop.open_url( widget.get_uri() )
 
222
        
 
223
    def on_button_restore_version_clicked(self, widget):
 
224
        buf = self.text_view_vhost_source.get_buffer()
 
225
        if buf.get_modified():
 
226
            md = gtk.MessageDialog(self.window, flags=0, type=gtk.MESSAGE_QUESTION, buttons=gtk.BUTTONS_OK_CANCEL, message_format="Are you sure, you will lose all your current changes")
 
227
            result = md.run()
 
228
            md.destroy()
 
229
            if result != gtk.RESPONSE_OK:
 
230
                return
 
231
        
 
232
        selected = self.combobox_vhost_backups.get_active()
 
233
        
 
234
        if selected == 0:
 
235
            buf.set_text( self.vhost.get_source() )
 
236
        else:
 
237
            value = self.combobox_vhost_backups.get_active_text()[7:]
 
238
            buf.set_text( self.vhost.get_source_version(value) )
 
239
            
 
240
        buf.set_modified(False)
 
241
        
 
242
        
 
243
    def run(self):
 
244
 
 
245
        # Load UI Plugins
 
246
        if self.vhost:
 
247
            site = self.vhost
 
248
        else:        
 
249
            #this should never happen since now we initialize an empty VirtualHostModel
 
250
            #inside __init__
 
251
            raise UnexpectedCase,  "Internal error, existing VirtualHostModel expected"
 
252
            pass
 
253
            
 
254
 
 
255
        self.window.show()   
 
256
                
134
257
        gtk.main()
135
258
 
136
 
    def load (self, name ):
137
 
        self.vhost = VirtualHostModel( name )
138
 
        self.create_new = False
139
 
        try:
140
 
            self.vhost.load(False, self.parent.plugin_manager)
141
 
            print self.vhost.data
142
 
            #self._get( 'has_www' ).set_active( site.data[ 'has_www' ] )
143
 
            server_name = self.vhost.data[ 'ServerName' ] 
144
 
            if ( server_name != None ):
145
 
                self.entry_domain.set_text( server_name )
146
 
            document_root = self.vhost.data[ 'DocumentRoot' ] 
147
 
            if ( document_root != None ):
148
 
                self.entry_location.set_text( document_root )
149
 
            server_alias = self.vhost.data[ 'ServerAlias' ]
150
 
            if ( server_alias != None ): 
151
 
                for domain in server_alias:
152
 
                    self.treeview_domain_store.append((domain, None))            
153
 
            print self.vhost.data
154
 
        except "VhostUnparsable":            
155
 
            pass
156
 
        
157
 
        buf = self.text_view_vhost_source.get_buffer()
158
 
        buf.set_text( self.vhost.get_source() )
159
 
        
160
 
 
161
 
 
 
259
    def load (self, vhost ):
 
260
        if vhost:
 
261
            self.vhost = vhost
 
262
            #hosts tooggling not supported on editing
 
263
            #self.checkbutton_hosts.hide()
 
264
            #self.label_hosts.hide()
 
265
        else:
 
266
            self.checkbutton_hosts.set_active(True)
 
267
        self.load_domain_tab()
 
268
        
 
269
        for file in self.vhost.get_backup_files():
 
270
            self.combobox_vhost_backups.append_text("Backup " + file[0][-21:-4])
 
271
 
 
272
        self.label_path.set_text( self.vhost.get_source_filename() ) 
 
273
        self.on_entry_domain_changed()
 
274
        
 
275
    def save_edit_tab(self):
 
276
        #print "Save edit tab"
 
277
        buf = self.text_view_vhost_source.get_buffer()
 
278
        content = buf.get_text(buf.get_start_iter(), buf.get_end_iter())
 
279
 
 
280
        return self.vhost.load_from_string( content ), "your edited source does not seem to be valid syntax"
 
281
 
 
282
    def load_edit_tab(self):
 
283
        #print "load edit tab"
 
284
        # open edit tab update content
 
285
        buf = self.text_view_vhost_source.get_buffer()
 
286
        text = self.vhost.get_source_generated()
 
287
        buf.set_text( text )
 
288
        buf.set_modified(False) 
 
289
        
 
290
    def load_domain_tab(self):
 
291
        #print "Load domain tab"
 
292
        
 
293
        vhost_name = self.vhost.get_server_name()
 
294
        self.window.set_title("VirtualHost Editor - " + vhost_name )
 
295
        self.window.set_icon_from_file(self.vhost.get_icon())
 
296
        
 
297
        modal = self.treeview_menu.get_model()
 
298
        iter = modal.get_iter(0)
 
299
        
 
300
        modal.set_value(iter, 0, self.window.get_icon())
 
301
        server_name = ''
 
302
        if self.vhost.config and self.vhost.config.servername and self.vhost.config.servername.value:
 
303
            server_name = self.vhost.config.servername.value
 
304
            
 
305
        self.entry_domain.set_text( server_name )
 
306
        """ ???    
 
307
        if not self.vhost.is_default():            
 
308
            self.entry_domain.set_text( server_name )
 
309
        elif self.vhost.config.ServerName:
 
310
            self.entry_domain.set_sensitive(False)
 
311
        """
 
312
        
 
313
        document_root = self.vhost.get_document_root()
 
314
        if ( document_root != None ):
 
315
            self.entry_location.set_text( document_root )
 
316
        server_alias = None
 
317
        
 
318
        self.treeview_domain_store.clear()
 
319
 
 
320
        server_alias = self.vhost.get_server_alias()
 
321
        if server_alias:
 
322
            for domain in server_alias:
 
323
                self.treeview_domain_store.append((domain, None))   
 
324
 
 
325
    def save_domain_tab(self):
 
326
        #print "Save domain tab"
 
327
        if self.entry_location.get_text() == "" and self.vhost.is_new:
 
328
            self.set_default_values_from_domain( True )
 
329
        
 
330
        #if not self.vhost.is_default():
 
331
        if self.entry_domain.get_text():
 
332
            self.vhost.config.ServerName.value = self.entry_domain.get_text()
 
333
        elif self.vhost.config.ServerName:
 
334
            del self.vhost.config.ServerName 
 
335
            
 
336
        self.window.set_title("VirtualHost Editor - " + self.vhost.get_server_name() )
 
337
        
 
338
        if self.vhost.config.DocumentRoot:
 
339
            old_document_root = self.vhost.config.DocumentRoot.value
 
340
            if old_document_root != self.entry_location.get_text():
 
341
                ds = self.vhost.config.Directory.search( [old_document_root] )
 
342
                if len(ds) > 0:
 
343
                    d = ds[0]
 
344
                    d.value = self.entry_location.get_text()
 
345
        self.vhost.config.DocumentRoot.value = self.entry_location.get_text()
 
346
 
 
347
        aliases = self.get_server_aliases_list()
 
348
        if len(aliases) > 0:
 
349
            self.vhost.config.ServerAlias.opts = self.get_server_aliases_list()
 
350
        elif self.vhost.config.ServerAlias:
 
351
            del self.vhost.config.ServerAlias
 
352
             
 
353
        self.hack_hosts = self.checkbutton_hosts.get_active()      
 
354
 
 
355
        return
 
356
        
 
357
    def update_plugin_tab(self, tab):
 
358
        #print "Update plugin : ", tab
 
359
        if self.plugins:
 
360
            for plugin in self.plugins:
 
361
                try:
 
362
                    if plugin.is_enabled() and plugin._tab_number == tab:          
 
363
                        plugin.load_vhost_properties(self.vhost)
 
364
                except Exception:
 
365
                        traceback.print_exc(file=sys.stdout)
 
366
 
 
367
    def save_plugin_tab(self, tab):
 
368
        result = True
 
369
        error = ""
 
370
        #print "Save plugin : ", tab
 
371
        if self.plugins:
 
372
            for plugin in self.plugins:
 
373
                try:
 
374
                    if plugin.is_enabled() and plugin._tab_number == tab:  
 
375
                        result, error = plugin.update_vhost_properties(self.vhost)
 
376
                except Exception:
 
377
                        traceback.print_exc(file=sys.stdout)
 
378
        return result, error
 
379
                 
162
380
    def get_domain (self):
163
381
        return self.entry_domain.get_text().strip()
164
382
        #url.lower().startswith('http://')
172
390
        if force_domain and not domain:
173
391
            self.entry_location.set_text("")
174
392
 
175
 
        # auto create a www entry
176
 
        #if not force_domain and domain and len(self.treeview_domain_store) == 0 and not domain.startswith("www"):
177
 
        #    self.treeview_domain_store.append(("www." + domain, None))
178
 
 
179
393
    def on_entry_domain_focus_out_event(self, widget, opt):
180
394
        self.set_default_values_from_domain()
181
395
        
182
396
    def on_entry_domain_changed(self, unused_widget = None):
183
397
        widget = self.entry_domain
184
 
        name = widget.get_text()
185
 
        if ( valid_domain_name( name ) ):
 
398
        name = widget.get_text()                
 
399
        if valid_domain_name( name ) or (self.vhost and self.vhost.is_default()):
186
400
            self.button_save.set_sensitive(True);
187
 
            #if self.create_new :
188
 
            #    self.xml.get_widget( 'default_folder' ).set_text( '/var/www/'+name+'/httpdocs' )
189
401
        else:
190
402
            self.button_save.set_sensitive(False); 
191
403
    
203
415
                        gtk.RESPONSE_OK))
204
416
                        
205
417
        location = self.entry_location.get_text().strip()
 
418
        
 
419
        while not Shell.command.exists(location):
 
420
            location = os.path.abspath(os.path.join(location, os.path.pardir))
 
421
        
206
422
        if not location:
207
423
            location = "/var/www"    
208
424
        chooser.set_current_folder(location)
221
437
        if domain:
222
438
            self.treeview_domain_store.append((domain, None))
223
439
        return
 
440
        
224
441
    def  get_server_aliases_list (self ):
225
442
        aliases = []
226
443
        for row in self.treeview_domain_store: aliases.append( row[0] )
230
447
        model, iter = self.treeview_domain.get_selection().get_selected()
231
448
        if not iter: return
232
449
        domain = model.get_value(iter, 0)
233
 
        print domain
 
450
 
234
451
        edw = EditDomainNameWindow( domain )
235
452
        result = edw.run()
236
453
        if result:
244
461
        return  
245
462
            
246
463
    def on_button_save_clicked(self, widget):
247
 
        if self.entry_location.get_text() == "" and self.create_new:
248
 
            self.set_default_values_from_domain( True )
 
464
 
 
465
        # Save
 
466
        result, error = True, ""
 
467
        if self.__previous_active_tab == self.notebook.get_n_pages() - 1:
 
468
            result, error = self.save_edit_tab()
 
469
        elif self.__previous_active_tab == 0:
 
470
            self.save_domain_tab()
 
471
        else:
 
472
            result, error = self.save_plugin_tab(self.__previous_active_tab)
249
473
        
250
 
        options = {}
251
 
        options[ 'ServerAlias' ] =  []
252
 
        options[ 'ServerName' ] = self.entry_domain.get_text()
253
 
        options[ 'hack_hosts' ] = self.checkbutton_hosts.get_active()                
254
 
        options[ 'DocumentRoot' ] = self.entry_location.get_text()
255
 
        options[ 'ServerAlias' ] = self.get_server_aliases_list()
256
 
 
257
 
            # Save plugins
 
474
        # if errors
 
475
        if not result:
 
476
            md = gtk.MessageDialog(self.window, flags=0, type=gtk.MESSAGE_ERROR, buttons=gtk.BUTTONS_OK, message_format=error)
 
477
            result = md.run()
 
478
            md.destroy()
 
479
            return 
 
480
    
 
481
        # All plugins on save
258
482
        if self.plugins:
259
483
            for plugin in self.plugins:
260
484
                try:
261
485
                    if plugin.is_enabled():
262
 
                        plugin.save_vhost_properties(options)
 
486
                        res, message = plugin.save_vhost_properties(self.vhost)
 
487
                        if not res:
 
488
                            result = False
 
489
                            if tab_number and plugin._tab_number == tab_number:
 
490
                                self.show_error ( message )
263
491
                except Exception:
264
492
                    traceback.print_exc(file=sys.stdout) 
265
 
 
266
 
        print options
267
 
        
268
 
        try:
269
 
            if ( self.create_new ):
270
 
                site = VirtualHostModel( options[ 'ServerName' ] )
271
 
                site.create ( options )
272
 
            else:
273
 
                name = self.vhost.data['name']
274
 
                print "Current name:", name
275
 
                site = VirtualHostModel( name )
276
 
                site.update( options, name )
277
 
 
278
 
            
279
 
            #self.parent.create_vhost_list()        
280
 
            self.parent.refresh_vhosts()
281
 
            self.parent.please_restart()
282
 
            self.window.destroy()
283
 
        except "VhostExists":
284
 
           print "========================"
285
 
           self.show_error( "A virtual host with the same name already exists" )     
286
 
        
287
 
                         
 
493
        
 
494
 
 
495
        is_new = self.vhost.is_new
 
496
        
 
497
        self.vhost.hack_hosts = self.checkbutton_hosts.get_active()
 
498
        
 
499
        # save over buffer content
 
500
        self.vhost.save()
 
501
        
 
502
        #update /etc/hosts only if it's a new vhost
 
503
        
 
504
        if is_new:
 
505
            if self.hack_hosts:
 
506
                #update servername
 
507
                if self.vhost.config.ServerName and self.vhost.config.ServerName.value:
 
508
                    Shell.command.sudo_execute ( [os.path.join(Configuration.APPPATH, "hosts-manager"), '-a', self.vhost.config.ServerName.value ] )
 
509
                #add an entry for each host
 
510
                if self.vhost.config.ServerAlias:
 
511
                    for alias in self.vhost.config.ServerAlias:
 
512
                        Shell.command.sudo_execute ( [os.path.join(Configuration.APPPATH, 'hosts-manager'), '-a', alias ])
 
513
                    
 
514
        # check apache config
 
515
        returncode, error = self.parent.apache.test_config()
 
516
        if not returncode:
 
517
            error = error.strip()
 
518
            md = gtk.MessageDialog(self.window, flags=0, type=gtk.MESSAGE_ERROR, buttons=gtk.BUTTONS_OK_CANCEL, message_format="Changes have been saved, but an error has been detected: \n\n"+error + "\n\nAre you sure you want to continue? Apache may not start until all errors are resolved.")
 
519
            result = md.run()
 
520
            md.destroy()
 
521
            if result != gtk.RESPONSE_OK:
 
522
                return
 
523
 
 
524
        #self.parent.create_vhost_list()        
 
525
        self.parent.refresh_vhosts()
 
526
        self.parent.please_restart()
 
527
        self.window.destroy()
 
528
                               
288
529
    def on_button_cancel_clicked(self, widget):
289
530
        self.window.destroy()
290
531
        return    
 
532
        
 
533
    def on_button_error_close_clicked(self, widget):
 
534
        self.clear_error()
 
535
                
291
536
    def show_error ( self, message ):
292
 
        
293
 
        self.xml.get_widget( 'message_text' ).set_label( '<b>'+message+'</b>' )
294
 
        self.xml.get_widget( 'message_container' ).show()                 
295
 
 
 
537
        self.message_text.set_label( '<b>'+message+'</b>' )
 
538
        self.error_area.show() 
 
539
                        
 
540
    def clear_error ( self):
 
541
        self.error_area.hide()