gnms 2.1.0.rc1

data/lib/gui/node_host_property.rb

@@ -0,0 +1,3712 @@
+require "#{GNMSLIB}"+'/monitor/client/snmp/snmp_monitoring'
+require "#{GNMSLIB}"+'/monitor/client/wmi/wmi_monitoring'
+require "#{GNMSLIB}"+'/monitor/client/jmx/jmx_monitoring'
+require "#{GNMSLIB}"+'/monitor/client/custom/custom_monitoring'
+require "#{GNMSLIB}"+'/monitor/server/syslog/syslog_monitoring'
+require "#{GNMSLIB}"+'/monitor/server/snmp/snmptrap_monitoring'
+
+class NodeHostProperty
+
+def toggle_select_port(path=0)
+    #switch all port
+	 @treeview.model.each {|model, path, iter|
+      fixed =iter[0]
+      fixed ^= 1
+      @cbutton[path.to_str().to_i()]=fixed
+      iter[0] = fixed
+	}
+end
+
+def toggle_select_custom(path=0)
+	 @customview.model.each {|model, path, iter|
+      fixed =iter[0]
+      fixed ^= 1
+      iter[0] = fixed
+	}
+end
+
+def include_regex_str(str,list)
+	list.each {|str_lign|
+		if str_lign.match(str)
+			return true
+		end
+	} unless list == nil
+	return false
+end
+
+#
+#	add or modify an existing service
+#
+	def add_monitored_service(mode=nil)
+
+	 protocol=nil
+	 port=nil
+	 service_name=nil
+	 severity=nil
+	 
+    addportwin=Gtk::Window.new
+
+	 if mode
+		 if @treeview.selection.selected == nil
+			return
+		 end
+		 title="Edit monitored service"
+		 iter=@treeview.selection.selected
+		 protocol=iter[1]
+		 port=iter[2]
+	    service_name=iter[3]
+	    severity=iter[4]
+  	 else
+		 title="Add monitored service"
+    end
+
+    addportwin.set_title(title)
+    addportwin.set_size_request(315, -1)
+    addportwin.set_modal(true)
+
+    addportwin.signal_connect("key_press_event") {|w,e|
+      if e.keyval == Gdk::Keyval::GDK_Escape
+			addportwin.destroy
+      end
+    }
+
+    frame = Gtk::Frame::new
+    frame.border_width=10
+    frame.show
+    vbox_root=Gtk::VBox::new
+    vbox_root.show
+    addportwin.add vbox_root
+    vbox_root.add frame
+    vbox = Gtk::VBox.new
+    vbox.show
+    frame.add vbox
+
+    table = Gtk::Table.new(4,2,false)
+    table.show
+
+    entry_serv = Gtk::Entry.new
+    entry_serv.set_text(service_name) unless service_name==nil
+    label_proto = Gtk::Label.new "Protocol"
+    label_proto.show
+
+  	 entry_proto = Gtk::ComboBox.new
+         protos = ["tcp","udp"]
+         protos.each {|p|
+            entry_proto.append_text(p)
+         }
+         if protocol
+            ind = protos.index(protocol)
+            entry_proto.set_active(ind) if ind
+         else
+            ind = protos.index("tcp")
+            entry_proto.set_active(ind) if ind
+         end
+	 entry_proto.set_size_request(20,-1)
+	 entry_proto.show
+
+	 bbox=Gtk::HButtonBox.new
+	 bbox.show
+	 bbox.add entry_proto
+    table.attach(label_proto,0,1,0,1)
+    table.attach(bbox,1,2,0,1)
+
+	 label_port = Gtk::Label.new "Port"
+	 label_port.show
+	 entry_port = Gtk::Entry.new
+	 entry_port.set_max_length 5
+	 entry_port.set_text(port.to_s()) unless port==nil
+	 entry_port.set_size_request(20,-1)
+	 entry_port.show
+	 entry_port.signal_connect("changed") {
+		 entry_serv.text=service_name(entry_proto.active_text, entry_port.text)
+	 }
+	 entry_proto.signal_connect("changed") {
+		 entry_serv.text=service_name(entry_proto.active_text, entry_port.text) unless entry_port.text==nil
+	 }
+	 bbox=Gtk::HButtonBox.new
+	 bbox.show
+	 bbox.add entry_port
+    table.attach(label_port,0,1,1,2)
+    table.attach(bbox,1,2,1,2)
+
+    label_serv = Gtk::Label.new "Service"
+    label_serv.show
+    entry_serv.set_size_request(20,-1)
+    entry_serv.show
+    bbox=Gtk::HButtonBox.new
+    bbox.show
+    bbox.add entry_serv
+    table.attach(label_serv,0,1,2,3)
+    table.attach(bbox,1,2,2,3)
+
+    label_sev = Gtk::Label.new "Severity"
+    label_sev.show
+    entry_sev = Gtk::ComboBox.new
+    $status[0..3].each {|sev|
+      entry_sev.append_text(sev)
+    }
+    entry_sev.signal_connect("changed") {
+      entry_sev.child.set_background_gdk(@color_style[entry_sev.active])
+    }
+   ind = 0
+   if severity
+      ind = $status[0..3].index(severity)
+      entry_sev.set_active(ind) if ind
+   else
+      entry_sev.set_active(ind)            
+   end
+   entry_sev.child.set_background_gdk(@color_style[ind])
+        
+	 entry_sev.set_size_request(150,-1)
+	 entry_sev.show
+	 bbox=Gtk::HButtonBox.new
+	 bbox.show
+	 bbox.add entry_sev
+    table.attach(label_sev,0,1,3,4)
+    table.attach(bbox,1,2,3,4)
+
+    ok_button = Gtk::Button.new(Gtk::Stock::OK)
+    ok_button.show
+    ok_button.signal_connect("clicked") {
+		if mode
+			#here we just modify this service
+			if isValidPort(entry_port.text.to_i())		
+			  iter=@treeview.selection.selected
+			  iter[1] = entry_proto.active_text
+			  iter[2] = entry_port.text.to_i
+			  iter[3] = entry_serv.text
+			  iter[4] = entry_sev.active_text
+                          addportwin.destroy()
+			else
+				errorEntry(addportwin, "Bad port #{entry_port.entry.text}")
+			end
+		else
+ 		  #just add this service
+   	  if isValidPort(entry_port.text.to_i())
+			  search_mon_port=false
+			  @treeview.model.each {|model, path, iter|
+				 if iter[2]==entry_port.text.to_i && iter[1]==entry_proto.active_text
+					 search_mon_port=true
+					 break
+				 end
+			  }
+
+			 if search_mon_port==false
+				iter=@treeview.model.append
+				iter[0] = 1
+				iter[1] = entry_proto.active_text
+				iter[2] = entry_port.text.to_i
+				iter[3] = entry_serv.text
+				iter[4] = entry_sev.active_text
+      		                addportwin.destroy()
+			 else
+				 errorEntry(addportwin, "#{entry_proto.active_text}/#{entry_port.text} already exists")
+			 end
+   	  else 
+  	   	  	errorEntry(addportwin, "Bad port #{entry_port.text}")
+   	  end
+		end
+    }
+
+    cancel_button = Gtk::Button.new(Gtk::Stock::CANCEL)
+    cancel_button.show
+    cancel_button.signal_connect("clicked") {
+  	    addportwin.destroy 
+    }
+
+	 bbox =Gtk::HBox::new(FALSE, 10)
+	 bbox.border_width=10
+	 bbox.show
+
+	 ok_button.set_flags(Gtk::Widget::CAN_DEFAULT)
+	 bbox.pack_start(ok_button, TRUE, TRUE, 0)
+	 cancel_button.set_flags(Gtk::Widget::CAN_DEFAULT)
+	 bbox.pack_start(cancel_button, TRUE, TRUE, 0)
+
+	 vbox.add(table)
+	 separator = Gtk::HSeparator::new()
+	 separator.show
+	 vbox_root.pack_start(separator, FALSE, TRUE, 0)
+	 vbox_root.pack_start(bbox, FALSE, TRUE, 0)
+
+    addportwin.show
+	
+	end
+
+def add_monitored_snmp(mode=nil)
+	 oidref=nil
+	 operator=nil
+	 threshold=nil
+	 severity=nil
+
+    addsnmpwin=Gtk::Window.new
+
+	 if mode
+		 if @snmpview.selection.selected == nil
+			return
+		 end
+		 title="Edit monitored SNMP OID"
+		 iter=@snmpview.selection.selected
+		 oidref=iter[1]
+		 operator=iter[2]
+	    threshold=iter[3]
+	    severity=iter[4]
+  	 else
+		 title="Add monitored SNMP OID"
+    end
+
+    addsnmpwin.set_title(title)
+    addsnmpwin.set_size_request(340, -1)
+    addsnmpwin.set_modal(true)
+
+    addsnmpwin.signal_connect("key_press_event") {|w,e|
+      if e.keyval == Gdk::Keyval::GDK_Escape
+			addsnmpwin.destroy
+      end
+    }
+
+    frame = Gtk::Frame::new
+    frame.border_width=10
+    frame.show
+    vbox_root=Gtk::VBox::new
+    vbox_root.show
+    addsnmpwin.add vbox_root
+    vbox_root.add frame
+    vbox = Gtk::VBox.new
+    vbox.show
+    frame.add vbox
+
+    table = Gtk::Table.new(4,2,false)
+    table.show
+
+	 label_oidref = Gtk::Label.new "OID Ref"
+    label_oidref.show
+  	 entry_oidref = Gtk::ComboBox.new
+         OIDRef::get_oid_refs_name().each {|oid|
+            entry_oidref.append_text(oid)
+         }
+         if oidref
+            ind = OIDRef::get_oid_refs_name().index(oidref)
+            entry_oidref.set_active(ind) if ind
+         else
+            entry_oidref.set_active(0)
+         end
+	 entry_oidref.set_size_request(150,-1)
+	 entry_oidref.show
+	 bbox=Gtk::HButtonBox.new
+	 bbox.show
+	 bbox.add entry_oidref
+    table.attach(label_oidref,0,1,0,1)
+    table.attach(bbox,1,2,0,1)
+
+	 label_operator = Gtk::Label.new "Operator"
+    label_operator.show
+  	 entry_operator = Gtk::ComboBox.new
+         SnmpMonitoring::TESTOP.each {|ope|
+            entry_operator.append_text(ope)
+         }
+         if operator
+            ind = SnmpMonitoring::TESTOP.index(operator)
+            entry_operator.set_active(ind) if ind
+         else
+            entry_operator.set_active(0)
+         end
+
+	 entry_operator.set_size_request(150,-1)
+	 entry_operator.show
+	 bbox=Gtk::HButtonBox.new
+	 bbox.show
+	 bbox.add entry_operator
+    table.attach(label_operator,0,1,1,2)
+    table.attach(bbox,1,2,1,2)
+
+	 entry_threshold = Gtk::Entry.new
+	 entry_threshold.set_text(threshold) unless threshold==nil
+    label_threshold = Gtk::Label.new "Threshold"
+	 label_threshold.show
+	 entry_threshold.set_size_request(150,-1)
+	 entry_threshold.show
+	 bbox=Gtk::HButtonBox.new
+	 bbox.show
+	 bbox.add entry_threshold
+    table.attach(label_threshold,0,1,2,3)
+    table.attach(bbox,1,2,2,3)
+
+    label_sev = Gtk::Label.new "Severity"
+    label_sev.show
+    entry_sev = Gtk::ComboBox.new
+    $status[0..3].each {|sev|
+      entry_sev.append_text(sev)
+    }
+   entry_sev.signal_connect("changed") {
+     entry_sev.child.set_background_gdk(@color_style[entry_sev.active])
+   }
+   ind = 0
+   if severity
+      ind = $status[0..3].index(severity)
+      entry_sev.set_active(ind) if ind
+   else
+      entry_sev.set_active(ind)            
+   end
+   entry_sev.child.set_background_gdk(@color_style[ind])
+  
+   entry_sev.set_size_request(150,-1)
+   entry_sev.show
+	 bbox=Gtk::HButtonBox.new
+	 bbox.show
+	 bbox.add entry_sev
+    table.attach(label_sev,0,1,3,4)
+    table.attach(bbox,1,2,3,4)
+
+    ok_button = Gtk::Button.new(Gtk::Stock::OK)
+    ok_button.show
+    ok_button.signal_connect("clicked") {
+		if mode
+			#here we just modify this service
+			iter=@snmpview.selection.selected
+			iter[1] = entry_oidref.active_text
+			iter[2] = entry_operator.active_text
+			iter[3] = entry_threshold.text
+			iter[4] = entry_sev.active_text
+     		addsnmpwin.destroy()
+		else
+			if isInteger(entry_threshold.text)
+					#need to test if already exists
+					error_detected=0
+					@snmpview.model.each {|model, path, iter|
+						if "#{iter[1]}" == "#{entry_oidref.active_text}"
+							error_detected=1
+							break
+						end
+				 	}
+					if error_detected == 0
+					  iter=@snmpview.model.append
+					  iter[0] = 1
+					  iter[1] = entry_oidref.active_text
+					  iter[2] = entry_operator.active_text
+					  iter[3] = entry_threshold.text
+					  iter[4] = entry_sev.active_text
+      			  addsnmpwin.destroy()
+					else
+						 errorEntry(addsnmpwin, "OID Ref already set")
+					end
+			else
+				 errorEntry(addsnmpwin, "Threshold #{entry_threshold.text} need to be an integer")
+			end
+		end
+    }
+
+    cancel_button = Gtk::Button.new(Gtk::Stock::CANCEL)
+    cancel_button.show
+    cancel_button.signal_connect("clicked") {
+  	    addsnmpwin.destroy 
+    }
+
+	 bbox =Gtk::HBox::new(FALSE, 10)
+	 bbox.border_width=10
+	 bbox.show
+
+	 ok_button.set_flags(Gtk::Widget::CAN_DEFAULT)
+	 bbox.pack_start(ok_button, TRUE, TRUE, 0)
+	 cancel_button.set_flags(Gtk::Widget::CAN_DEFAULT)
+	 bbox.pack_start(cancel_button, TRUE, TRUE, 0)
+
+	 vbox.add(table)
+	 separator = Gtk::HSeparator::new()
+	 separator.show
+	 vbox_root.pack_start(separator, FALSE, TRUE, 0)
+	 vbox_root.pack_start(bbox, FALSE, TRUE, 0)
+
+    addsnmpwin.show
+end
+
+
+def add_monitored_wmi(mode=nil)
+	 wmiref=nil
+	 operator=nil
+	 value=nil
+	 severity=nil
+
+    addwmiwin=Gtk::Window.new
+
+	 if mode
+		 if @wmiview.selection.selected == nil
+			return
+		 end
+		 title="Edit monitored WMI Ref"
+		 iter=@wmiview.selection.selected
+		 wmiref=iter[1]
+		 operator=iter[2]
+	    value=iter[3]
+	    severity=iter[4]
+  	 else
+		 title="Add monitored WMI Ref"
+    end
+
+    addwmiwin.set_title(title)
+    addwmiwin.set_size_request(340, -1)
+    addwmiwin.set_modal(true)
+
+    addwmiwin.signal_connect("key_press_event") {|w,e|
+      if e.keyval == Gdk::Keyval::GDK_Escape
+			addwmiwin.destroy
+      end
+    }
+
+    frame = Gtk::Frame::new
+    frame.border_width=10
+    frame.show
+    vbox_root=Gtk::VBox::new
+    vbox_root.show
+    addwmiwin.add vbox_root
+    vbox_root.add frame
+    vbox = Gtk::VBox.new
+    vbox.show
+    frame.add vbox
+
+    table = Gtk::Table.new(4,2,false)
+    table.show
+
+    label_wmiref = Gtk::Label.new "WMI Ref"
+    label_wmiref.show
+    entry_wmiref = Gtk::ComboBox.new
+    WMIRef::get_wmi_refs_name().each {|ref|
+            entry_wmiref.append_text(ref)
+    }
+    if wmiref
+       ind = WMIRef::get_wmi_refs_name().index(wmiref)
+       entry_wmiref.set_active(ind) if ind
+    else
+       entry_wmiref.set_active(0)
+    end
+    entry_wmiref.set_size_request(150, -1)
+    entry_wmiref.show
+    bbox=Gtk::HButtonBox.new
+    bbox.show
+    bbox.add entry_wmiref
+    table.attach(label_wmiref,0,1,0,1)
+    table.attach(bbox,1,2,0,1)
+
+	 label_operator = Gtk::Label.new "Operator"
+    label_operator.show
+  	 entry_operator = Gtk::ComboBox.new
+         WmiMonitoring::TESTOP.each {|ope|
+            entry_operator.append_text(ope)
+         }
+         if operator
+            ind = WmiMonitoring::TESTOP.index(operator)
+            entry_operator.set_active(ind) if ind
+         else
+            entry_operator.set_active(0)
+         end
+
+	 entry_operator.set_size_request(150, -1)
+	 entry_operator.show
+	 bbox=Gtk::HButtonBox.new
+	 bbox.show
+	 bbox.add entry_operator
+    table.attach(label_operator,0,1,1,2)
+    table.attach(bbox,1,2,1,2)
+
+	 entry_value = Gtk::Entry.new
+	 entry_value.set_text(value) unless value==nil
+    label_value = Gtk::Label.new "Value"
+	 label_value.show
+	 entry_value.set_size_request(150, -1)
+	 entry_value.show
+	 bbox=Gtk::HButtonBox.new
+	 bbox.show
+	 bbox.add entry_value
+    table.attach(label_value,0,1,2,3)
+    table.attach(bbox,1,2,2,3)
+
+	 label_sev = Gtk::Label.new "Severity"
+    label_sev.show
+  	 entry_sev = Gtk::ComboBox.new
+         $status[0..3].each {|sev|
+            entry_sev.append_text(sev)
+     }    
+   entry_sev.signal_connect("changed") {
+     entry_sev.child.set_background_gdk(@color_style[entry_sev.active])
+   }
+   ind = 0
+   if severity
+      ind = $status[0..3].index(severity)
+      entry_sev.set_active(ind) if ind
+   else
+      entry_sev.set_active(ind)            
+   end
+   entry_sev.child.set_background_gdk(@color_style[ind])        
+	 entry_sev.set_size_request(150, -1)
+	 entry_sev.show
+	 bbox=Gtk::HButtonBox.new
+	 bbox.show
+	 bbox.add entry_sev
+    table.attach(label_sev,0,1,3,4)
+    table.attach(bbox,1,2,3,4)
+
+    ok_button = Gtk::Button.new(Gtk::Stock::OK)
+    ok_button.show
+    ok_button.signal_connect("clicked") {
+		if mode
+			#here we just modify this service
+			iter=@wmiview.selection.selected
+			iter[1] = entry_wmiref.active_text
+			iter[2] = entry_operator.active_text
+			iter[3] = entry_value.text
+			iter[4] = entry_sev.active_text
+     		addwmiwin.destroy()
+		else
+			if entry_value.text != ""
+				#need to test if already exists
+				error_detected=0
+				@wmiview.model.each {|model, path, iter|
+				if "#{iter[1]}" == "#{entry_wmiref.active_text}"
+					error_detected=1
+					break
+				end
+				}
+				if error_detected == 0
+					iter=@wmiview.model.append
+					iter[0] = 1
+					iter[1] = entry_wmiref.active_text
+					iter[2] = entry_operator.active_text
+					iter[3] = entry_value.text
+					iter[4] = entry_sev.active_text
+    					addwmiwin.destroy()
+				else
+					 errorEntry(addwmiwin, "WMI Ref already set")
+				end
+			else
+				errorEntry(addwmiwin, "WMI Ref, you must set a value")
+			end
+		end
+    }
+
+    cancel_button = Gtk::Button.new(Gtk::Stock::CANCEL)
+    cancel_button.show
+    cancel_button.signal_connect("clicked") {
+  	    addwmiwin.destroy 
+    }
+
+	 bbox =Gtk::HBox::new(FALSE, 10)
+	 bbox.border_width=10
+	 bbox.show
+
+	 ok_button.set_flags(Gtk::Widget::CAN_DEFAULT)
+	 bbox.pack_start(ok_button, TRUE, TRUE, 0)
+	 cancel_button.set_flags(Gtk::Widget::CAN_DEFAULT)
+	 bbox.pack_start(cancel_button, TRUE, TRUE, 0)
+
+	 vbox.add(table)
+	 separator = Gtk::HSeparator::new()
+	 separator.show
+	 vbox_root.pack_start(separator, FALSE, TRUE, 0)
+	 vbox_root.pack_start(bbox, FALSE, TRUE, 0)
+
+    addwmiwin.show
+end
+
+def add_monitored_jmx(node, mode=nil)
+	jmxref=nil
+	protocol="rmi"
+	port=nil
+	auth=nil
+	jmxattr_h=Hash.new
+
+    addjmxwin=Gtk::Window.new
+
+	 if mode
+		 if @jmxview.selection.selected == nil
+			return
+		 end
+		 title="Edit monitored jmx Ref"
+		 iter=@jmxview.selection.selected
+		 jmxref=iter[1]
+		 protocol=iter[2].split("/")[0]
+	    	 port=iter[2].split("/")[1]
+		 auth=iter[3]
+  	 else
+		 title="Add monitored jmx Ref"
+    end
+
+    addjmxwin.set_title(title)
+    addjmxwin.set_size_request(340, 300)
+    addjmxwin.set_modal(true)
+
+    addjmxwin.signal_connect("key_press_event") {|w,e|
+      if e.keyval == Gdk::Keyval::GDK_Escape
+			addjmxwin.destroy
+      end
+    }
+
+    frame = Gtk::Frame::new
+    frame.border_width=10
+    frame.show
+    vbox_root=Gtk::VBox::new
+    vbox_root.show
+    addjmxwin.add vbox_root
+    vbox_root.add frame
+    vbox = Gtk::VBox.new
+    vbox.show
+    frame.add vbox
+
+    table = Gtk::Table.new(4,2,false)
+    table.show
+
+   label_jmxref = Gtk::Label.new "JMX Ref"
+   label_jmxref.show
+   entry_jmxref = Gtk::ComboBox.new
+   if mode 
+	entry_jmxref.set_sensitive(false)
+   end
+   JMXRef::get_jmx_refs_name().each {|ref|
+      entry_jmxref.append_text(ref)
+   }
+   if jmxref
+      ind = JMXRef::get_jmx_refs_name().index(jmxref)
+      entry_jmxref.set_active(ind) if ind
+   else
+      entry_jmxref.set_active(0)
+   end
+
+   entry_jmxref.set_size_request(150, -1)
+   entry_jmxref.show
+   bbox=Gtk::HButtonBox.new
+   bbox.show
+   bbox.add entry_jmxref
+   table.attach(label_jmxref,0,1,0,1)
+   table.attach(bbox,1,2,0,1)
+
+   entry_protocol = Gtk::Entry.new
+   entry_protocol.set_text(protocol) unless protocol==nil
+   entry_protocol.set_sensitive(false)
+   label_protocol = Gtk::Label.new "Protocol"
+   label_protocol.show
+   entry_protocol.set_size_request(150, -1)
+   entry_protocol.show
+   bbox=Gtk::HButtonBox.new
+   bbox.show
+   bbox.add entry_protocol
+   table.attach(label_protocol,0,1,1,2)
+   table.attach(bbox,1,2,1,2)
+
+   entry_port = Gtk::Entry.new
+   entry_port.set_text(port) unless port==nil
+   label_port = Gtk::Label.new "Port"
+   label_port.show
+   entry_port.set_size_request(150, -1)
+   entry_port.show
+   bbox=Gtk::HButtonBox.new
+   bbox.show
+   bbox.add entry_port
+   table.attach(label_port,0,1,2,3)
+   table.attach(bbox,1,2,2,3)
+
+   label_auth = Gtk::Label.new "Authentication"
+   label_auth.show
+   entry_auth = Gtk::ComboBox.new
+   node.get_all_account().keys.unshift("None").each {|authval|
+            entry_auth.append_text(authval)
+   }
+   if auth
+      ind = node.get_all_account().keys.unshift("None").index(auth)
+      entry_auth.set_active(ind) if ind
+   else
+      entry_auth.set_active(0)
+   end
+   entry_auth.set_size_request(150, -1)
+   entry_auth.show
+   bbox=Gtk::HButtonBox.new
+   bbox.show
+   bbox.add entry_auth
+   table.attach(label_auth,0,1,3,4)
+   table.attach(bbox,1,2,3,4)
+ 
+   jmxls = Gtk::TreeStore.new(String, String, String, String)
+   @jmxtv = Gtk::TreeView.new(jmxls)
+   @jmxtv_nb_entry=0
+
+	model=Gtk::ListStore.new(String)
+	$jmx_refs[entry_jmxref.active_text].attribute.split.each {|attr|
+		if attr != ""
+			iter = model.append
+			iter[0] = attr
+		end
+	}
+
+	model2=Gtk::ListStore.new(String)
+	JmxAttributeMonitoring::TESTOP.each {|op|
+		iter = model2.append
+		iter[0] = op
+	}
+
+	model4=Gtk::ListStore.new(String)
+	$status[0..3].each {|sev|
+		iter = model4.append
+		iter[0] = sev
+	}
+
+  renderer1=Gtk::CellRendererCombo.new
+  column1 = Gtk::TreeViewColumn.new("Attribute", renderer1, "text" => 0)
+  renderer1.model = model
+  renderer1.text_column = 0
+  renderer1.has_entry = false
+  renderer1.editable = true
+  renderer1.signal_connect('edited') do |w, path, new_text|
+    if path != ""
+      iter = @jmxtv.model.get_iter(path)
+      iter[0] = new_text
+    end
+  end
+  column1.set_sort_column_id(0)
+
+	renderer2=Gtk::CellRendererCombo.new
+	column2 = Gtk::TreeViewColumn.new("Operator", renderer2, "text" => 1)
+	column2.set_sort_column_id(1)
+	renderer2.model = model2
+	renderer2.text_column = 0
+  	renderer2.has_entry = false
+  	renderer2.editable = true
+	renderer2.signal_connect('edited') do |w, path, new_text|
+    		if path != ""
+			iter = @jmxtv.model.get_iter(path)
+        		iter[1] = new_text
+			jmxattr_h[iter[0]].set_operator(JmxAttributeMonitoring::TESTOP.index(new_text))
+      		end
+	end
+
+	def cell_jmx_attr_value_edited(cell, path_string, new_text, col, node, jmxattr_h)
+		iter = @jmxtv.model.get_iter(path_string)
+		iter[col] = new_text
+		jmxattr_h[iter[0]].set_value(new_text)
+	end
+
+	tr0=Gtk::CellRendererText.new
+	tr0.editable=true
+  tr0.mode=Gtk::CellRenderer::MODE_EDITABLE
+	tr0.signal_connect("edited") { |renderer, iter, var|
+		cell_jmx_attr_value_edited(renderer, iter, var, 2, node, jmxattr_h) 
+	}
+	column3 = Gtk::TreeViewColumn.new("Value", tr0, "text" => 2)
+	column3.set_sort_column_id(2)
+
+  renderer4=Gtk::CellRendererCombo.new
+  column4 = Gtk::TreeViewColumn.new("Severity", renderer4, "text" => 3)
+  column4.set_sort_column_id(3)
+  renderer4.model = model4
+  renderer4.text_column = 0
+  renderer4.has_entry = false
+  renderer4.editable = true
+  renderer4.signal_connect('edited') do |w, path, new_text|
+    if path != ""
+      iter = @jmxtv.model.get_iter(path)
+      iter[3] = new_text
+      jmxattr_h[iter[0]].set_severity($status.index(new_text))
+    end
+  end
+	
+	column4.set_cell_data_func(renderer4) do |col, renderer, model, iter|
+	  if iter[3] and iter[3] != ""
+	    renderer.set_background_gdk(@color_style[$status.index(iter[3])])
+	  else
+	    renderer.background = nil
+	  end
+        end
+
+	@jmxtv.append_column(column1)
+	@jmxtv.append_column(column2)
+	@jmxtv.append_column(column3)
+	@jmxtv.append_column(column4)
+
+	if mode
+		#load existing jmx attribute table
+		if node.jmx_monitoring[entry_jmxref.active_text]
+			attr_h=node.jmx_monitoring[entry_jmxref.active_text].get_attributes()
+			attr_h.each_value { |attr|
+				parent=jmxls.append(nil)
+				parent[0]=attr.attributeName
+				parent[1]=JmxAttributeMonitoring::TESTOP[attr.operator]
+				parent[2]=attr.value.to_s
+				parent[3]=$status[attr.severity]
+				jmxattr_h[parent[0]]=JmxAttributeMonitoring.new(parent[0], attr.operator, parent[2], attr.severity)
+				@jmxtv_nb_entry+=1
+			}
+		end
+	end
+	
+	#create menu
+	menu_jmx_attr = Gtk::Menu.new
+
+	item_add_jmx_attr = Gtk::ImageMenuItem.new("Add JMX Attribute")
+ 	image_item_add_jmx_attr = Gtk::Image.new()
+ 	image_item_add_jmx_attr.set_stock(Gtk::Stock::ADD)
+	item_add_jmx_attr.set_image(image_item_add_jmx_attr)
+	item_add_jmx_attr.signal_connect("activate") {
+		insert_jmx_attr_entry(node, jmxattr_h, entry_jmxref)
+	}
+	menu_jmx_attr.append(item_add_jmx_attr)
+
+	item_del_jmx_attr = Gtk::ImageMenuItem.new("Delete JMX Attribute")
+ 	image_item_del_jmx_attr = Gtk::Image.new() 
+ 	image_item_del_jmx_attr.set_stock(Gtk::Stock::REMOVE) 
+	item_del_jmx_attr.set_image(image_item_del_jmx_attr)
+	item_del_jmx_attr.signal_connect("activate") {|renderer, iter, var|
+		remove_selected_jmx_attr_entry(node, jmxattr_h, entry_jmxref)	
+	}
+	menu_jmx_attr.append(item_del_jmx_attr)
+	menu_jmx_attr.show_all
+	
+	@jmxtv.signal_connect("button_press_event") do |widget, event|
+		if event.kind_of? Gdk::EventButton and event.button == 3
+			menu_jmx_attr.popup(nil, nil, event.button, event.time)
+		end
+	end
+		
+	@jmxtv.signal_connect("key_press_event") {|w,e|
+    		if e.keyval == Gdk::Keyval::GDK_Delete
+			remove_selected_jmx_attr_entry(node, jmxattr_h, entry_jmxref)
+	    	elsif e.keyval == Gdk::Keyval::GDK_Insert
+			insert_jmx_attr_entry(node, jmxattr_h, entry_jmxref)
+		end
+	}
+
+ 	def insert_jmx_attr_entry(node, jmxattr_h, mbean)
+		if $jmx_refs[mbean.active_text].attribute.split.size > @jmxtv_nb_entry
+			iter=@jmxtv.model.append(nil)
+			val=""
+			$jmx_refs[mbean.active_text].attribute.split.each {|attr|
+				if !jmxattr_h[mbean.active_text]
+					val=attr
+					break
+				elsif !jmxattr_h[attr]
+					val=attr
+					break
+				end
+			}
+			if val != ""
+				#as we insert the attribute we blocked the mbean name
+				mbean.set_sensitive(false)
+				iter[0] = val
+				iter[1] = JmxAttributeMonitoring::TESTOP[0]
+				iter[2] = "0"
+				iter[3] = $status[0]
+				jmxattr_h[iter[0]]=JmxAttributeMonitoring.new(iter[0],0,iter[2],0)
+				@jmxtv_nb_entry+=1
+			end
+		end
+  	end
+	
+	def remove_selected_jmx_attr_entry(node, jmxattr_h, mbean)
+		if @jmxtv.selection.selected
+		    jmxattr_h.delete(@jmxtv.model.get_value(@jmxtv.selection.selected,0))
+		    @jmxtv.model.remove(@jmxtv.selection.selected)
+		    @jmxtv_nb_entry-=1
+		    if @jmxtv_nb_entry == 0
+		       mbean.set_sensitive(true)
+		    end
+		end
+	end
+		
+    ok_button = Gtk::Button.new(Gtk::Stock::OK)
+    ok_button.show
+    ok_button.signal_connect("clicked") {
+		if (entry_port.text != "") && (isInteger(entry_port.text))
+		   if mode
+			   #here we just modify this jmx ref
+			   iter=@jmxview.selection.selected
+			   iter[1] = entry_jmxref.active_text
+			   iter[2] = entry_protocol.text + "/" + entry_port.text
+			   iter[3] = entry_auth.active_text
+			   node.jmx_monitoring[entry_jmxref.active_text].set_protocol(entry_protocol.text)
+			   node.jmx_monitoring[entry_jmxref.active_text].set_port(entry_port.text)
+			   node.jmx_monitoring[entry_jmxref.active_text].set_auth(entry_auth.active_text)
+			   node.jmx_monitoring[entry_jmxref.active_text].clear_attributes()
+			   jmxattr_h.each_value {|attr|
+				node.jmx_monitoring[entry_jmxref.active_text].add_attribute(attr.attributeName, attr.operator, attr.value, attr.severity)
+			   }
+     			   addjmxwin.destroy()
+		   else
+			   #new entry
+			   list_rows = 0
+			   @jmxtv.model.each {|model, path, it|			   
+                           list_rows += 1
+			   if  "#{it[2]}" != ""
+				   #need to test if already exists
+				   error_detected=0
+				   @jmxview.model.each {|model, path, iter|
+				   if "#{iter[1]}" == "#{entry_jmxref.active_text}"
+					   error_detected=1
+					   break
+				   end
+				   }
+				   if error_detected == 0
+					   iter=@jmxview.model.append
+					   iter[0] = 1
+					   iter[1] = entry_jmxref.active_text
+					   iter[2] = entry_protocol.text + "/" + entry_port.text
+					   iter[3] = entry_auth.active_text
+					   
+					   node.add_jmx_monitoring(iter[0], iter[1], entry_protocol.text, entry_port.text, entry_auth.active_text, jmxattr_h)
+    					   addjmxwin.destroy()
+				   else
+					    errorEntry(addjmxwin, "jmx Ref already set")
+				   end
+			   else
+				   errorEntry(addjmxwin, "jmx Ref, you must set a value")
+			   end
+			   }
+			   errorEntry(addjmxwin, "jmx attributes not set") if list_rows == 0
+		   end
+		else
+			 entry_port.grab_focus()
+		         errorEntry(addjmxwin, "Port should be a valid integer")
+		end
+    }
+
+    cancel_button = Gtk::Button.new(Gtk::Stock::CANCEL)
+    cancel_button.show
+    cancel_button.signal_connect("clicked") {
+  	    addjmxwin.destroy 
+    }
+
+	 bbox =Gtk::HBox::new(FALSE, 10)
+	 bbox.border_width=10
+	 bbox.show
+
+	 ok_button.set_flags(Gtk::Widget::CAN_DEFAULT)
+	 bbox.pack_start(ok_button, TRUE, TRUE, 0)
+	 cancel_button.set_flags(Gtk::Widget::CAN_DEFAULT)
+	 bbox.pack_start(cancel_button, TRUE, TRUE, 0)
+
+	 vbox.add(table)
+	 vbox.add(@jmxtv)
+	 separator = Gtk::HSeparator::new()
+	 separator.show
+	 vbox_root.pack_start(separator, FALSE, TRUE, 0)
+	 vbox_root.pack_start(bbox, FALSE, TRUE, 0)
+
+    addjmxwin.show_all
+end
+
+def get_syslog_refs_left()
+	syslog_ref_list_local=[]
+	@syslogview.model.each {|model, path, iter|
+		syslog_ref_list_local.push(iter[1].dup().to_s())
+	}
+	syslog_ref_list_local=SyslogRef::get_syslog_refs_name()-syslog_ref_list_local
+	return syslog_ref_list_local
+end
+
+def add_monitored_snmptrap(mode=nil)
+	 snmptrapref=nil
+	 severity=nil
+
+	 #list already snmptrap ref configured
+	 snmptrap_ref_list=[]
+
+	 if mode
+		 if @snmptrapview.selection.selected == nil
+			return
+		 end
+		 title="Edit monitored SNMP Trap Ref"
+		 iter=@snmptrapview.selection.selected
+		 snmptrapref=iter[1]
+		 severity=iter[2]
+  	 else
+		title="Add monitored SNMP Trap Ref"
+		snmptrap_ref_list=get_snmptrap_refs_left()
+		if snmptrap_ref_list.size() == 0
+			return
+		end
+    end
+
+    addsnmptrapwin=Gtk::Window.new
+    addsnmptrapwin.set_title(title)
+    addsnmptrapwin.set_size_request(340, -1)
+    addsnmptrapwin.set_modal(true)
+
+    addsnmptrapwin.signal_connect("key_press_event") {|w,e|
+      if e.keyval == Gdk::Keyval::GDK_Escape
+			addsnmptrapwin.destroy
+      end
+    }
+
+    frame = Gtk::Frame::new
+    frame.border_width=10
+    frame.show
+    vbox_root=Gtk::VBox::new
+    vbox_root.show
+    addsnmptrapwin.add vbox_root
+    vbox_root.add frame
+    vbox = Gtk::VBox.new
+    vbox.show
+    frame.add vbox
+
+    table = Gtk::Table.new(4,2,false)
+    table.show
+
+    label_snmptrapref = Gtk::Label.new "SNMP Trap Ref"
+    label_snmptrapref.show
+    entry_snmptrapref = Gtk::ComboBox.new
+    snmp_trap_list=snmptrap_ref_list
+    if mode
+	     snmp_trap_list = SnmpTrapRef::get_snmptrap_refs_name()
+    end
+    snmp_trap_list.each {|slist|
+       entry_snmptrapref.append_text(slist)
+    }
+    if snmptrapref
+       ind = snmp_trap_list.index(snmptrapref)
+       entry_snmptrapref.set_active(ind) if ind
+    else
+       entry_snmptrapref.set_active(0)
+    end
+    entry_snmptrapref.set_size_request(150, -1)
+    entry_snmptrapref.show
+    bbox=Gtk::HButtonBox.new
+    bbox.show
+    bbox.add entry_snmptrapref
+    table.attach(label_snmptrapref,0,1,0,1)
+    table.attach(bbox,1,2,0,1)
+
+    label_sev = Gtk::Label.new "Severity"
+    label_sev.show
+    entry_sev = Gtk::ComboBox.new
+    $status[0..3].each {|sev|
+       entry_sev.append_text(sev)
+    }
+   entry_sev.signal_connect("changed") {
+     entry_sev.child.set_background_gdk(@color_style[entry_sev.active])
+   }
+   ind = 0
+   if severity
+      ind = $status[0..3].index(severity)
+      entry_sev.set_active(ind) if ind
+   else
+      entry_sev.set_active(ind)            
+   end
+   entry_sev.child.set_background_gdk(@color_style[ind])
+        
+    entry_sev.set_size_request(150, -1)
+    entry_sev.show
+    bbox=Gtk::HButtonBox.new
+    bbox.show
+    bbox.add entry_sev
+    table.attach(label_sev,0,1,1,2)
+    table.attach(bbox,1,2,1,2)
+
+    ok_button = Gtk::Button.new(Gtk::Stock::OK)
+    ok_button.show
+    ok_button.signal_connect("clicked") {
+		iter=nil
+		if mode
+			#here we just modify this service
+			iter=@snmptrapview.selection.selected
+		else
+			iter=@snmptrapview.model.append
+			iter[0] = 1
+		end
+		iter[1] = entry_snmptrapref.active_text
+		iter[2] = entry_sev.active_text
+                iter[3] = $snmptrap_refs[ entry_snmptrapref.active_text].description
+     	addsnmptrapwin.destroy()
+    }
+
+    cancel_button = Gtk::Button.new(Gtk::Stock::CANCEL)
+    cancel_button.show
+    cancel_button.signal_connect("clicked") {
+  	    addsnmptrapwin.destroy 
+    }
+
+	 bbox =Gtk::HBox::new(FALSE, 10)
+	 bbox.border_width=10
+	 bbox.show
+
+	 ok_button.set_flags(Gtk::Widget::CAN_DEFAULT)
+	 bbox.pack_start(ok_button, TRUE, TRUE, 0)
+	 cancel_button.set_flags(Gtk::Widget::CAN_DEFAULT)
+	 bbox.pack_start(cancel_button, TRUE, TRUE, 0)
+
+	 vbox.add(table)
+	 separator = Gtk::HSeparator::new()
+	 separator.show
+	 vbox_root.pack_start(separator, FALSE, TRUE, 0)
+	 vbox_root.pack_start(bbox, FALSE, TRUE, 0)
+
+    addsnmptrapwin.show
+end
+
+def get_snmptrap_refs_left()
+	snmptrap_ref_list=[]
+	@snmptrapview.model.each {|model, path, iter|
+		snmptrap_ref_list.push(iter[1].dup().to_s())
+	}
+	snmptrap_ref_list=SnmpTrapRef::get_snmptrap_refs_name()-snmptrap_ref_list
+	return snmptrap_ref_list
+end
+
+def add_monitored_syslog(mode=nil)
+  syslogpref=nil
+  severity=nil
+
+  #list already syslog ref configured
+  syslog_ref_list=[]
+
+  if mode
+    if @syslogview.selection.selected == nil
+      return
+    end
+    title="Edit monitored Syslog Ref"
+    iter=@syslogview.selection.selected
+    syslogpref=iter[1]
+    severity=iter[2]
+  else
+    title="Add monitored Syslog Ref"
+    syslog_ref_list=get_syslog_refs_left()
+    if syslog_ref_list.size() == 0
+      return
+    end
+  end
+
+  addsyslogwin=Gtk::Window.new
+  addsyslogwin.set_title(title)
+  addsyslogwin.set_size_request(340, -1)
+  addsyslogwin.set_modal(true)
+
+  addsyslogwin.signal_connect("key_press_event") {|w,e|
+    if e.keyval == Gdk::Keyval::GDK_Escape
+      addsyslogwin.destroy
+    end
+  }
+
+  frame = Gtk::Frame::new
+  frame.border_width=10
+  frame.show
+  vbox_root=Gtk::VBox::new
+  vbox_root.show
+  addsyslogwin.add vbox_root
+  vbox_root.add frame
+  vbox = Gtk::VBox.new
+  vbox.show
+  frame.add vbox
+
+  table = Gtk::Table.new(4,2,false)
+  table.show
+
+  label_oidref = Gtk::Label.new "Syslog Ref"
+  label_oidref.show
+  entry_oidref = Gtk::ComboBox.new
+  if mode
+    syslog_ref_list = SyslogRef::get_syslog_refs_name()
+  end
+
+  syslog_ref_list.each {|ref|
+    entry_oidref.append_text(ref)
+  }
+  if syslogpref
+    ind = syslog_ref_list.index(syslogpref)
+    entry_oidref.set_active(ind) if ind
+  else
+    entry_oidref.set_active(0)
+  end
+  entry_oidref.set_size_request(150, -1)
+  entry_oidref.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_oidref
+  table.attach(label_oidref,0,1,0,1)
+  table.attach(bbox,1,2,0,1)
+
+  label_sev = Gtk::Label.new "Severity"
+  label_sev.show
+  entry_sev = Gtk::ComboBox.new
+  sevs = [MAP_SYSLOG_SEV]+$status[0..3]
+  sevs.each {|sev|
+    entry_sev.append_text(sev)
+  }
+   entry_sev.signal_connect("changed") {
+     if entry_sev.active > 0
+        entry_sev.child.set_background_gdk(@color_style[entry_sev.active-1])
+     end
+   }
+   ind = 0
+   if severity
+      ind = sevs.index(severity)
+      entry_sev.set_active(ind) if ind
+   else
+      entry_sev.set_active(ind)            
+   end
+   if ind > 0
+      entry_sev.child.set_background_gdk(@color_style[ind-1])
+   end
+  
+  entry_sev.set_size_request(150, -1)
+  entry_sev.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_sev
+  table.attach(label_sev,0,1,1,2)
+  table.attach(bbox,1,2,1,2)
+
+  ok_button = Gtk::Button.new(Gtk::Stock::OK)
+  ok_button.show
+  ok_button.signal_connect("clicked") {
+    iter=nil
+    if mode
+      #here we just modify this service
+      iter=@syslogview.selection.selected
+    else
+      iter=@syslogview.model.append
+      iter[0] = 1
+    end
+    iter[1] = entry_oidref.active_text
+    iter[2] = entry_sev.active_text
+    iter[3] = $syslog_refs[entry_oidref.active_text].description
+    addsyslogwin.destroy()
+  }
+
+  cancel_button = Gtk::Button.new(Gtk::Stock::CANCEL)
+  cancel_button.show
+  cancel_button.signal_connect("clicked") {
+    addsyslogwin.destroy
+  }
+
+  bbox =Gtk::HBox::new(FALSE, 10)
+  bbox.border_width=10
+  bbox.show
+
+  ok_button.set_flags(Gtk::Widget::CAN_DEFAULT)
+  bbox.pack_start(ok_button, TRUE, TRUE, 0)
+  cancel_button.set_flags(Gtk::Widget::CAN_DEFAULT)
+  bbox.pack_start(cancel_button, TRUE, TRUE, 0)
+
+  vbox.add(table)
+  separator = Gtk::HSeparator::new()
+  separator.show
+  vbox_root.pack_start(separator, FALSE, TRUE, 0)
+  vbox_root.pack_start(bbox, FALSE, TRUE, 0)
+
+  addsyslogwin.show
+end
+
+def edit_monitored_service()
+	add_monitored_service("edit")
+end
+
+def edit_monitored_snmp()
+	add_monitored_snmp("edit")
+end
+
+def edit_monitored_wmi()
+	add_monitored_wmi("edit")
+end
+
+def edit_monitored_jmx(node)
+	add_monitored_jmx(node, "edit")
+end
+
+def edit_monitored_syslog()
+	add_monitored_syslog("edit")
+end
+def edit_monitored_snmptrap()
+	add_monitored_snmptrap("edit")
+end
+
+def fill_port_view(node)
+	@treeview.show
+	@vbox_ports.add(@treeview)
+	 row_mon_port=[]
+	 if @scanned_port_list != nil
+   	for x in 1..@scanned_port_list.size
+		  row=[]
+		  plattr=@scanned_port_list[x-1].split(/[\ ]+/)
+		  port=plattr[0].to_i()
+		  proto=plattr[1]
+		  name=plattr[2]
+
+		  #we verify if we monitor this port
+		  cbutton=0
+		  if node.is_service_monitor(proto, port)
+			  cbutton=1
+		  end
+		  if name == ""
+			  service = "?"
+		  else
+			  service = name
+		  end
+		  sev = $status[node.get_service_sev(proto, port)]
+		  @cbutton.push(cbutton)
+		  row.push(cbutton)			
+		  row.push(proto)
+		  row.push(port)
+		  row.push(service)
+		  row.push(sev)
+		  row_mon_port.push(row)
+	  end
+	end
+   row_mon_port.each do |cb, proto, port, service, sev|
+	  iter = @treeview.model.append
+	  iter[0] = cb
+	  iter[1] = proto
+	  iter[2] = port
+	  iter[3] = service
+	  iter[4] = sev
+	end
+end
+
+
+
+def fill_port_list(node)
+
+	#we need to append all monitored ports of service hash
+	#@scanned_port_list is ordered as udp first and port number ...
+	if node.service != nil
+     if @scanned_port_list == nil
+		  @scanned_port_list=[]
+		  node.service.sort{|s1,s2| s1[0].split('/')[1].to_i()<=>s2[0].split('/')[1].to_i()}.each {|w,serv|
+       	  str="#{serv.port} #{serv.protocol} "
+			  @scanned_port_list.push "#{str} #{serv.name}"
+		  }
+	  else
+   	 node.service.each_value {|serv|
+      	str="#{serv.port} #{serv.protocol} "
+      	if !include_regex_str("^#{str}",@scanned_port_list)
+      	  # we need to add it correctly
+			  plistbis=[]
+      	  i=0
+      	  for pt in @scanned_port_list
+         	 ptt = pt.split(/ /)
+         	 if ptt[1] == serv.protocol && serv.port.to_i < ptt[0].to_i
+            	plistbis.push "#{str} #{serv.name}"
+            	for port in @scanned_port_list[i..@scanned_port_list.size-1]
+            	  plistbis.push port
+            	end
+            	break
+         	 else
+            	if ptt[1] != serv.protocol
+            	  if serv.protocol == "udp"           
+	            	 plistbis.push "#{str} #{serv.name}"
+               	 for port in @scanned_port_list[i..@scanned_port_list.size-1]
+                  	plistbis.push port
+               	 end
+               	 break
+            	  else #its ptt[1] udp the first
+               	 plistbis.push pt
+            	  end
+            	else
+            	  plistbis.push pt
+            	end
+         	 end
+         	 i+=1
+      	  end
+      	  @scanned_port_list=plistbis
+		  end
+			}
+	  end
+	end
+end
+
+def scan_port_now(node)
+    
+	@scan_port_th=Thread.new {
+		labelwait=Gtk::Label.new("Waiting scanning ports ...")
+		labelwait.show
+		@treeview.hide
+		@vbox_ports.remove(@treeview)
+		@treeview.model.clear()
+		@vbox_ports.add(labelwait)
+		@scanned_port_list=listport(node.ip).split(/\n/)
+		fill_port_list(node)
+		labelwait.hide
+		@vbox_ports.remove(labelwait)
+		labelwait.destroy
+		fill_port_view(node)
+ }
+end
+
+
+###############################################################
+  def initialize (node)
+
+  @color_style = [$red, $orange, $yellow, $blue]
+  
+  window=Gtk::Window.new
+  #we need window to be a class variable to be accessible from account_frame sub error window
+  @window=window
+  window.set_transient_for($win)
+  window.set_title("Node property of "+node.ip+"/#{node.netmask}")
+  window.set_size_request(450, 450)
+  window.set_modal(true)
+  vboxb = Gtk::VBox::new
+  window.add vboxb
+  vboxb.show	
+
+  notebook = Gtk::Notebook::new()
+  notebook.set_tab_pos(Gtk::POS_TOP)
+  vboxb.add notebook
+  notebook.show
+
+################################ status tab #########
+
+  frame = Gtk::Frame::new
+  frame.border_width=10
+  frame.set_size_request(300, 290)
+  frame.show
+
+  vbox = Gtk::VBox::new(false,2)
+  vbox.show
+  frame.add vbox 
+
+  frame_st=Gtk::Frame.new("General")
+  frame_st.border_width=10
+  table_st = Gtk::Table.new(1,2,false)
+  table_st.show
+  label_status = Gtk::Label.new "Current"
+  label_status.show
+  entry_status = Gtk::Entry.new
+  tstyle=Gtk::Style.new
+  rgb=hexa_to_rgb_color($status_color[$status_value[node.status]])
+  tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
+  entry_status.set_style(tstyle)
+  entry_status.set_text($status[$status_value[node.status]])
+  entry_status.set_size_request(100, -1)
+  entry_status.set_xalign(0.5);
+  entry_status.set_editable false
+  entry_status.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_status
+  table_st.attach(label_status,0,1,0,1)
+  table_st.attach(bbox,1,2,0,1)
+  frame_st.add table_st
+  frame_st.show
+  vbox.add frame_st
+
+  frame_dt=Gtk::Frame.new("Details")
+  frame_dt.border_width=10
+  table = Gtk::Table.new(8,2,false)
+  table.show
+
+  label_avail = Gtk::Label.new "Availability"
+  label_avail.show
+  entry_avail = Gtk::Entry.new
+  tstyle=Gtk::Style.new
+  rgb=nil
+	rgb=hexa_to_rgb_color($status_color[$status_value.index(node.avail_sev)])
+  entry_avail.set_text($status[$status_value.index(node.avail_sev)])
+  tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
+  entry_avail.set_style(tstyle)
+  entry_avail.set_size_request(100, -1)
+  entry_avail.set_xalign(0.5);
+  entry_avail.set_editable false
+  entry_avail.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_avail
+  table.attach(label_avail,0,1,0,1)
+  table.attach(bbox,1,2,0,1)
+    
+  label_service = Gtk::Label.new "Service"
+  label_service.show
+  entry_service = Gtk::Entry.new
+  tstyle=Gtk::Style.new
+  rgb=nil
+  if $config.port_mon
+   rgb=hexa_to_rgb_color($status_color[$status_value.index(node.service_sev)])
+   entry_service.set_text($status[$status_value.index(node.service_sev)])
+  else
+   rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
+   entry_service.set_text($status[$status_value.index(UNMANAGED)])
+  end
+  tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
+  entry_service.set_style(tstyle)
+  entry_service.set_size_request(100, -1)
+  entry_service.set_xalign(0.5);
+  entry_service.set_editable false
+  entry_service.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_service
+  table.attach(label_service,0,1,1,2)
+  table.attach(bbox,1,2,1,2)
+
+  label_snmp = Gtk::Label.new "SNMP"
+  label_snmp.show
+  entry_snmp = Gtk::Entry.new
+  tstyle=Gtk::Style.new
+  rgb=nil
+  if $config.snmp_mon
+	  rgb=hexa_to_rgb_color($status_color[$status_value.index(node.snmp_sev)])
+	  entry_snmp.set_text($status[$status_value.index(node.snmp_sev)])
+	else
+	  rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
+	  entry_snmp.set_text($status[$status_value.index(UNMANAGED)])
+	end
+  tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
+  entry_snmp.set_style(tstyle)
+
+  entry_snmp.set_size_request(100, -1)
+  entry_snmp.set_xalign(0.5);
+  entry_snmp.set_editable false
+  entry_snmp.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_snmp
+  table.attach(label_snmp,0,1,2,3)
+  table.attach(bbox,1,2,2,3)
+
+  label_wmi = Gtk::Label.new "WMI"
+  label_wmi.show
+  entry_wmi = Gtk::Entry.new
+  tstyle=Gtk::Style.new
+  rgb=nil
+  if $config.wmi_mon
+	  rgb=hexa_to_rgb_color($status_color[$status_value.index(node.wmi_sev)])
+	  entry_wmi.set_text($status[$status_value.index(node.wmi_sev)])
+	else
+	  rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
+	  entry_wmi.set_text($status[$status_value.index(UNMANAGED)])
+	end
+  tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
+  entry_wmi.set_style(tstyle)
+
+  entry_wmi.set_size_request(100, -1)
+  entry_wmi.set_xalign(0.5);
+  entry_wmi.set_editable false
+  entry_wmi.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_wmi
+  table.attach(label_wmi,0,1,3,4)
+  table.attach(bbox,1,2,3,4)
+  
+  label_jmx = Gtk::Label.new "JMX"
+  label_jmx.show
+  entry_jmx = Gtk::Entry.new
+  tstyle=Gtk::Style.new
+  rgb=nil
+  if $config.jmx_mon
+	  rgb=hexa_to_rgb_color($status_color[$status_value.index(node.jmx_sev)])
+	  entry_jmx.set_text($status[$status_value.index(node.jmx_sev)])
+	else
+	  rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
+	  entry_jmx.set_text($status[$status_value.index(UNMANAGED)])
+	end
+  tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
+  entry_jmx.set_style(tstyle)
+
+  entry_jmx.set_size_request(100, -1)
+  entry_jmx.set_xalign(0.5);
+  entry_jmx.set_editable false
+  entry_jmx.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_jmx
+  table.attach(label_jmx,0,1,4,5)
+  table.attach(bbox,1,2,4,5)
+  
+  label_custom = Gtk::Label.new "Custom"
+  label_custom.show
+  entry_custom = Gtk::Entry.new
+  tstyle=Gtk::Style.new
+	rgb=nil
+	if $config.custom_mon
+	  rgb=hexa_to_rgb_color($status_color[$status_value.index(node.custom_sev)])
+	  entry_custom.set_text($status[$status_value.index(node.custom_sev)])
+	else
+	  rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
+	  entry_custom.set_text($status[$status_value.index(UNMANAGED)])
+	end
+  tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
+  entry_custom.set_style(tstyle)
+
+  entry_custom.set_size_request(100, -1)
+  entry_custom.set_xalign(0.5)
+  entry_custom.set_editable false
+  entry_custom.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_custom
+  table.attach(label_custom,0,1,5,6)
+  table.attach(bbox,1,2,5,6)
+
+  label_syslog = Gtk::Label.new "Syslog"
+  label_syslog.show
+  entry_syslog = Gtk::Entry.new
+  tstyle=Gtk::Style.new
+	rgb=nil
+	if $config.syslog_mon
+	  rgb=hexa_to_rgb_color($status_color[$status_value.index(node.syslog_sev)])
+	  entry_syslog.set_text($status[$status_value.index(node.syslog_sev)])
+	else
+	  rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
+	  entry_syslog.set_text($status[$status_value.index(UNMANAGED)])
+	end
+  tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
+  entry_syslog.set_style(tstyle)
+  entry_syslog.set_size_request(100, -1)
+  entry_syslog.set_xalign(0.5)
+  entry_syslog.set_editable false
+  entry_syslog.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_syslog
+  table.attach(label_syslog,0,1,6,7)
+  table.attach(bbox,1,2,6,7)
+  
+  label_trap = Gtk::Label.new "SNMP Trap"
+  label_trap.show
+  entry_trap = Gtk::Entry.new
+  tstyle=Gtk::Style.new
+	rgb=nil
+	if $config.snmptrap_mon
+	  rgb=hexa_to_rgb_color($status_color[$status_value.index(node.trap_sev)])
+	  entry_trap.set_text($status[$status_value.index(node.trap_sev)])
+	else
+	  rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
+	  entry_trap.set_text($status[$status_value.index(UNMANAGED)])
+	end
+  tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
+  entry_trap.set_style(tstyle)
+  entry_trap.set_size_request(100, -1)
+  entry_trap.set_xalign(0.5)
+  entry_trap.set_editable false
+  entry_trap.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_trap
+  table.attach(label_trap,0,1,7,8)
+  table.attach(bbox,1,2,7,8)
+
+  frame_dt.add table
+  frame_dt.show
+  vbox.add frame_dt
+
+  #update node sev periodically
+  refresh_node_sev_display=Thread.new {
+	while (window != nil) do
+		  sleep(10)
+		  begin
+		  rgb=hexa_to_rgb_color($status_color[$status_value[node.status]])
+		  Gtk.thread_protect do
+		  tstyle=Gtk::Style.new
+		  tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
+		  entry_status.set_style(tstyle)
+		  entry_status.set_text($status[$status_value[node.status]])
+		
+      rgb=nil
+			rgb=hexa_to_rgb_color($status_color[$status_value.index(node.avail_sev)])
+			entry_avail.set_text($status[$status_value.index(node.avail_sev)])	
+		  tstyle=Gtk::Style.new
+		  tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
+		  entry_avail.set_style(tstyle)
+      
+      rgb=nil
+			if $config.port_mon
+			  rgb=hexa_to_rgb_color($status_color[$status_value.index(node.service_sev)])
+			  entry_service.set_text($status[$status_value.index(node.service_sev)])	
+			else
+			   rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
+			   entry_service.set_text($status[$status_value.index(UNMANAGED)])
+			end
+		  tstyle=Gtk::Style.new
+		  tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
+		  entry_service.set_style(tstyle)
+	
+		  rgb=nil
+		  if $config.snmp_mon || $config.wmi_mon
+		  	rgb=hexa_to_rgb_color($status_color[$status_value.index(node.snmp_sev)])
+		  	entry_snmp.set_text($status[$status_value.index(node.snmp_sev)])
+		  else
+		  	rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
+		  	entry_snmp.set_text($status[$status_value.index(UNMANAGED)])
+		  end
+		  tstyle=Gtk::Style.new
+		  tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
+		  entry_snmp.set_style(tstyle)
+
+		  rgb=nil
+		  if $config.wmi_mon
+		  	rgb=hexa_to_rgb_color($status_color[$status_value.index(node.wmi_sev)])
+		  	entry_wmi.set_text($status[$status_value.index(node.wmi_sev)])
+		  else
+		  	rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
+		  	entry_wmi.set_text($status[$status_value.index(UNMANAGED)])
+		  end
+		  tstyle=Gtk::Style.new
+		  tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
+		  entry_wmi.set_style(tstyle)      
+      
+		  rgb=nil
+		  if $config.jmx_mon
+		  	rgb=hexa_to_rgb_color($status_color[$status_value.index(node.jmx_sev)])
+		  	entry_jmx.set_text($status[$status_value.index(node.jmx_sev)])
+		  else
+		  	rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
+		  	entry_jmx.set_text($status[$status_value.index(UNMANAGED)])
+		  end
+		  tstyle=Gtk::Style.new
+		  tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
+		  entry_jmx.set_style(tstyle)
+      
+		  rgb=nil
+			if $config.custom_mon
+		  		rgb=hexa_to_rgb_color($status_color[$status_value.index(node.custom_sev)])
+		 	 	entry_custom.set_text($status[$status_value.index(node.custom_sev)])
+			else
+			  rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
+			  entry_custom.set_text($status[$status_value.index(UNMANAGED)])
+			end
+		  tstyle=Gtk::Style.new
+		  tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
+		  entry_custom.set_style(tstyle)
+      
+      rgb=nil
+			if $config.syslog_mon
+		  		rgb=hexa_to_rgb_color($status_color[$status_value.index(node.syslog_sev)])
+		 	 	entry_syslog.set_text($status[$status_value.index(node.syslog_sev)])
+			else
+			  rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
+			  entry_syslog.set_text($status[$status_value.index(UNMANAGED)])
+			end
+		  tstyle=Gtk::Style.new
+		  tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
+		  entry_syslog.set_style(tstyle)      
+
+			rgb=nil
+			if $config.snmptrap_mon
+		 		rgb=hexa_to_rgb_color($status_color[$status_value.index(node.trap_sev)])
+		  		entry_trap.set_text($status[$status_value.index(node.trap_sev)])
+			else
+			  rgb=hexa_to_rgb_color($status_color[$status_value.index(UNMANAGED)])
+			  entry_trap.set_text($status[$status_value.index(UNMANAGED)])
+			end
+		  tstyle=Gtk::Style.new
+		  tstyle.set_base(Gtk::STATE_NORMAL, rgb.red, rgb.green, rgb.blue)
+		  entry_trap.set_style(tstyle)
+		  end
+		  rescue Exception => msg
+			$log.debug("Exception in refresh_node_sev_display for #{node.ip}: #{msg}")
+		end
+	end
+  }
+
+	hbox = Gtk::HBox.new(FALSE, 1)
+	hbox.add Gtk::Image.new(Gtk::Stock::DIALOG_WARNING, Gtk::IconSize::MENU)
+	hbox.add Gtk::Label::new("Status")
+	hbox.show_all
+	notebook.append_page frame, hbox
+  
+    window.signal_connect("key_press_event") {|w,e|
+    if e.keyval == Gdk::Keyval::GDK_Escape
+		#we rollback here the account from the db to the @account hash
+		node.init_account_from_db()
+		Thread.kill(@scan_port_th) unless @scan_port_th == nil
+		Gtk.thread_flush
+		Thread.kill(refresh_node_sev_display)
+		Gtk.thread_flush
+		window.destroy
+    end
+  }
+
+#########################################################################
+
+#  frame = Gtk::Frame::new
+#  frame.border_width=10
+#  frame.show
+
+  notebook_info = Gtk::Notebook::new()
+  notebook_info.show
+
+  frame_stored = Gtk::Frame::new
+  frame_stored.border_width=10
+  frame_stored.set_size_request(300, 290)
+  frame_stored.show
+
+  table = Gtk::Table.new(10,2,false)
+  table.show
+  
+  vbox = Gtk::VBox.new
+  vbox.show
+  frame_stored.add vbox
+  vbox.add table
+
+  label_icon = Gtk::Label.new "Icon"
+  label_icon.show
+  entry_type =  Gtk::ImageComboList.new("type", "#{node.type}")
+  entry_type.set_size_request(200, -1)
+  entry_type.show
+
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_type
+
+  table.attach(label_icon,0,1,0,1)
+  table.attach(bbox,1,2,0,1)
+
+  label_xy = Gtk::Label.new "X:Y"
+  label_xy.show
+  entry_x = Gtk::Entry.new
+  entry_x.set_editable false  
+  entry_x.set_text "#{node.x.to_i}"
+  entry_x.set_size_request(96, -1)
+  entry_x.show
+  bbox=Gtk::HButtonBox.new
+  bbox.set_layout_style Gtk::ButtonBox::EDGE
+  bbox.show
+  bbox.add entry_x
+  table.attach(label_xy,0,1,1,2)
+
+  entry_y = Gtk::Entry.new
+  entry_y.set_editable false
+  entry_y.set_text "#{node.y.to_i}"
+  entry_y.set_size_request(96, -1)
+  entry_y.show
+
+  bbox.add entry_y
+
+  table.attach(bbox,1,2,1,2,Gtk::EXPAND)
+  
+  label_ip = Gtk::Label.new "IP"
+  label_ip.show
+  entry_ip = Gtk::Entry.new
+  entry_ip.set_editable false
+  entry_ip.set_text(node.ip)
+  entry_ip.set_size_request(200, -1)
+  entry_ip.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_ip
+
+  table.attach(label_ip,0,1,2,3)
+  table.attach(bbox,1,2,2,3)
+
+  label_mask = Gtk::Label.new "Mask"
+  label_mask.show
+  entry_mask = Gtk::Entry.new
+  entry_mask.set_text node.netmask.to_s
+  entry_mask.set_size_request(200, -1)
+  entry_mask.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_mask
+
+  table.attach(label_mask,0,1,3,4)
+  table.attach(bbox,1,2,3,4)
+
+  label_map = Gtk::Label.new "Network"
+  label_map.show
+  entry_map = Gtk::Entry.new
+  entry_map.set_editable false
+  entry_map.set_text(node.map)
+  entry_map.set_size_request(200, -1)
+  entry_map.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_map
+
+  table.attach(label_map,0,1,4,5)
+  table.attach(bbox,1,2,4,5)
+
+  label_mac = Gtk::Label.new "MAC"
+  label_mac.show
+  entry_mac = Gtk::Entry.new
+  entry_mac.set_text(node.mac)
+  entry_mac.set_size_request(200, -1)
+  entry_mac.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_mac
+  table.attach(label_mac,0,1,5,6)
+  table.attach(bbox,1,2,5,6)
+
+  label_name = Gtk::Label.new "DNS Name"
+  label_name.show
+  entry_name = Gtk::Entry.new
+  #local host can have name filled by facter and not the dns_name
+  if node.hostname?() and !node.dns_name?()
+     entry_name.set_text(node.name)
+  else
+     entry_name.set_text(node.dns_name)
+  end
+  entry_name.set_size_request(200, -1)
+  entry_name.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_name
+
+  table.attach(label_name,0,1,6,7)
+  table.attach(bbox,1,2,6,7)
+
+  label_netbiosname = Gtk::Label.new "Netbios Name"
+  label_netbiosname.show
+  entry_netbiosname = Gtk::Entry.new
+  entry_netbiosname.set_text(node.netbios_name)
+  entry_netbiosname.set_size_request(200, -1)
+  entry_netbiosname.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_netbiosname
+
+  table.attach(label_netbiosname,0,1,7,8)
+  table.attach(bbox,1,2,7,8)
+
+  label_os = Gtk::Label.new "OS"
+  label_os.show
+  entry_os =  Gtk::ImageComboList.new("os", "#{node.os}")
+  entry_os.set_size_request(200, -1)
+  entry_os.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_os
+
+  table.attach(label_os,0,1,8,9)
+  table.attach(bbox,1,2,8,9)
+  
+  label_desc = Gtk::Label.new "Description"
+  label_desc.show
+  entry_desc = Gtk::Entry.new
+  entry_desc.set_text(node.description)
+  entry_desc.set_size_request(200, -1)
+  entry_desc.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_desc
+
+  table.attach(label_desc,0,1,9,10)
+  table.attach(bbox,1,2,9,10)
+
+  hbox = Gtk::HBox.new(FALSE, 1)
+  hbox.add Gtk::Image.new(Gtk::Stock::INFO, Gtk::IconSize::MENU)
+  hbox.add Gtk::Label::new("Information")
+  hbox.show_all
+
+  notebook_info.append_page frame_stored, Gtk::Label::new("Stored")
+
+########## SNMP tab
+
+  frame_snmp_info = Gtk::Frame::new
+  frame_snmp_info.border_width=10
+  frame_snmp_info.set_size_request(300, 290)
+  frame_snmp_info.show
+
+  table = Gtk::Table.new(5,2,false)
+  table.show
+  frame_snmp_info.add table
+
+  label_desc = Gtk::Label.new "Description"
+  label_desc.show
+  entry_descsnmp = Gtk::Entry.new
+  entry_descsnmp.set_editable false
+  
+  def snmp_description(entry, node, read_community)
+	if $config.snmp_mon		
+		entry.set_text "(polling...)"
+		Thread.start {
+   		val=get_snmp_description(node)
+		Gtk.thread_protect do
+			begin
+			   	entry.set_position 0
+				entry.set_text val
+			rescue Exception => msg
+				$log.debug("Exception in snmp_description for #{node.ip}: #{msg}")
+			end
+		end
+	  	}
+	 else
+		Gtk.thread_protect do
+	 		begin
+				entry.set_sensitive(false)
+			   	entry.set_text "(SNMP is disable)"
+			rescue
+				$log.debug("Exception in snmp_description for #{node.ip}: #{msg}")		
+			end
+		end
+	 end
+  end
+   if node.get_account_id("snmp")
+  	  login, password = node.get_account_id("snmp") 
+	  snmp_description(entry_descsnmp, node, login)
+	end
+  entry_descsnmp.set_size_request(200, -1)
+  entry_descsnmp.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_descsnmp
+
+  table.attach(label_desc,0,1,0,1)
+  table.attach(bbox,1,2,0,1)
+
+  label_uptime = Gtk::Label.new "Uptime"
+  label_uptime.show
+  entry_uptime = Gtk::Entry.new
+  entry_uptime.set_editable false
+  def snmp_uptime(entry, node, read_community)
+	 if $config.snmp_mon
+	     entry.set_text "(polling...)"
+	  Thread.start {
+   		val=get_snmp_uptime(node)
+		Gtk.thread_protect do
+			begin
+		   		entry.set_position 0
+				entry.set_text val
+			rescue Exception => msg
+				$log.debug("Exception in snmp_uptime for #{node.ip}: #{msg}")			
+			end
+		end
+	  }
+	 else
+		begin
+			entry.set_sensitive(false)
+	   		entry.set_text "(SNMP is disable)"
+		rescue Exception => msg
+			$log.debug("Exception in snmp_uptime for #{node.ip}: #{msg}")
+		end
+	 end
+  end
+  if node.get_account_id("snmp")
+  	  login, password = node.get_account_id("snmp")
+	  snmp_uptime(entry_uptime, node, login)
+  end
+	entry_uptime.set_size_request(200, -1)
+  entry_uptime.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_uptime
+
+  table.attach(label_uptime,0,1,1,2)
+  table.attach(bbox,1,2,1,2)
+
+  label_contact = Gtk::Label.new "Contact"
+  label_contact.show
+  entry_contact = Gtk::Entry.new
+  entry_contact.set_editable false
+  def snmp_contact(entry, node, read_community)
+	 if $config.snmp_mon
+     entry.set_text "(polling...)"
+	  Thread.start {
+	   	val=get_snmp_contact(node)
+		Gtk.thread_protect do
+			begin
+	   			entry.set_position 0
+				entry.set_text val
+			rescue Exception => msg
+				$log.debug("Exception in snmp_contact for #{node.ip}: #{msg}")
+			end
+		end
+	  }
+	 else
+	 	Gtk.thread_protect do
+			begin
+				entry.set_sensitive(false)
+		   		entry.set_text "(SNMP is disable)"
+			rescue Exception => msg
+				$log.debug("Exception in snmp_contact for #{node.ip}: #{msg}")
+			end
+		end
+
+	 end
+  end
+  if node.get_account_id("snmp")
+  	  login, password = node.get_account_id("snmp")
+	  snmp_contact(entry_contact, node, login)
+	end
+  entry_contact.set_size_request(200, -1)
+  entry_contact.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_contact
+
+  table.attach(label_contact,0,1,2,3)
+  table.attach(bbox,1,2,2,3)
+  label_location = Gtk::Label.new "Location"
+  label_location.show
+  entry_location = Gtk::Entry.new
+  entry_location.set_editable false
+  def snmp_location(entry, node, read_community)
+	 if $config.snmp_mon
+     entry.set_text "(polling...)"
+	  Thread.start {
+	   	val=get_snmp_location(node)
+		Gtk.thread_protect do
+			begin
+		   		entry.set_position 0
+				entry.set_text val
+			rescue Exception => msg
+				$log.debug("Exception in snmp_location for #{node.ip}: #{msg}")
+			end
+		end
+	  }
+	 else
+		Gtk.thread_protect do
+	 		begin
+				entry.set_sensitive(false)
+			   	entry.set_text "(SNMP is disable)"
+			rescue Exception => msg
+				$log.debug("Exception in snmp_location for #{node.ip}: #{msg}")
+			end
+		end
+	 end
+  end
+  if node.get_account_id("snmp")
+  	  login, password = node.get_account_id("snmp")
+		snmp_location(entry_location, node, login)
+	end
+  entry_location.set_size_request(200, -1)
+  entry_location.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_location
+
+  table.attach(label_location,0,1,3,4)
+  table.attach(bbox,1,2,3,4)
+
+  hbbox=Gtk::HButtonBox.new
+  refresh_button = Gtk::Button.new(Gtk::Stock::REFRESH)
+  if !$config.snmp_mon
+	refresh_button.set_sensitive false
+  end
+  hbbox.add refresh_button
+  hbbox.show
+
+  refresh_button.signal_connect("clicked") do
+	if node.get_account_id("snmp")
+		login, password = node.get_account_id("snmp")
+	  	snmp_description(entry_descsnmp, node, login)
+		snmp_uptime(entry_uptime, node, login)
+		snmp_contact(entry_contact, node, login)
+		snmp_location(entry_location, node, login)
+	end
+  end
+
+  refresh_button.show
+  table.attach(hbbox,1,2,4,5)
+
+  notebook_info.append_page frame_snmp_info, Gtk::Label::new("SNMP")
+
+########## WMI tab, info from Win32_ComputerSystem and Win32_OperatingSystem
+
+  frame_wmi_info = Gtk::Frame::new
+  frame_wmi_info.border_width=10
+  frame_wmi_info.set_size_request(300, 290)
+  frame_wmi_info.show
+
+  table = Gtk::Table.new(8,2,false)
+  table.show
+  frame_wmi_info.add table
+
+  label_desc = Gtk::Label.new "Description"
+  label_desc.show
+  entry_descwmi = Gtk::Entry.new
+  entry_descwmi.set_editable false
+  
+  def wmi_description(entry, node, login ,pass)
+	if $config.wmi_mon		
+		entry.set_text "(polling...)"
+		Thread.start {
+   		val=get_wmi_description(login, pass, node.ip)
+			if val
+				Gtk.thread_protect do
+					begin
+					   	entry.set_position 0
+						entry.set_text val
+					rescue Exception => msg
+						$log.debug("Exception in wmi_description for #{node.ip}: #{msg}")
+					end
+				end
+			end
+	  	}
+	 else
+	 	begin
+			entry.set_sensitive(false)
+			entry.set_text "(WMI is disable)"
+		rescue
+		end
+	 end
+  end
+  if node.get_account_id("wmi")
+  	  login, password = node.get_account_id("wmi")
+	  wmi_description(entry_descwmi, node, login, password)
+  end
+  entry_descwmi.set_size_request(200, -1)
+  entry_descwmi.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_descwmi
+
+  table.attach(label_desc,0,1,0,1)
+  table.attach(bbox,1,2,0,1)
+
+  label_boot = Gtk::Label.new "Bootup State"
+  label_boot.show
+  entry_bootwmi = Gtk::Entry.new
+  entry_bootwmi.set_editable false
+  
+  def wmi_boot(entry, node, login ,pass)
+	if $config.wmi_mon		
+		entry.set_text "(polling...)"
+		Thread.start {
+   		val=get_wmi_boot_state(login, pass, node.ip)
+			if val
+				Gtk.thread_protect do
+					begin
+						entry.set_position 0
+						entry.set_text val
+					rescue Exception => msg
+						$log.debug("Exception in wmi_boot for #{node.ip}: #{msg}")
+					end
+				end
+			end
+	  	}
+	 else
+	 	Gtk.thread_protect do
+		 	begin
+				entry.set_sensitive(false)
+				entry.set_text "(WMI is disable)"
+			rescue
+			end
+		end
+	 end
+  end
+
+  if node.get_account_id("wmi")
+  	  login, password = node.get_account_id("wmi")
+	  wmi_boot(entry_bootwmi, node, login, password)
+  end
+  entry_bootwmi.set_size_request(200, -1)
+  entry_bootwmi.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_bootwmi
+
+  table.attach(label_boot,0,1,1,2)
+  table.attach(bbox,1,2,1,2)
+
+  label_thermal = Gtk::Label.new "Thermal State"
+  label_thermal.show
+  entry_thermalwmi = Gtk::Entry.new
+  entry_thermalwmi.set_editable false
+  
+  def wmi_thermal(entry, node, login ,pass)
+	if $config.wmi_mon		
+		entry.set_text "(polling...)"
+		Thread.start {
+   		val=get_wmi_thermal_state(login, pass, node.ip)
+			if val
+				Gtk.thread_protect do
+					begin
+				   		entry.set_position 0
+						entry.set_text val
+					rescue Exception => msg
+						$log.debug("Exception in wmi_thermal for #{node.ip}: #{msg}")
+					end
+				end
+			end
+	  	}
+	 else
+	 	begin
+			entry.set_sensitive(false)
+			entry.set_text "(WMI is disable)"
+		rescue
+		end
+	 end
+  end
+
+  if node.get_account_id("wmi")
+  	  login, password = node.get_account_id("wmi")
+	  wmi_thermal(entry_thermalwmi, node, login, password)
+  end
+  entry_thermalwmi.set_size_request(200, -1)
+  entry_thermalwmi.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_thermalwmi
+
+  table.attach(label_thermal,0,1,2,3)
+  table.attach(bbox,1,2,2,3)
+  
+  label_nbproc = Gtk::Label.new "Processor Number"
+  label_nbproc.show
+  entry_nbprocwmi = Gtk::Entry.new
+  entry_nbprocwmi.set_editable false
+  
+  def wmi_nbproc(entry, node, login ,pass)
+	if $config.wmi_mon		
+		entry.set_text "(polling...)"
+		Thread.start {
+   		val=get_wmi_nb_proc(login, pass, node.ip)
+			if val
+				Gtk.thread_protect do
+					begin
+					   	entry.set_position 0
+						entry.set_text val
+					rescue Exception => msg
+						$log.debug("Exception in wmi_nbproc for #{node.ip}: #{msg}")
+					end
+				end
+			end
+	  	}
+	 else
+	 	begin
+			entry.set_sensitive(false)
+			entry.set_text "(WMI is disable)"
+		rescue
+		end
+	 end
+  end
+
+  if node.get_account_id("wmi")
+  	  login, password = node.get_account_id("wmi")
+	  wmi_nbproc(entry_nbprocwmi, node, login, password)
+  end
+  entry_nbprocwmi.set_size_request(200, -1)
+  entry_nbprocwmi.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_nbprocwmi
+
+  table.attach(label_nbproc,0,1,3,4)
+  table.attach(bbox,1,2,3,4)
+  
+  label_systype = Gtk::Label.new "System Type"
+  label_systype.show
+  entry_systype = Gtk::Entry.new
+  entry_systype.set_editable false
+  
+  def wmi_systype(entry, node, login ,pass)
+	if $config.wmi_mon		
+		entry.set_text "(polling...)"
+		Thread.start {
+   		val=get_wmi_system_type(login, pass, node.ip)
+			if val
+				Gtk.thread_protect do
+					begin
+					   	entry.set_position 0
+						entry.set_text val
+					rescue Exception => msg
+						$log.debug("Exception in wmi_systype for #{node.ip}: #{msg}")
+					end
+				end
+			end
+	  	}
+	 else
+	 	begin
+			entry.set_sensitive(false)
+			entry.set_text "(WMI is disable)"
+		rescue
+		end
+	 end
+  end
+
+  if node.get_account_id("wmi")
+  	  login, password = node.get_account_id("wmi")
+	  wmi_systype(entry_systype, node, login, password)
+  end
+  entry_systype.set_size_request(200, -1)
+  entry_systype.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_systype
+
+  table.attach(label_systype,0,1,4,5)
+  table.attach(bbox,1,2,4,5)
+
+  label_oswmi = Gtk::Label.new "OS"
+  label_oswmi.show
+  entry_oswmi = Gtk::Entry.new
+  entry_oswmi.set_editable false
+  
+  def wmi_os(entry, node, login ,pass)
+	if $config.wmi_mon		
+		entry.set_text "(polling...)"
+		Thread.start {
+   		val=get_wmi_os(login, pass, node.ip)
+		if val
+			Gtk.thread_protect do
+				begin
+				   	entry.set_position 0
+					entry.set_text val
+				rescue Exception => msg
+					$log.debug("Exception in wmi_os for #{node.ip}: #{msg}")
+				end
+			end
+		end
+	  	}
+	 else
+	 	begin
+			entry.set_sensitive(false)
+			entry.set_text "(WMI is disable)"
+		rescue
+		end
+	 end
+  end
+
+  if node.get_account_id("wmi")
+  	  login, password = node.get_account_id("wmi")
+	  wmi_os(entry_oswmi, node, login, password)
+  end
+  entry_oswmi.set_size_request(200, -1)
+  entry_oswmi.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_oswmi
+
+  table.attach(label_oswmi,0,1,5,6)
+  table.attach(bbox,1,2,5,6)
+
+  label_producttype = Gtk::Label.new "Product Type"
+  label_producttype.show
+  entry_producttype = Gtk::Entry.new
+  entry_producttype.set_editable false
+  
+  def wmi_producttype(entry, node, login ,pass)
+	if $config.wmi_mon		
+		entry.set_text "(polling...)"
+		Thread.start {
+   		val=get_wmi_product_type(login, pass, node.ip)
+		if val
+			Gtk.thread_protect do
+				begin
+				   	entry.set_position 0
+					entry.set_text val
+				rescue Exception => msg
+					$log.debug("Exception in wmi_producttype for #{node.ip}: #{msg}")
+				end
+			end
+		end
+	  	}
+	 else
+	 	begin
+			entry.set_sensitive(false)
+			entry.set_text "(WMI is disable)"
+		rescue
+		end
+	 end
+  end
+
+  if node.get_account_id("wmi")
+  	  login, password = node.get_account_id("wmi")
+	  wmi_producttype(entry_producttype, node, login, password)
+  end
+  entry_producttype.set_size_request(200, -1)
+  entry_producttype.show
+  bbox=Gtk::HButtonBox.new
+  bbox.show
+  bbox.add entry_producttype
+
+  table.attach(label_producttype,0,1,6,7)
+  table.attach(bbox,1,2,6,7)
+
+  hbbox=Gtk::HButtonBox.new
+  refresh_button_wmi = Gtk::Button.new(Gtk::Stock::REFRESH)
+  if !$config.wmi_mon
+	refresh_button_wmi.set_sensitive false
+  end
+  hbbox.add refresh_button_wmi
+  hbbox.show
+
+  refresh_button_wmi.signal_connect("clicked") do
+	if node.get_account_id("wmi")
+		login, password = node.get_account_id("wmi")
+		wmi_description(entry_descwmi, node, login, password)
+	  	wmi_boot(entry_bootwmi, node, login, password)
+	  	wmi_thermal(entry_thermalwmi, node, login, password)
+	  	wmi_nbproc(entry_nbprocwmi, node, login, password)
+		wmi_systype(entry_systype, node, login, password)		
+		wmi_os(entry_oswmi, node, login, password)
+		wmi_producttype(entry_producttype, node, login, password)
+	end
+  end
+
+  refresh_button_wmi.show
+  table.attach(hbbox,1,2,7,8)
+  
+  
+  notebook_info.append_page frame_wmi_info, Gtk::Label::new("WMI")
+
+  notebook.append_page notebook_info, hbox
+
+###############################Account conf########################
+
+eval IO.read("#{GNMSLIB}"+'/gui/sub/account_frame.rb')
+
+########### begin port monitoring #################################
+
+  frame = Gtk::Frame::new
+  frame.border_width=10
+  frame.show
+
+  vvbox = Gtk::VBox::new
+  vvbox.show
+  vvbox.add frame
+
+  vbox = Gtk::VBox::new(false,3)
+  vbox.show
+  frame.add vbox  
+
+  @vbox_ports = Gtk::VBox::new
+  @vbox_ports.show
+
+  #scrolled_window.add_with_viewport(vbox_ports)
+  #vbox_ports.set_focus_vadjustment(scrolled_window.vadjustment)
+  #scrolled_window.show
+  vbox.add @vbox_ports
+  @scan_port_th=nil
+  @cbutton=[]
+  @scanned_port_list=nil
+  
+######################## nmap thread ##################################
+
+   ls = Gtk::ListStore.new(Integer, String, Integer, String, String)
+   @treeview = Gtk::TreeView.new(ls)
+
+   renderer = Gtk::CellRendererToggle.new
+   renderer.signal_connect('toggled') do |cell, path|
+	  # get toggled iter
+	  iter = @treeview.model.get_iter(path)
+	  fixed =iter[0]
+	  # do something with the value
+	  fixed ^= 1
+	  @cbutton[path.to_i()]=fixed
+	  # set new value
+	  iter[0] = fixed
+   end
+
+	column1 = Gtk::TreeViewColumn.new("Selected",
+					 renderer, {:active => 0})
+	column1.set_clickable(true)
+	column2 = Gtk::TreeViewColumn.new("Protocol",
+					 Gtk::CellRendererText.new, {:text => 1})
+	column2.set_sort_column_id(1)
+	column3 = Gtk::TreeViewColumn.new("Port",
+					 Gtk::CellRendererText.new, {:text => 2})
+	column3.set_sort_column_id(2)
+	column4 = Gtk::TreeViewColumn.new("Service",
+					 Gtk::CellRendererText.new, {:text => 3})
+	column4.set_sort_column_id(3)
+	sev_renderer = Gtk::CellRendererText.new
+        column5 = Gtk::TreeViewColumn.new("Severity", sev_renderer, {:text => 4})
+        column5.set_sort_column_id(4)
+	
+	column5.set_cell_data_func(sev_renderer) do |col, renderer, model, iter|
+	  if iter[4] and iter[4] != ""
+	    renderer.set_background_gdk(@color_style[$status.index(iter[4])])
+	  else
+	    renderer.background = nil
+	  end
+        end
+	
+	column1.signal_connect("clicked") do |column|
+		toggle_select_port()
+	end  
+
+	@treeview.append_column(column1)
+	@treeview.append_column(column2)
+	@treeview.append_column(column3)
+	@treeview.append_column(column4)
+	@treeview.append_column(column5)
+	@treeview.show
+
+	# Create a menu
+	menu_port = Gtk::Menu.new
+
+	item_add_serv = Gtk::ImageMenuItem.new("Add service")
+ 	image_item_add_serv = Gtk::Image.new() 
+ 	image_item_add_serv.set_stock(Gtk::Stock::ADD) 
+	item_add_serv.set_image(image_item_add_serv)
+	item_add_serv.signal_connect("activate") { add_monitored_service() }
+	menu_port.append(item_add_serv)
+
+	item_del_serv = Gtk::ImageMenuItem.new("Delete selected service")
+ 	image_item_del_serv = Gtk::Image.new() 
+ 	image_item_del_serv.set_stock(Gtk::Stock::REMOVE) 
+	item_del_serv.set_image(image_item_del_serv)
+	item_del_serv.signal_connect("activate") {
+		@treeview.model.remove(@treeview.selection.selected) unless @treeview.selection.selected==nil
+	}
+	menu_port.append(item_del_serv)
+
+	item_edit_serv = Gtk::ImageMenuItem.new("Edit service")
+ 	image_item_edit_serv = Gtk::Image.new() 
+ 	image_item_edit_serv.set_stock(Gtk::Stock::EDIT) 
+	item_edit_serv.set_image(image_item_edit_serv)
+	item_edit_serv.signal_connect("activate") { edit_monitored_service() }
+	menu_port.append(item_edit_serv)
+
+	scan_port_serv = Gtk::ImageMenuItem.new("Scan ports")
+ 	image_scan_port_serv = Gtk::Image.new() 
+ 	image_scan_port_serv.set_stock(Gtk::Stock::REFRESH) 
+	scan_port_serv.set_image(image_scan_port_serv)
+	scan_port_serv.signal_connect("activate") { scan_port_now(node) }
+	menu_port.append(scan_port_serv)
+
+	item_sw_serv = Gtk::MenuItem.new("Switch selection")
+	item_sw_serv.signal_connect("activate") { toggle_select_port() }
+	menu_port.append(item_sw_serv)
+	menu_port.show_all
+
+        @treeview.signal_connect("key_press_event") do |tview,e|
+	   if e.keyval == Gdk::Keyval::GDK_Delete
+	      tview.model.remove(tview.selection.selected) unless tview.selection.selected==nil
+	   end
+	end
+
+	@treeview.signal_connect("button_press_event") do |widget, event|
+	  if event.kind_of? Gdk::EventButton and event.button == 3
+		 if @treeview.selection.selected==nil 
+			 item_edit_serv.set_sensitive(false)
+			 item_del_serv.set_sensitive(false)
+
+		 else
+			 item_edit_serv.set_sensitive(true)
+			 item_del_serv.set_sensitive(true)
+		 end
+   	 menu_port.popup(nil, nil, event.button, event.time)
+	  elsif (@treeview.selection.selected!=nil) && (event.event_type == Gdk::Event::BUTTON2_PRESS)
+		edit_monitored_service()	
+	  end
+	end
+
+  fill_port_list(node)
+  fill_port_view(node)
+
+  if !($config.port_mon && $config.nmap_path != "")
+	 @treeview.set_sensitive false
+	 @treeview.show
+	 frame.set_label("This monitoring is disabled")
+  end
+
+  notebook_inside = Gtk::Notebook::new()
+  label_port = Gtk::Label::new("Service")
+  notebook_inside.append_page(vvbox, label_port)
+  notebook_inside.show
+
+######################### snmp oid monitoring ###################################################################
+
+  frame = Gtk::Frame::new
+  frame.border_width=10
+  frame.set_size_request(300, 290)
+  frame.show
+
+  vbox = Gtk::VBox::new
+  vbox.show
+  frame.add vbox
+
+  snmp_ls = Gtk::ListStore.new(Integer, String, String, String, String)
+  @snmpview = Gtk::TreeView.new(snmp_ls)
+
+   renderer_snmp = Gtk::CellRendererToggle.new
+   renderer_snmp.signal_connect('toggled') do |cell, path|
+	  # get toggled iter
+	  iter = @snmpview.model.get_iter(path)
+	  fixed =iter[0]
+	  # do something with the value
+	  fixed ^= 1
+	  # set new value
+	  iter[0] = fixed
+   end
+
+  if !$config.snmp_mon
+	 @snmpview.set_sensitive false
+	 frame.set_label("This monitoring is disabled")
+  end
+
+  if OIDRef::oid_ref_nb_entry() == 0
+  	 @snmpview.set_sensitive false
+	 frame.set_label("No SNMP OID defined, go in Tools menu")
+  end
+
+  column1 = Gtk::TreeViewColumn.new("Selected",
+					renderer_snmp, {:active => 0})
+  column1.set_clickable(true)
+  column2 = Gtk::TreeViewColumn.new("OID label",
+					Gtk::CellRendererText.new, {:text => 1})
+  column2.set_sort_column_id(1)
+  column3 = Gtk::TreeViewColumn.new("Operator",
+					Gtk::CellRendererText.new, {:text => 2})
+  column3.set_sort_column_id(2)
+  tr=Gtk::CellRendererText.new
+  tr.mode=Gtk::CellRenderer::MODE_EDITABLE
+  column4 = Gtk::TreeViewColumn.new("Threshold",
+					tr, {:text => 3})
+  column4.set_sort_column_id(3)
+  sev_renderer = Gtk::CellRendererText.new
+  column5 = Gtk::TreeViewColumn.new("Severity",	sev_renderer, {:text => 4})
+  column5.set_sort_column_id(4)
+
+  column5.set_cell_data_func(sev_renderer) do |col, renderer, model, iter|
+    if iter[4] and iter[4] != ""
+      renderer.set_background_gdk(@color_style[$status.index(iter[4])])
+    else
+      renderer.background = nil
+    end
+  end
+
+  @snmpview.append_column(column1)
+  @snmpview.append_column(column2)
+  @snmpview.append_column(column3)
+  @snmpview.append_column(column4)
+  @snmpview.append_column(column5)
+  @snmpview.show
+
+	# Create a menu
+	menu_snmp = Gtk::Menu.new
+
+	item_add_snmp = Gtk::ImageMenuItem.new("Add SNMP Ref")
+ 	image_item_add_snmp = Gtk::Image.new() 
+ 	image_item_add_snmp.set_stock(Gtk::Stock::ADD) 
+	item_add_snmp.set_image(image_item_add_snmp)
+	item_add_snmp.signal_connect("activate") { add_monitored_snmp() unless OIDRef::get_oid_refs_name().size() == 0 }
+	menu_snmp.append(item_add_snmp)
+
+	item_del_snmp = Gtk::ImageMenuItem.new("Delete selected SNMP Ref")
+ 	image_item_del_snmp = Gtk::Image.new() 
+ 	image_item_del_snmp.set_stock(Gtk::Stock::REMOVE) 
+	item_del_snmp.set_image(image_item_del_snmp)
+	item_del_snmp.signal_connect("activate") {
+		@snmpview.model.remove(@snmpview.selection.selected) unless @snmpview.selection.selected==nil
+	}
+	menu_snmp.append(item_del_snmp)
+
+	item_edit_snmp = Gtk::ImageMenuItem.new("Edit SNMP Ref")
+ 	image_edit_snmp = Gtk::Image.new() 
+ 	image_edit_snmp.set_stock(Gtk::Stock::EDIT) 
+	item_edit_snmp.set_image(image_edit_snmp)
+	item_edit_snmp.signal_connect("activate") { edit_monitored_snmp() }
+	menu_snmp.append(item_edit_snmp)
+
+	menu_snmp.show_all
+
+	@snmpview.signal_connect("button_press_event") do |widget, event|
+	  if event.kind_of? Gdk::EventButton and event.button == 3
+		if @snmpview.selection.selected==nil 
+			item_edit_snmp.set_sensitive(false)
+			item_del_snmp.set_sensitive(false)
+		else
+			item_edit_snmp.set_sensitive(true)
+			item_del_snmp.set_sensitive(true)
+		end
+		if OIDRef::get_oid_refs_name().size() > 0
+			item_add_snmp.set_sensitive(true)
+		else
+			item_add_snmp.set_sensitive(false)
+		end
+   	menu_snmp.popup(nil, nil, event.button, event.time)
+	  elsif (@snmpview.selection.selected!=nil) && (event.event_type == Gdk::Event::BUTTON2_PRESS)
+		edit_monitored_snmp()	
+	  end
+	end
+
+	#populate with saved values
+   node.snmp_monitoring.each_value do |snmp_mon|
+	  iter = snmp_ls.append
+	  iter[0] = snmp_mon.get_state()
+	  iter[1] = snmp_mon.oidref
+	  iter[2] = snmp_mon.oper
+	  iter[3] = snmp_mon.threshold.to_s
+	  iter[4] = snmp_mon.severity
+	end
+
+	vbox.add(@snmpview)
+
+  label_snmp = Gtk::Label::new("SNMP")
+  notebook_inside.append_page frame, label_snmp
+
+######################### end snmp oid monitoring ##########################################################
+
+######################### wmi monitoring ###################################################################
+
+  frame = Gtk::Frame::new
+  frame.border_width=10
+  frame.set_size_request(300, 290)
+  frame.show
+
+  vbox = Gtk::VBox::new
+  vbox.show
+  frame.add vbox
+
+  wmi_ls = Gtk::ListStore.new(Integer, String, String, String, String)
+  @wmiview = Gtk::TreeView.new(wmi_ls)
+
+   renderer_wmi = Gtk::CellRendererToggle.new
+   renderer_wmi.signal_connect('toggled') do |cell, path|
+	  # get toggled iter
+	  iter = @wmiview.model.get_iter(path)
+	  fixed =iter[0]
+	  # do something with the value
+	  fixed ^= 1
+	  # set new value
+	  iter[0] = fixed
+   end
+
+  if !$config.wmi_mon
+	 @wmiview.set_sensitive false
+	 frame.set_label("This monitoring is disabled")
+  end
+
+  if WMIRef::wmi_ref_nb_entry() == 0
+  	 @wmiview.set_sensitive false
+	 frame.set_label("No WMI request defined, go in Tools menu")
+  end
+
+  column1 = Gtk::TreeViewColumn.new("Selected",
+					renderer_wmi, {:active => 0})
+  column1.set_clickable(true)
+  column2 = Gtk::TreeViewColumn.new("WMI label",
+					Gtk::CellRendererText.new, {:text => 1})
+  column2.set_sort_column_id(1)
+  column3 = Gtk::TreeViewColumn.new("Operator",
+					Gtk::CellRendererText.new, {:text => 2})
+  column3.set_sort_column_id(2)
+  tr=Gtk::CellRendererText.new
+  tr.mode=Gtk::CellRenderer::MODE_EDITABLE
+  column4 = Gtk::TreeViewColumn.new("Threshold",
+					tr, {:text => 3})
+  column4.set_sort_column_id(3)
+  sev_renderer = Gtk::CellRendererText.new
+  column5 = Gtk::TreeViewColumn.new("Severity", sev_renderer, {:text => 4})
+  column5.set_sort_column_id(4)
+  
+  column5.set_cell_data_func(sev_renderer) do |col, renderer, model, iter|
+    if iter[4] and iter[4] != ""
+      renderer.set_background_gdk(@color_style[$status.index(iter[4])])
+    else
+      renderer.background = nil
+    end
+  end
+
+  @wmiview.append_column(column1)
+  @wmiview.append_column(column2)
+  @wmiview.append_column(column3)
+  @wmiview.append_column(column4)
+  @wmiview.append_column(column5)
+  @wmiview.show
+
+	# Create a popup menu
+	menu_wmi = Gtk::Menu.new
+
+	item_add_wmi = Gtk::ImageMenuItem.new("Add WMI Ref")
+ 	image_item_add_wmi = Gtk::Image.new()
+ 	image_item_add_wmi.set_stock(Gtk::Stock::ADD)
+	item_add_wmi.set_image(image_item_add_wmi)
+	item_add_wmi.signal_connect("activate") { add_monitored_wmi() unless WMIRef::get_wmi_refs_name().size() == 0 }
+	menu_wmi.append(item_add_wmi)
+
+	item_del_wmi = Gtk::ImageMenuItem.new("Delete selected WMI Ref")
+ 	image_item_del_wmi = Gtk::Image.new() 
+ 	image_item_del_wmi.set_stock(Gtk::Stock::REMOVE) 
+	item_del_wmi.set_image(image_item_del_wmi)
+	item_del_wmi.signal_connect("activate") {
+		@wmiview.model.remove(@wmiview.selection.selected) unless @wmiview.selection.selected==nil
+	}
+	menu_wmi.append(item_del_wmi)
+
+	item_edit_wmi = Gtk::ImageMenuItem.new("Edit WMI Ref")
+ 	image_edit_wmi = Gtk::Image.new() 
+ 	image_edit_wmi.set_stock(Gtk::Stock::EDIT) 
+	item_edit_wmi.set_image(image_edit_wmi)
+	item_edit_wmi.signal_connect("activate") { edit_monitored_wmi() }
+	menu_wmi.append(item_edit_wmi)
+
+	menu_wmi.show_all
+
+	@wmiview.signal_connect("button_press_event") do |widget, event|
+	  if event.kind_of? Gdk::EventButton and event.button == 3
+		if @wmiview.selection.selected==nil 
+			item_edit_wmi.set_sensitive(false)
+			item_del_wmi.set_sensitive(false)
+		else
+			item_edit_wmi.set_sensitive(true)
+			item_del_wmi.set_sensitive(true)
+		end
+		if WMIRef::get_wmi_refs_name().size() > 0
+			item_add_wmi.set_sensitive(true)
+		else
+			item_add_wmi.set_sensitive(false)
+		end
+   	menu_wmi.popup(nil, nil, event.button, event.time)
+	  elsif (@wmiview.selection.selected!=nil) && (event.event_type == Gdk::Event::BUTTON2_PRESS)
+		edit_monitored_wmi()	
+	  end
+	end
+
+	#populate with saved values
+   node.wmi_monitoring.each_value do |wmi_mon|
+	  iter = wmi_ls.append
+	  iter[0] = wmi_mon.get_state()
+	  iter[1] = wmi_mon.wmiref
+	  iter[2] = wmi_mon.oper
+	  iter[3] = wmi_mon.value.to_s
+	  iter[4] = wmi_mon.severity
+	end
+
+	vbox.add(@wmiview)
+
+  label_wmi = Gtk::Label::new("WMI")
+  notebook_inside.append_page frame, label_wmi
+
+###########################end wmi monitoring#####################################################################
+
+######################### jmx monitoring ###################################################################
+
+  frame = Gtk::Frame::new
+  frame.border_width=10
+  frame.set_size_request(300, 290)
+  frame.show
+
+  vbox = Gtk::VBox::new
+  vbox.show
+  frame.add vbox
+
+  jmx_ls = Gtk::ListStore.new(Integer, String, String, String)
+  @jmxview = Gtk::TreeView.new(jmx_ls)
+
+   renderer_jmx = Gtk::CellRendererToggle.new
+   renderer_jmx.signal_connect('toggled') do |cell, path|
+	  # get toggled iter
+	  iter = @jmxview.model.get_iter(path)
+	  fixed =iter[0]
+	  # do something with the value
+	  fixed ^= 1
+	  # set new value
+	  iter[0] = fixed
+	  node.jmx_monitoring[iter[1]].set_state(fixed.to_i)
+   end
+
+  if !$config.jmx_mon
+	 @jmxview.set_sensitive false
+	 frame.set_label("This monitoring is disabled")
+  end
+
+  if JMXRef::jmx_ref_nb_entry() == 0
+  	 @jmxview.set_sensitive false
+	 frame.set_label("No jmx request defined, go in Tools menu")
+  end
+
+  column1 = Gtk::TreeViewColumn.new("Selected",
+					renderer_jmx, {:active => 0})
+  column1.set_clickable(true)
+  column2 = Gtk::TreeViewColumn.new("Label",
+					Gtk::CellRendererText.new, {:text => 1})
+  column2.set_sort_column_id(1)
+  column3 = Gtk::TreeViewColumn.new("Protocol/Port",
+					Gtk::CellRendererText.new, {:text => 2})
+  column3.set_sort_column_id(2)
+  column4 = Gtk::TreeViewColumn.new("Auth",
+					Gtk::CellRendererText.new, {:text => 3})
+  column4.set_sort_column_id(3)
+
+  @jmxview.append_column(column1)
+  @jmxview.append_column(column2)
+  @jmxview.append_column(column3)
+  @jmxview.append_column(column4)
+  @jmxview.show
+
+	# Create a popup menu
+	menu_jmx = Gtk::Menu.new
+
+	item_add_jmx = Gtk::ImageMenuItem.new("Add JMX Ref")
+ 	image_item_add_jmx = Gtk::Image.new()
+ 	image_item_add_jmx.set_stock(Gtk::Stock::ADD)
+	item_add_jmx.set_image(image_item_add_jmx)
+	item_add_jmx.signal_connect("activate") { add_monitored_jmx(node) unless JMXRef::get_jmx_refs_name().size() == 0 }
+	menu_jmx.append(item_add_jmx)
+
+	item_del_jmx = Gtk::ImageMenuItem.new("Delete selected JMX Ref")
+ 	image_item_del_jmx = Gtk::Image.new() 
+ 	image_item_del_jmx.set_stock(Gtk::Stock::REMOVE) 
+	item_del_jmx.set_image(image_item_del_jmx)
+	item_del_jmx.signal_connect("activate") {
+		@jmxview.model.remove(@jmxview.selection.selected) unless @jmxview.selection.selected==nil
+	}
+	menu_jmx.append(item_del_jmx)
+
+	item_edit_jmx = Gtk::ImageMenuItem.new("Edit JMX Ref")
+ 	image_edit_jmx = Gtk::Image.new() 
+ 	image_edit_jmx.set_stock(Gtk::Stock::EDIT) 
+	item_edit_jmx.set_image(image_edit_jmx)
+	item_edit_jmx.signal_connect("activate") { edit_monitored_jmx(node) }
+	menu_jmx.append(item_edit_jmx)
+
+	menu_jmx.show_all
+
+	@jmxview.signal_connect("button_press_event") do |widget, event|
+	  if event.kind_of? Gdk::EventButton and event.button == 3
+		if @jmxview.selection.selected==nil 
+			item_edit_jmx.set_sensitive(false)
+			item_del_jmx.set_sensitive(false)
+		else
+			item_edit_jmx.set_sensitive(true)
+			item_del_jmx.set_sensitive(true)
+		end
+		if JMXRef::get_jmx_refs_name().size() > 0
+			item_add_jmx.set_sensitive(true)
+		else
+			item_add_jmx.set_sensitive(false)
+		end
+   	menu_jmx.popup(nil, nil, event.button, event.time)
+	  elsif (@jmxview.selection.selected!=nil) && (event.event_type == Gdk::Event::BUTTON2_PRESS)
+		edit_monitored_jmx(node)	
+	  end
+	end
+
+	#populate with saved values
+   node.jmx_monitoring.each_value do |jmx_mon|
+	  iter = jmx_ls.append
+	  iter[0] = jmx_mon.get_state()
+	  iter[1] = jmx_mon.get_ref()
+	  iter[2] = "#{jmx_mon.get_protocol()}/#{jmx_mon.get_port()}"
+	  iter[3] = jmx_mon.get_auth()
+	end
+
+	vbox.add(@jmxview)
+
+  label_jmx = Gtk::Label::new("JMX")
+  notebook_inside.append_page frame, label_jmx
+
+###########################end jmx monitoring#####################################################################
+
+######################### snmp trap monitoring ###################################################################
+
+  frame = Gtk::Frame::new
+  frame.border_width=10
+  frame.set_size_request(300, 290)
+  frame.show
+
+  vbox = Gtk::VBox::new
+  vbox.show
+  frame.add vbox
+
+  snmp_trap_ls = Gtk::ListStore.new(Integer, String, String, String)
+  @snmptrapview = Gtk::TreeView.new(snmp_trap_ls)
+  @snmptrapview.set_tooltip_column(3)  
+
+   renderer_snmp = Gtk::CellRendererToggle.new
+   renderer_snmp.signal_connect('toggled') do |cell, path|
+	  # get toggled iter
+	  iter = @snmptrapview.model.get_iter(path)
+	  fixed =iter[0]
+	  # do something with the value
+	  fixed ^= 1
+	  # set new value
+	  iter[0] = fixed
+   end
+
+  if !$config.snmptrap_mon
+ 	 @snmptrapview.set_sensitive false
+	 frame.set_label("This monitoring is disabled")
+  end
+
+  column1 = Gtk::TreeViewColumn.new("Selected",
+					renderer_snmp, {:active => 0})
+  column1.set_clickable(true)
+  column2 = Gtk::TreeViewColumn.new("Trap label",
+					Gtk::CellRendererText.new, {:text => 1})
+  column2.set_sort_column_id(1)
+  sev_renderer = Gtk::CellRendererText.new
+  column3 = Gtk::TreeViewColumn.new("Severity",	sev_renderer, {:text => 2})
+  column4 = Gtk::TreeViewColumn.new("Description",
+					Gtk::CellRendererText.new, {:text => 3})          
+  column4.visible = false
+  column3.set_cell_data_func(sev_renderer) do |col, renderer, model, iter|
+    if iter[2] and iter[2] != ""
+      renderer.set_background_gdk(@color_style[$status.index(iter[2])])
+    else
+      renderer.background = nil
+    end
+  end
+
+  @snmptrapview.append_column(column1)
+  @snmptrapview.append_column(column2)
+  @snmptrapview.append_column(column3)
+  @snmptrapview.append_column(column4)
+  @snmptrapview.show
+
+	# Create a menu
+	menu_snmptrap = Gtk::Menu.new
+	item_add_snmptrap = Gtk::ImageMenuItem.new("Add SNMP Trap")
+ 	image_item_add_snmptrap = Gtk::Image.new() 
+ 	image_item_add_snmptrap.set_stock(Gtk::Stock::ADD) 
+	item_add_snmptrap.set_image(image_item_add_snmptrap)
+	item_add_snmptrap.signal_connect("activate") { add_monitored_snmptrap() unless SnmpTrapRef::get_snmptrap_refs_name().size() == 0 }
+	menu_snmptrap.append(item_add_snmptrap)
+
+	item_del_snmptrap = Gtk::ImageMenuItem.new("Delete selected SNMP Trap")
+ 	image_item_del_snmptrap = Gtk::Image.new() 
+ 	image_item_del_snmp.set_stock(Gtk::Stock::REMOVE) 
+	item_del_snmptrap.set_image(image_item_del_snmptrap)
+	item_del_snmptrap.signal_connect("activate") {
+		@snmptrapview.model.remove(@snmptrapview.selection.selected) unless @snmptrapview.selection.selected==nil
+	}
+	menu_snmptrap.append(item_del_snmptrap)
+
+	item_edit_snmptrap = Gtk::ImageMenuItem.new("Edit SNMP Trap")
+ 	image_edit_snmptrap = Gtk::Image.new() 
+ 	image_edit_snmptrap.set_stock(Gtk::Stock::EDIT) 
+	item_edit_snmptrap.set_image(image_edit_snmptrap)
+	item_edit_snmptrap.signal_connect("activate") { edit_monitored_snmp() }
+	menu_snmptrap.append(item_edit_snmptrap)
+
+	menu_snmptrap.show_all
+
+	@snmptrapview.signal_connect("button_press_event") do |widget, event|
+	  if event.kind_of? Gdk::EventButton and event.button == 3
+		if @snmptrapview.selection.selected==nil 
+			item_edit_snmptrap.set_sensitive(false)
+			item_del_snmptrap.set_sensitive(false)
+		else
+			item_edit_snmptrap.set_sensitive(true)
+			item_del_snmptrap.set_sensitive(true)
+		end
+		if SnmpTrapRef::get_snmptrap_refs_name().size() > 0 && get_snmptrap_refs_left().size() > 0
+			item_add_snmptrap.set_sensitive(true)
+		else
+			item_add_snmptrap.set_sensitive(false)
+		end
+   	menu_snmptrap.popup(nil, nil, event.button, event.time)
+	  elsif (@snmptrapview.selection.selected!=nil) && (event.event_type == Gdk::Event::BUTTON2_PRESS)
+		edit_monitored_snmptrap()	
+	  end
+	end
+
+	#populate with saved values
+   node.snmptrap_monitoring.each_value do |snmptrap_mon|
+	  iter = snmp_trap_ls.append
+	  iter[0] = snmptrap_mon.get_state()
+	  iter[1] = snmptrap_mon.get_snmptrap_ref()
+	  iter[2] = snmptrap_mon.severity()
+          iter[3] = $snmptrap_refs[snmptrap_mon.get_snmptrap_ref()].description
+	end
+
+	vbox.add(@snmptrapview)
+
+  label_snmptrap = Gtk::Label::new("SNMP trap")
+  notebook_inside.append_page frame, label_snmptrap
+
+###########################end snmp trap monitoring############################################################
+
+######################### syslog monitoring ###################################################################
+
+  frame = Gtk::Frame::new
+  frame.border_width=10
+  frame.set_size_request(300, 290)
+  frame.show
+
+  vbox = Gtk::VBox::new
+  vbox.show
+  frame.add vbox
+
+  syslog_ls = Gtk::ListStore.new(Integer, String, String, String)
+  @syslogview = Gtk::TreeView.new(syslog_ls)
+  @syslogview.set_tooltip_column(3)  
+
+   renderer_syslog = Gtk::CellRendererToggle.new
+   renderer_syslog.signal_connect('toggled') do |cell, path|
+	  # get toggled iter
+	  iter = @syslogview.model.get_iter(path)
+	  fixed =iter[0]
+	  # do something with the value
+	  fixed ^= 1
+	  # set new value
+	  iter[0] = fixed
+   end
+
+  if !$config.syslog_mon
+ 	 @syslogview.set_sensitive false
+	 frame.set_label("This monitoring is disabled")
+  end
+
+  column1 = Gtk::TreeViewColumn.new("Selected",
+					renderer_syslog, {:active => 0})
+  column1.set_clickable(true)
+  column2 = Gtk::TreeViewColumn.new("Syslog label",
+					Gtk::CellRendererText.new, {:text => 1})
+  column2.set_sort_column_id(1)
+  sev_renderer = Gtk::CellRendererText.new  
+  column3 = Gtk::TreeViewColumn.new("Severity",	sev_renderer, {:text => 2})
+  column4 = Gtk::TreeViewColumn.new("Description", Gtk::CellRendererText.new, {:text => 3})
+  column4.visible = false
+  column3.set_cell_data_func(sev_renderer) do |col, renderer, model, iter|
+    if iter[2] and iter[2] != ""
+      ind = $status.index(iter[2])
+      if ind
+        color = @color_style[ind]
+        if color
+          renderer.set_background_gdk(color)
+        end
+        next
+      end
+    end
+    renderer.background = nil
+  end
+
+  @syslogview.append_column(column1)
+  @syslogview.append_column(column2)
+  @syslogview.append_column(column3)
+  @syslogview.append_column(column4)
+  @syslogview.show
+
+	# Create a menu
+	menu_syslog = Gtk::Menu.new
+
+	item_add_syslog = Gtk::ImageMenuItem.new("Add Syslog Ref")
+ 	image_item_add_syslog = Gtk::Image.new() 
+ 	image_item_add_syslog.set_stock(Gtk::Stock::ADD) 
+	item_add_syslog.set_image(image_item_add_syslog)
+	item_add_syslog.signal_connect("activate") {	
+		add_monitored_syslog() unless SyslogRef::get_syslog_refs_name().size() == 0
+ 	}
+	
+	menu_syslog.append(item_add_syslog)
+
+	item_del_syslog = Gtk::ImageMenuItem.new("Delete selected Syslog Ref")
+ 	image_item_del_syslog = Gtk::Image.new() 
+ 	image_item_del_syslog.set_stock(Gtk::Stock::REMOVE) 
+	item_del_syslog.set_image(image_item_del_syslog)
+	item_del_syslog.signal_connect("activate") {
+		@syslogview.model.remove(@syslogview.selection.selected) unless @syslogview.selection.selected==nil
+	}
+	menu_syslog.append(item_del_syslog)
+
+	item_edit_syslog = Gtk::ImageMenuItem.new("Edit Syslog Ref")
+	image_item_edit_syslog = Gtk::Image.new() 
+	image_item_edit_syslog.set_stock(Gtk::Stock::EDIT) 
+	item_edit_syslog.set_image(image_item_edit_syslog)
+	item_edit_syslog.signal_connect("activate") { edit_monitored_syslog() }
+	menu_syslog.append(item_edit_syslog)
+
+	menu_syslog.show_all
+
+	@syslogview.signal_connect("button_press_event") do |widget, event|
+	  if event.kind_of? Gdk::EventButton and event.button == 3
+		 if @syslogview.selection.selected==nil 
+			 item_edit_syslog.set_sensitive(false)
+			 item_del_syslog.set_sensitive(false)
+		 else
+			 item_edit_syslog.set_sensitive(true)
+			 item_del_syslog.set_sensitive(true)
+		 end
+		if SyslogRef::get_syslog_refs_name().size() > 0 && get_syslog_refs_left().size() > 0
+			item_add_syslog.set_sensitive(true)
+		else
+			item_add_syslog.set_sensitive(false)
+		end
+   	 menu_syslog.popup(nil, nil, event.button, event.time)
+	  elsif (@syslogview.selection.selected!=nil) && (event.event_type == Gdk::Event::BUTTON2_PRESS)
+		edit_monitored_syslog()	
+	  end
+	end
+
+	#populate with saved values
+   node.syslog_monitoring.each_value do |syslog_mon|
+	  iter = syslog_ls.append
+	  iter[0] = syslog_mon.get_state()
+	  iter[1] = syslog_mon.get_syslog_ref()
+	if syslog_mon.raw_severity()>0
+	  iter[2] = syslog_mon.severity()
+	else
+	  iter[2] = MAP_SYSLOG_SEV
+	end
+	  iter[3] = $syslog_refs[syslog_mon.get_syslog_ref()].description
+	end
+
+	vbox.add(@syslogview)
+
+  label_syslog = Gtk::Label::new("Syslog")
+  notebook_inside.append_page frame, label_syslog
+
+###########################end syslog monitoring#################################################################
+
+######################### external cmd/plugin monitoring ###################################################################
+
+  frame = Gtk::Frame::new
+  frame.border_width=10
+  frame.set_size_request(300, 290)
+  frame.show
+
+  vbox = Gtk::VBox::new
+  vbox.show
+  frame.add vbox 
+
+  custom_ls = Gtk::ListStore.new(Integer, String, String, String, String)
+  @customview = Gtk::TreeView.new(custom_ls)
+  @customview.set_tooltip_column(4)
+  
+  if !$config.custom_mon
+	 @customview.set_sensitive false
+	 frame.set_label("This monitoring is disabled")
+  end
+
+  renderer = Gtk::CellRendererToggle.new
+  renderer.signal_connect('toggled') do |cell, path|
+	 # get toggled iter
+	 iter = @customview.model.get_iter(path)
+	 fixed =iter[0]
+	 # do something with the value
+	 fixed ^= 1
+	 # set new value
+	 iter[0] = fixed
+  end
+
+  column1 = Gtk::TreeViewColumn.new("Selected",
+					renderer, {:active => 0})
+  column1.set_clickable(true)
+  column2 = Gtk::TreeViewColumn.new("Name",
+					Gtk::CellRendererText.new, {:text => 1})      
+    
+  column2.set_sort_column_id(1)
+  renderer = Gtk::CellRendererText.new
+  renderer.set_editable(true)
+  
+  sev_ls_value=Gtk::ListStore.new(String)
+  $status[0..3].each {|sev|
+	  iter = sev_ls_value.append
+	  iter[0] = sev
+  }
+
+  sev_renderer=Gtk::CellRendererCombo.new
+  column3 = Gtk::TreeViewColumn.new("Severity", sev_renderer, "text" => 2)
+  column3.set_sort_column_id(2)
+  sev_renderer.model = sev_ls_value
+  sev_renderer.text_column = 0
+  sev_renderer.has_entry = false
+  sev_renderer.editable = true
+  
+  def custom_monitor_cell_set_parameter(cell, path_string, new_text, col)
+		iter = @customview.model.get_iter(path_string)
+		iter[col] = new_text
+	end
+  
+  tr0 = Gtk::CellRendererText.new
+	tr0.editable = true
+  tr0.mode =Gtk::CellRenderer::MODE_EDITABLE
+  tr0.signal_connect("edited") { |renderer, iter, var|
+		custom_monitor_cell_set_parameter(renderer, iter, var, 3) 
+	}
+  
+  column4 = Gtk::TreeViewColumn.new("Parameter", tr0, {:text => 3})
+  column4.set_sort_column_id(3)
+
+  column5 = Gtk::TreeViewColumn.new("Description", renderer, {:text => 4})
+  column5.visible = false
+  
+  column1.signal_connect("clicked") do |column|
+	toggle_select_custom()
+  end
+
+  sev_renderer.signal_connect("changed") {|cell, path, iter|
+      sev = cell.model.get_value(iter,0)
+      cell.set_background_gdk(@color_style[$status.index(sev)])
+      i = @customview.selection.selected
+      @customview.model.set_value(i, 2, sev)
+  }  
+  
+  column3.set_cell_data_func(sev_renderer) do |col, renderer, model, iter|
+    if iter[2] and iter[2] != ""
+      ind = $status.index(iter[2])
+      if ind
+        color = @color_style[ind]
+        if color
+          renderer.set_background_gdk(color)
+        end
+        next
+      end
+    end
+    renderer.background = nil
+  end
+
+  @customview.append_column(column1)
+  @customview.append_column(column2)
+  @customview.append_column(column3)
+  @customview.append_column(column4)
+  @customview.append_column(column5)
+  @customview.show
+
+  #populate with saved values
+  if $custom_monitor
+     $custom_monitor.each do |cm_name|
+	    iter = custom_ls.append
+	    if node.custom_monitoring[cm_name] != nil
+		    iter[0] = node.custom_monitoring[cm_name].get_state()
+	    else
+		    iter[0] = 0
+	    end		
+	    #class name
+	    iter[1] = cm_name
+	    #default sev
+      if node.custom_monitoring[cm_name] != nil
+        iter[2] = node.custom_monitoring[cm_name].severity
+      else
+	      begin
+	        iter[2] = Object.const_get(cm_name).default_severity()
+	      rescue
+	        #default sev is not set
+	        iter[2] = "CRITICAL"
+	      end
+      end
+	    #param
+      if node.custom_monitoring[cm_name] != nil
+        iter[3] = node.custom_monitoring[cm_name].param.to_s
+      else
+        begin
+	        iter[3] = Object.const_get(cm_name).parameter().to_s
+        rescue Exception => msg
+          $log.error("Can't instantiate #{cm_name} plugin class #{msg}")
+          iter[3] = ""
+        end
+      end
+	    #description
+      begin
+	        iter[4] = Object.const_get(cm_name).name()
+      rescue Exception => msg
+          $log.error("Can't instantiate #{cm_name} plugin class #{msg}")
+          iter[4] = ""
+      end
+    end
+  end
+
+  vbox.add(@customview)
+
+  label_custom = Gtk::Label::new("Custom")
+  notebook_inside.append_page frame, label_custom
+
+###########################end external cmd/plugin monitoring#################################################################
+ 
+	hbox = Gtk::HBox.new(FALSE, 1)
+	hbox.add Gtk::Image.new(Gtk::Stock::EXECUTE, Gtk::IconSize::MENU)
+	hbox.add Gtk::Label::new("Monitoring")
+	hbox.show_all
+  notebook.append_page notebook_inside, hbox
+  
+######################### graph ###################################################################
+
+#  frame = Gtk::Frame::new("Graphic monitoring")
+#  frame.border_width=10
+#  frame.set_size_request(300, 300)
+#  frame.show
+
+#  label = Gtk::Label::new("Graph")
+#  notebook.append_page frame, label
+
+###########################end graph#################################################################
+
+   ok_button = Gtk::Button.new(Gtk::Stock::SAVE)
+   ok_button.signal_connect("clicked") {
+
+	Thread.kill(@scan_port_th) unless @scan_port_th == nil
+	Gtk.thread_flush
+	if $config.port_mon && ($config.nmap_path != "")
+	  #store services
+	  if defined?(@treeview)
+		  node.clear_service()
+	    @treeview.model.each {|model, path, iter|
+	  	   selected = iter[0]
+	   	   protocol	= iter[1]
+	   	   port	= iter[2]
+	   	   service_name	= iter[3]
+		     sev = iter[4]
+		     node.add_service(protocol, port, service_name, selected, sev)
+		  }
+ 	  end
+	end
+
+  #store snmp_monitoring
+  node.clear_snmp_monitoring()
+  nbline=0
+  @snmpview.model.each {|model, path, iter|
+    state = iter[0]
+    oidname = iter[1]
+    oper = iter[2]
+    threshold = iter[3]
+    severity = iter[4]
+    node.add_snmp_monitoring(state, oidname, oper, threshold, severity)
+    nbline+=1
+  }
+  if nbline > 0 && (node.snmp_sev == UNMANAGED)
+    node.set_snmp_severity(UNKNOWN)
+  end
+
+  #store wmi_monitoring
+  node.clear_wmi_monitoring()
+  nbline=0
+  @wmiview.model.each {|model, path, iter|
+    state 	= iter[0]
+    wminame 	= iter[1]
+    oper		= iter[2]
+    value= iter[3]
+    severity	= iter[4]
+    node.add_wmi_monitoring(state, wminame, oper, value, severity)
+    nbline+=1
+  }
+  if nbline > 0 && (node.snmp_sev == UNMANAGED)
+    node.set_snmp_severity(UNKNOWN)
+  end
+
+	#store jmx_monitoring
+	nbline=0
+	db_del_jmx_monitoring(node.ip, HOSTNODE)	
+	node.jmx_monitoring.each_value { |jmx|		
+		db_add_jmx_monitoring(node.ip, HOSTNODE, jmx.get_state(), jmx.get_ref(), jmx.get_protocol(), jmx.get_port(), jmx.get_auth(), jmx.get_attributes())
+		nbline+=1
+	}
+	if (nbline > 0) && (node.jmx_monitoring.size > 0) && (node.snmp_sev == UNMANAGED)
+		node.set_snmp_severity(UNKNOWN)
+	end
+
+	#store custom_monitoring
+	node.clear_custom_monitoring()
+	nbline=0
+	custom_mon_table = Array.new()
+
+   @customview.model.each {|model, path, iter|
+      state = iter[0]
+      name = iter[1]
+      severity = iter[2]
+      param = iter[3]
+      custom_mon_table.push(Array.[](state, name,  param, $status.index(severity)))
+      nbline+=1
+    }
+    if nbline > 0
+      node.add_custom_monitoring_bulk(custom_mon_table)
+    end 
+
+  if nbline > 0 && (node.custom_sev == UNMANAGED)
+    node.set_custom_severity(UNKNOWN)
+  end
+
+  #store syslog_monitoring
+  node.clear_syslog_monitoring()
+  nbline=0
+  @syslogview.model.each {|model, path, iter|
+    state = iter[0]
+    syslog_ref 	= iter[1]
+    severity	= iter[2]
+    node.add_syslog_monitoring(state, syslog_ref, severity)
+    nbline+=1
+  }
+  if nbline > 0 && (node.trap_sev == UNMANAGED)
+    node.set_trap_severity(UNKNOWN)
+  end
+
+	#store snmptrap_monitoring
+	node.clear_snmptrap_monitoring()
+	nbline=0
+   @snmptrapview.model.each {|model, path, iter|
+      		state 		= iter[0]
+      		snmptrap_ref	= iter[1]
+	   	severity	= iter[2]
+		node.add_snmptrap_monitoring(state, snmptrap_ref, severity)
+		nbline+=1
+	}
+	if nbline > 0 && (node.trap_sev == UNMANAGED)
+		node.set_trap_severity(UNKNOWN)
+	end
+
+	#store account only in db as the lived value is already stored in @acccount hash
+	node.clear_db_accounts()
+	account_table = Array.new()
+	@account_view.model.each {|model, path, iter|
+	  idname     = iter[0]
+      	  login		= iter[1]
+	  password  = iter[2]
+	  account_table.push([idname, login, password])
+	}
+	if account_table.length > 0
+	  node.add_db_account(account_table)
+	end
+
+
+  #general
+  if entry_x.text.to_i >= 0 && entry_x.text.to_i <= $win.window.geometry[2]
+    node.x = entry_x.text.to_i
+  end
+  if entry_y.text.to_i >= 0 && entry_y.text.to_i <= $win.window.geometry[3]
+    node.y = entry_y.text.to_i
+  end
+
+  need_reload_icon=0
+
+  if entry_os.name != node.os || entry_type.name != node.type
+    need_reload_icon=1
+  end
+
+  if isValidIPv4(entry_ip.text)
+    node.ip = entry_ip.text
+  end
+
+  nodeid=db_get_node_id(node.ip, HOSTNODE)
+  
+  node.netmask = entry_mask.text.to_i
+  db_set_mask(nodeid, node.netmask)
+  
+  if (entry_mac.text=="") || (entry_mac.text.match('\s+'))
+	node.mac=Node::NOARP_PROPERTY
+  else
+	node.mac = entry_mac.text
+  end
+  db_set_mac(nodeid, node.mac)
+
+  if (entry_name.text=="") || (entry_name.text.match('\s+'))
+	node.dns_name=Node::NONAME_PROPERTY
+  else
+  	node.dns_name = entry_name.text
+  end
+  if (entry_netbiosname.text=="") || (entry_netbiosname.text.match('\s+'))
+	node.netbios_name=Node::NONAME_PROPERTY
+  else
+  	node.netbios_name = entry_netbiosname.text
+  end
+  if (entry_desc.text=="") || (entry_desc.text.match('\s+'))
+	node.description=Node::NODESCR_PROPERTY
+  else
+  	node.description = entry_desc.text
+  end
+  db_set_description(nodeid, node.description)
+
+  node.os = entry_os.name
+  if entry_type.filename != nil
+    node.change_type(entry_type.name)
+  end
+  node.change_label()
+  if need_reload_icon == 1
+    node.reload
+  end
+
+  Thread.kill(refresh_node_sev_display)
+  Gtk.thread_flush
+  window.destroy
+	
+	}
+
+	cancel_button = Gtk::Button.new(Gtk::Stock::CANCEL)
+	cancel_button.signal_connect("clicked") {
+		#we rollback the jmx monitoring from the db
+		node.init_jmx_from_db()
+		#we rollback here the account from the db to the @account hash
+		node.init_account_from_db()
+		Thread.kill(@scan_port_th) unless @scan_port_th == nil
+		Gtk.thread_flush
+		Thread.kill(refresh_node_sev_display)
+		Gtk.thread_flush
+		window.destroy
+	}
+	
+	hbox=Gtk::HBox.new(FALSE, 10)
+	hbox.border_width=10
+	hbox.show
+	hbox.pack_start(ok_button, TRUE, TRUE, 0)
+	ok_button.set_flags(Gtk::Widget::CAN_DEFAULT);
+	hbox.pack_start(cancel_button, TRUE, TRUE, 0)
+	cancel_button.set_flags(Gtk::Widget::CAN_DEFAULT);
+	separator = Gtk::HSeparator::new()
+	vboxb.pack_start(separator, FALSE, TRUE, 0)
+	separator.show
+	vboxb.pack_start(hbox, FALSE, TRUE, 0)
+	ok_button.show
+	cancel_button.show
+
+	window.show
+
+  end
+end