gnms 2.1.0.rc1

data/lib/gui/node_network_view.rb

@@ -0,0 +1,186 @@
+class NodeNetworkView < NodeView
+
+  def setup_ellipse(root, status, icon_file, label)
+  
+        node_size = get_node_size()
+        @group = Goo::CanvasGroup.new(root,{:x => 0.0,:y => 0.0, :can_focus => true})
+	@group.visibility = Goo::CanvasItem::HIDDEN
+	@icon=Goo::CanvasEllipse.new(@group, node.x+node_size/2, node.y+node_size/2,
+                                            node_size/2, node_size/2,
+                                            :fill_color_rgba => status,
+                                            :stroke_color => "black",
+                                            :line_width => 1.0)
+	if (icon_file == nil) || (!FileTest.exist?(icon_file))
+		icon_file="#{PIXMAP_PATH}/unknown.png"
+	end
+	@image=nil
+	if FileTest.exist?(icon_file)
+		im=Gdk::Pixbuf.new(icon_file)
+		#the network type icon
+		@image=Goo::CanvasImage.new(@group, im, @icon.x1, @icon.y1,
+                                      :width => node_size*80/100.0,
+                                      :height => node_size*80/100.0,
+      				      :can_focus => false,
+				      :scale_to_fit => true
+				      )
+				      
+		@image.x= @icon.x1+(node_size/2.0)-@image.width/2.0
+		@image.y= @icon.y1+(node_size/2.0)-@image.height/2.0
+	else 
+		puts "Could not find img #{icon_file}"
+	end
+        #box for the network label background, pos will be fixed by resize method
+	cl = Integer("0x#{rgb_to_hex_color(Gdk::Color.new($config.label_bg[0],$config.label_bg[1],$config.label_bg[2]))}ff")
+	@bg_text=Goo::CanvasRect.new(@group,@icon.x1-3*label.size/2, @icon.y2+node_size/5-5,
+                                         node_size+3*label.size, 
+					 node_size/5+5,
+					 :fill_color_rgba => cl,
+					 :stroke_color_rgba => cl,
+                                         :line_width => 1.0)
+					 
+   #the label, pos will be fixed by resize method
+   @text=Goo::CanvasText.new(@group, label, @icon.x1+node_size/2, @icon.y2+2+node_size/5, 0, 
+                          Gtk::ANCHOR_CENTER, 
+			  :fill_color_rgba => Integer("0x#{rgb_to_hex_color(Gdk::Color.new($config.label_text[0],$config.label_text[1],$config.label_text[2]))}ff"), 
+			  :font => "Sans 8")
+
+	setup_item(@group)
+	#set_tooltips()
+  end
+
+#
+# define a tooltip
+# 
+ def show_tooltips()
+	if @tooltips==nil
+		@tooltips=Gtk::Window.new(Gtk::Window::POPUP)
+		@tooltips.set_decorated(false)
+		@tooltips.set_size_request(-1,-1)
+		@tooltips.set_window_position(Gtk::Window::POS_NONE)
+		@tooltips.border_width=1
+		x,y=$win.position
+		@tooltips.move(node.x+x+50, node.y+y+40)
+		@tooltips.app_paintable=true
+		@tooltips.realize
+		drawable=@tooltips.window
+		gc = Gdk::GC.new(drawable)
+
+
+	@tooltips.modify_bg(Gtk::STATE_NORMAL,$light_yellow)
+	@tooltips.signal_connect("expose-event") do |win, evt|
+	tooltips_width, tooltips_height=@tooltips.size
+
+	 drawable.draw_rectangle(gc,false, 0, 0, tooltips_width-1, tooltips_height-1)
+	 drawable.draw_rectangle(gc,false, 1, 1, tooltips_width-3, tooltips_height-3)
+	 false
+
+	 end
+		vbox=Gtk::VBox.new
+	  vbox.border_width=5
+	   ttips_text="<span weight=\"bold\" size=\"small\">IP: </span>#{self.node.ip}"
+		ttips_text+="\n<span weight=\"bold\" size=\"small\">Mask: </span>#{self.node.netmask}"
+     if self.node.dns_domain?
+	     ttips_text+="\n<span weight=\"bold\" size=\"small\">Dns domain: </span>#{self.node.dns_domain}"
+     end
+     if self.node.name?
+	     ttips_text+="\n<span weight=\"bold\" size=\"small\">Name: </span>#{self.node.name}"
+     end
+     if self.node.description?() &&( self.node.description != "")
+	     ttips_text+="\n<span weight=\"bold\" size=\"small\">Description: </span>#{self.node.description}"
+     end
+	  label = Gtk::Label.new.set_markup(ttips_text)
+	  label.set_alignment(0,0.5)
+	  vbox.add label
+
+     if self.node.os && (self.node.os != "unknown")
+			hbox=Gtk::HButtonBox.new
+			hbox.set_layout_style(Gtk::ButtonBox::START)
+			vbox.add hbox
+			label_os = Gtk::Label.new.set_markup("<span weight=\"bold\" size=\"small\">OS: </span>")
+			label_os.set_alignment(0,0.5)
+			label_os.show
+			hbox.add label_os
+			pxb = Gdk::Pixbuf.new(PIXMAP_PATH+"/#{find_extension("os/#{self.node.os}")}",20,20)
+			pxb_pixmap,pxb_mask=pxb.render_pixmap_and_mask(128)
+			img=Gtk::Image.new(pxb_pixmap,pxb_mask)
+			img.show
+			hbox.add img
+			hbox.show
+     end
+
+     if self.node.type
+			ttype=Gtk::Table.new(1,0,false)
+			vbox.add ttype
+			label_type = Gtk::Label.new.set_markup("<span weight=\"bold\" size=\"small\">Type: </span>")
+			label_type.set_alignment(0,0.5)
+			label_type.show
+			ttype.add label_type
+			pxb = Gdk::Pixbuf.new(PIXMAP_PATH+"/#{find_extension("type/#{self.node.type}")}",20,20)
+			pxb_pixmap,pxb_mask=pxb.render_pixmap_and_mask(128)
+			img=Gtk::Image.new(pxb_pixmap,pxb_mask)
+			img.show
+			ttype.attach(img,0,1,0,1, Gtk::FILL)
+			ttype.show
+     end
+	  if self.node.nb_node() > 0
+		  label_nbhost=Gtk::Label.new.set_markup("<span weight=\"bold\" size=\"small\">Nb host: </span>#{self.node.nb_node}")
+		  label_nbhost.set_alignment(0,0.5)
+		  label_nbhost.show
+		  vbox.add label_nbhost
+
+		  table = Gtk::Table.new(1,2,false)
+		  table.show
+		  vbox.add table
+		  label_status=Gtk::Label.new.set_markup("<span weight=\"bold\" size=\"small\">Status: </span>")
+		  label_status.show
+		  table.attach(label_status,0,1,0,1, Gtk::FILL)
+
+		  #do stat for each internal node network severity
+		  sev_stat=Array.new($status_value.size,0)
+		  node.get_node().each_value do |n|
+				sev_stat[$status_value.index(n.status)]+=1
+		  end
+
+		  status_index=0
+		  $status.each do |stat|
+			 if sev_stat[status_index] > 0
+   			label_sev = Gtk::Label.new.set_markup("<span color=\"##{rgb_to_hex_color(get_color_from_status(stat))}\">#{sev_stat[status_index]} #{stat}</span>")
+				label_sev.show
+				table.attach(label_sev,1,2,status_index,status_index+1, Gtk::FILL)
+			 end
+			status_index+=1
+	 		end
+
+	  end
+
+	  vbox.show
+	  label.show
+	  @tooltips.add vbox
+	end
+	if !@tooltips.visible?
+		@tooltips.show()
+	end
+
+
+
+  end
+
+  def hide_tooltips()
+		if @tooltips != nil
+			@tooltips.hide()
+			#with this the tooltips is always refreshed
+			@tooltips.destroy
+			@tooltips=nil
+		end
+  end
+
+  def initialize(rootcanvas, nd, status, icon_file, label)
+    @dragging=false
+    @size=get_node_size()
+    @tooltips=nil
+    self.node=nd
+    self.selected=false
+    setup_ellipse(rootcanvas, status, icon_file, label)
+  end
+
+end

data/lib/gui/node_view.rb

@@ -0,0 +1,672 @@
+class NodeView
+
+  MIN_MOVE=5
+  NODE_SIZE=40
+
+  attr_accessor :icon, :image, :bg_text, :text, :selected, :group
+  attr_accessor :node, :notification_count, :notification_sev
+
+  def add_notification(sev)
+    @notification_count[$status_value.index(sev)] +=1
+    if @notification_sev < sev
+      @notification_sev = sev
+    end
+    update_notification_icon()
+    if $icon.embedded? and !$win.visible? and !$icon.blinking?
+	$icon.set_blinking(true)
+    end
+  end
+
+  def del_notification(sev)
+    @notification_count[$status_value.index(sev)] -=1 if @notification_count[$status_value.index(sev)] > 0
+    #we need to update sev too
+    #warning it's not equivalent to @notification_count.each_with_index.max
+    max = @notification_count.max
+    if max == 0
+      @notification_sev = UNKNOWN
+    else
+      @notification_sev = $status_value[@notification_count.index(max)]
+    end
+    update_notification_icon()
+  end
+
+  def reset_notification()
+    #@notification_count is an array of 4 sevs: critical, major, warning, minor
+    @notification_count = Array.new(4, 0)
+    @notification_sev = UNKNOWN
+  end
+
+  def move_up()
+    hide_link()
+    move(0, -MIN_MOVE)
+    show_link()
+  end
+  
+  def move_down()
+    hide_link()
+    move(0, MIN_MOVE)
+    show_link()
+  end
+  
+  def move_left()
+    hide_link()
+    move(-MIN_MOVE, 0)
+    show_link()
+  end
+  
+  def move_right()
+    hide_link()
+    move(MIN_MOVE, 0)
+    show_link()
+  end
+
+  def get_node_size()
+    view_size=$config.pixmap_size.to_i()
+    
+    if @node != nil && @node.map != nil
+      if $network[@node.map].node_size != nil
+        view_size=$network[@node.map].node_size
+      end
+    end
+      
+    if view_size <= 0
+      return NODE_SIZE
+    else
+      return view_size
+    end
+  end
+
+  def reparent(canvas_group)
+    @group.parent = canvas_group
+  end
+
+  def get_size()
+    return @size
+  end
+
+  def resize()
+    #puts "in resize"
+    to_size=get_node_size()
+    hide_link()
+    @size=$config.pixmap_size
+       
+    @image.width=(to_size)*80/100.0
+    @image.height=(to_size)*80/100.0
+       
+    @image.x= @icon.x+(to_size/2.0)-@image.width/2.0
+    @image.y= @icon.y+(to_size/2.0)-@image.height/2.0
+
+    old_icon_width = @icon.width
+    old_icon_height = @icon.height
+    old_icon_y = @icon.y
+    @icon.width=to_size
+    @icon.height=to_size
+      
+    @text.x = @icon.x + get_node_size()/2
+    @text.y = @icon.y + get_node_size() + 11
+    reload_bg_text()
+    reload_label_colors()
+   
+    #notification icon is only displayed on Host node
+    if @node.class == Host
+      circle_size = to_size/2.0
+      @notification_group.translate(@icon.width - old_icon_width, @icon.y - old_icon_y)
+      resize_notification_icon(circle_size)
+    end  
+    show_link()
+  end
+
+  #
+  #	need to reload bg text when text label is changed
+  #
+  def reload_bg_text()
+    to_size = get_node_size()
+    siz = to_size + 3*@text.text.size
+    if siz > (@text.x2 - @text.x1)
+      @bg_text.width = siz
+    end    
+    @bg_text.x = @text.x - @bg_text.width/2
+    @bg_text.y = @icon.y + to_size + 5    
+  end
+
+  def reload_label_colors()
+    cl = Integer("0x#{rgb_to_hex_color(Gdk::Color.new($config.label_bg[0],$config.label_bg[1],$config.label_bg[2]))}ff")	
+    @bg_text.fill_color_rgba = cl
+    @bg_text.stroke_color_rgba = cl
+    @text.fill_color_rgba = Integer("0x#{rgb_to_hex_color(Gdk::Color.new($config.label_text[0],$config.label_text[1],$config.label_text[2]))}ff")
+  end
+
+  def selected?()
+    return @selected==true
+  end
+
+  def select()
+    @icon.stroke_color = "red"
+    @icon.line_width = 2.0
+    @selected=true
+  end
+
+  def unselect()
+    @icon.stroke_color = "black"
+    @icon.line_width = 1.0
+    @selected=false
+  end
+
+  def move(x_translate, y_translate)
+    @node.x += x_translate
+    @node.y += y_translate
+    @group.translate(x_translate, y_translate)
+  end
+
+  def destroy()
+    @group.parent.remove_child(@group) if !@group.nil?
+  end
+
+  def show()
+    @group.visibility = Goo::CanvasItem::VISIBLE if !@group.nil?
+  end
+
+  def hide()
+    @group.visibility = Goo::CanvasItem::HIDDEN if !@group.nil?
+  end
+
+  def set_text_color(color)
+    if @text != nil
+      @text.fill_color = color
+    end
+  end
+
+  def set_text(txt)
+    if (@text != nil) && (@text.text != txt)
+      @text.text = txt
+      reload_bg_text()
+    end
+  end
+
+  def get_text()
+    if @text != nil
+      @text.text
+    end
+  end
+
+  def hide_text()
+    if @text != nil
+      @bg_text.visibility = Goo::CanvasItem::HIDDEN
+      @text.visibility = Goo::CanvasItem::HIDDEN
+    end
+  end
+
+  def show_text()
+    if @text != nil
+      @bg_text.visibility = Goo::CanvasItem::VISIBLE
+      @text.visibility = Goo::CanvasItem::VISIBLE
+    end
+  end
+
+  def set_image(img_path)
+    if @image != nil
+      full_img_path="#{PIXMAP_PATH}/"+img_path
+      if FileTest.exist?(full_img_path)
+        begin
+          Gtk.thread_protect do
+	    node_size = get_node_size()
+            @image.pixbuf = Gdk::Pixbuf.new(full_img_path, node_size, node_size)
+	    @image.width=(node_size)*80/100.0
+            @image.height=(node_size)*80/100.0
+          end
+        rescue Exception => msg
+          $log.error("Image is corrupted #{msg}")
+        end
+      end
+    end
+  end
+
+  def icon_color(color)
+    if @icon != nil
+      Gtk.thread_protect do
+        @icon.fill_color_rgba = color
+      end
+    end
+  end
+
+  def hide_selected_node_link()
+    $canvas.get_selected_node.each {|n|
+      if n.nb_links > 0
+        n.get_links().each {|lnk|
+          lnk.hide
+        }
+      end
+    }
+  end
+
+  def show_selected_node_link()
+    $canvas.get_selected_node.each {|n|
+      if n.nb_links > 0
+        n.get_links().each {|lnk|
+          lnk.show
+        }
+      end
+    }
+  end
+
+  def hide_link()
+    if @node.nb_links > 0
+      @node.get_links().each {|lnk|
+        lnk.remove_link
+      }
+    end
+  end
+
+  def show_link()
+    if @node.nb_links > 0
+      @node.get_links().each {|lnk|
+        lnk.display
+      }
+    end
+  end
+
+  def unlink_node()
+    node_t=$canvas.get_selected_node()
+    node_t_size=node_t.size
+    if node_t_size == 0
+      @node.del_all_links()
+    elsif node_t_size == 1
+      node_t[0].del_all_links()
+    else
+      cpt=0
+      while cpt < node_t_size do
+        node_id=node_t.shift
+        node_t.each { |node2_id|
+          if node_id.linked(node2_id) == 1
+            node_id.del_node_link(node2_id)
+          end
+        }
+        cpt+=1
+      end
+    end
+  end
+
+  private
+  def item_event(item, event)
+    if busy?()
+       return
+    end
+    #print "node view item event #{item} #{event.event_type} #{Gdk::Event::LEAVE_NOTIFY}\n"    
+    case event.event_type
+    when Gdk::Event::KEY_PRESS
+      estring=Gdk::Keyval.to_name(event.keyval)
+      #print "code touche: ",event.keyval," = ",estring,"\n"
+      if (event.keyval == Gdk::Keyval::GDK_d) || (event.keyval == Gdk::Keyval::GDK_Delete)
+        #we want to delete a node!
+        verify_delnodewin(node)
+      end
+    when Gdk::Event::ENTER_NOTIFY
+      #@text.fill_color = "green"
+      #puts "mouse over"
+      $win.window.cursor = Gdk::Cursor.new(Gdk::Cursor::HAND1)
+      if $config.show_tooltips
+        @ttips=Thread.start {
+          sleep(3)
+          Gtk.thread_protect do
+            show_tooltips()
+          end
+        }
+      end      
+    when Gdk::Event::LEAVE_NOTIFY
+      #puts "mouse out"
+      $win.window.cursor = nil
+      #@text.set({:fill_color => "black"})
+      if defined?(@ttips)
+        hide_tooltips()
+        Thread.kill(@ttips)
+        Gtk.thread_flush
+      end
+    when Gdk::Event::BUTTON2_PRESS
+      #show links cause hide during first button check
+      show_selected_node_link()
+      if node.class == Network
+        if (event.state & Gdk::Window::SHIFT_MASK) != 0
+          node_property(self.node)
+        else
+          set_map(self.node.ip)
+        end
+      else
+        node_property(self.node)
+	$canvas.show()
+      end
+    when Gdk::Event::BUTTON_PRESS
+      item_x, item_y = item.parent.canvas.convert_to_pixels(event.x,event.y)
+      case event.button
+      when 1
+        @x = item_x;
+        @y = item_y;
+        #puts "here button press #{@x} #{@y}"
+        @dragging = true
+        if !selected?
+          if event.state & Gdk::Window::CONTROL_MASK != Gdk::Window::CONTROL_MASK
+            #unselect all nodes
+            $canvas.get_selected_node.each {|n|
+              n.node_view.unselect()
+            }
+          end
+          #and then select this one
+          select()
+        end
+        #hide links before moving nodes
+        hide_selected_node_link()
+      when 3
+        #popup menu
+        b = event.button
+        t = event.time
+
+        #just highlight the node
+        node.node_view.select
+
+        popup_menu = Gtk::Menu.new
+        popup_menu.append(Gtk::SeparatorMenuItem.new)
+
+        if node.status == UNMANAGED
+          ismon=Gtk::ImageMenuItem.new("Start Monitoring")
+          image_ismon = Gtk::Image.new()
+          image_ismon.set_stock(Gtk::Stock::MEDIA_PLAY)
+          ismon.set_image(image_ismon)
+          popup_menu.append(ismon)
+        else
+          ismon=Gtk::ImageMenuItem.new("Stop Monitoring")
+          image_ismon = Gtk::Image.new()
+          image_ismon.set_stock(Gtk::Stock::MEDIA_STOP)
+          ismon.set_image(image_ismon)
+          popup_menu.append(ismon)
+        end
+        map_menu_item=Gtk::ImageMenuItem.new("Move to map")
+        image_map_menu_item = Gtk::Image.new()
+        image_map_menu_item.set_stock(Gtk::Stock::JUMP_TO)
+        map_menu_item.set_image(image_map_menu_item)
+        if $map != nil
+          if (n_network() == 2) && (node.class == Network)
+            #there is just root node and this network node
+            map_menu_item.set_sensitive false
+          else
+            map_menu=Gtk::Menu.new
+            $network.each_value {|node_map|
+              if (get_map() != node_map.ip) && ($canvas.get_selected_node().index(node_map) == nil)
+                map_menu.append(actme=Gtk::MenuItem.new(node_map.ip))
+                actme.signal_connect('button-press-event') {
+                  #first we remove the links
+                  unlink_node()
+                  old_map=node.map
+                  #print "1\n";
+                  selected_nodes=$canvas.get_selected_node()
+                  #print "2\n";
+
+                  invalid_move=0
+                  selected_nodes.each {|n|
+                    if (n.class == Network)&&(n.contain_network(node_map.ip))
+                      invalid_move=1
+                    end
+                  }
+                  if invalid_move == 0
+                    #deselect nodes
+                    node.set_map(node_map.ip)
+                    #print "3\n";
+
+                    selected_nodes.each {|n|
+
+                      #cant move network in itself
+                      #print "2 #{n.ip} #{node_map.ip}\n";
+                      if (n.ip != node_map.ip)
+                        n.set_map(node_map.ip)
+                      end
+                    }
+
+                    #print "3\n";
+                    #print "node_view.rb: #{node_map.ip} #{old_map}\n";
+                    node_map.update_status()
+                    #we should test here which is inner of the other!
+                    $network[old_map].update_status()
+                  end
+                }
+              end
+            }
+            map_menu_item.set_submenu(map_menu)
+          end
+        else
+          map_menu_item.set_sensitive false
+        end
+
+        popup_menu.append(map_menu_item)
+        deletenode=Gtk::ImageMenuItem.new("Delete")
+        image_deletenode = Gtk::Image.new()
+        image_deletenode.set_stock(Gtk::Stock::DELETE)
+        deletenode.set_image(image_deletenode)
+        popup_menu.append(deletenode)
+        if $map == nil
+          deletenode.set_sensitive false
+        end
+        popup_menu.append(linknode=Gtk::MenuItem.new("Link"))
+        popup_menu.append(unlinknode=Gtk::MenuItem.new("Unlink"))
+
+        if $map == nil
+          linknode.set_sensitive false
+          unlinknode.set_sensitive false
+        end
+        if $canvas.nb_selected() < 2
+          linknode.set_sensitive false
+        end
+        if node.nb_links() == 0
+          unlinknode.set_sensitive false
+        end
+
+        popup_menu.append(Gtk::SeparatorMenuItem.new)
+
+        if node.class == Host
+          admin_menu_item=Gtk::ImageMenuItem.new("Admin")
+          image_admin_menu_item = Gtk::Image.new()
+          image_admin_menu_item.set_stock(Gtk::Stock::EXECUTE)
+          admin_menu_item.set_image(image_admin_menu_item)
+          admin_menu=Gtk::Menu.new
+
+          admin_menu.append(ssh=Gtk::MenuItem.new("Ssh"))
+          if $config.ssh_path == "" || $config.xterm_path == ""
+            ssh.set_sensitive false
+          end
+          admin_menu.append(telnet=Gtk::MenuItem.new("Telnet"))
+          if $config.telnet_path == "" || $config.xterm_path == ""
+            telnet.set_sensitive false
+          end
+          admin_menu.append(browser=Gtk::MenuItem.new("Web"))
+          if $config.browser_path == "" || $config.xterm_path == ""
+            browser.set_sensitive false
+          end
+          admin_menu.append(vnc=Gtk::MenuItem.new("VNC"))
+          if $config.vncviewer_path == "" || $config.xterm_path == ""
+            vnc.set_sensitive false
+          end
+          admin_menu.append(rdp=Gtk::MenuItem.new("RDP"))
+          if $config.vncviewer_path == "" || $config.xterm_path == ""
+            rdp.set_sensitive false
+          end
+          admin_menu_item.set_submenu(admin_menu)
+
+          ssh.signal_connect('button-press-event') {
+            Thread.start {
+              if $config.xterm_path !=""
+                system("#{$config.xterm_path} #{$config.ssh_path} #{node.ip}")
+              end
+            }
+            popup_menu.destroy
+          }
+          telnet.signal_connect('button-press-event') {
+            Thread.start {
+              if $config.xterm_path !=""
+                system("#{$config.xterm_path} #{$config.telnet_path} #{node.ip}")
+              end
+            }
+            popup_menu.destroy
+          }
+          browser.signal_connect('button-press-event') {
+            Thread.start {
+              if $config.xterm_path !=""
+                system("#{$config.browser_path} http://#{node.ip}")
+              end
+            }
+            popup_menu.destroy
+          }
+          vnc.signal_connect('button-press-event') {
+            Thread.start {
+              if $config.xterm_path !=""
+                system("#{$config.xterm_path} #{$config.vncviewer_path} #{node.ip}:1")
+              end
+            }
+            popup_menu.destroy
+          }
+          rdp.signal_connect('button-press-event') {
+            Thread.start {
+              if $config.xterm_path !=""
+                system("#{$config.xterm_path} #{$config.rdesktop_path} #{node.ip}")
+              end
+            }
+            popup_menu.destroy
+          }
+          popup_menu.append(admin_menu_item)
+        elsif node.class == Network
+          enter_network=Gtk::ImageMenuItem.new("Go down")
+          image_enter_network = Gtk::Image.new()
+          image_enter_network.set_stock(Gtk::Stock::GO_DOWN)
+          enter_network.set_image(image_enter_network)
+          popup_menu.append(enter_network)
+          enter_network.signal_connect('button-press-event') {
+            set_map(self.node.ip)
+          }
+        end
+
+        popup_menu.append(Gtk::SeparatorMenuItem.new)
+
+        popup_menu.append(event_win_host=Gtk::MenuItem.new("Show events"))
+
+        property=Gtk::ImageMenuItem.new("Property")
+        image_property = Gtk::Image.new()
+        image_property.set_stock(Gtk::Stock::PROPERTIES)
+        property.set_image(image_property)
+        popup_menu.append(property)
+
+        if node.status==UNMANAGED
+          property.set_sensitive(false)
+        end
+        popup_menu.show_all
+        popup_menu.popup(nil,nil,b,t)
+
+        ismon.signal_connect('button-press-event') {
+          if node.status == UNMANAGED
+            #when right clik
+            node.set_all_severity(UNKNOWN)
+            #when selected
+            $canvas.get_selected_node().each {|n|
+              n.set_all_severity(UNKNOWN)
+            }
+            #check if node status changed
+            if node.status == UNMANAGED
+              #all monitoring should be disabled, so we warn the users
+              errorEntry($win, "First, you have to configure monitoring in Option/Preference menu")
+            end
+          else
+            node.set_all_severity(UNMANAGED)
+            $canvas.get_selected_node().each {|n|
+              n.set_all_severity(UNMANAGED)
+            }
+          end
+          #refresh network map status
+          $network[node.map].update_status() unless $network[node.map] == nil
+          popup_menu.destroy
+        }
+        deletenode.signal_connect('button-press-event') {
+          verify_delnodewin(node)
+          popup_menu.destroy
+        }
+
+        unlinknode.signal_connect('button-press-event') {
+          unlink_node()
+          popup_menu.destroy
+        }
+
+        linknode.signal_connect('button-press-event') {
+          node_t=$canvas.get_selected_node()
+          node_t_size=node_t.size
+          cpt=0
+          while cpt < node_t_size do
+            node_id=node_t.shift
+            node_t.each { |node2_id|
+              if node_id.linked(node2_id) == 0
+                Link.new(node_id, node2_id)
+              end
+            }
+            cpt+=1
+          end
+          popup_menu.destroy
+        }
+
+        property.signal_connect('button-press-event') { |w,s|
+          node_property(self.node)
+          popup_menu.destroy
+        }
+        event_win_host.signal_connect('button-press-event') {
+          $event_win.filter_by_node(self.node)
+          $event_win.show()
+          popup_menu.destroy
+        }
+
+        #end of popup menu
+      end
+    when Gdk::Event::BUTTON_RELEASE
+      @dragging = false;
+    when Gdk::Event::MOTION_NOTIFY
+      item_x, item_y = item.canvas.convert_from_pixels(event.x, event.y)     
+      
+      if @dragging && (event.state & Gdk::Window::BUTTON1_MASK == Gdk::Window::BUTTON1_MASK)
+
+        nodex=node.x+(item_x - @x)
+        nodey=node.y+(item_y - @y)
+
+        #test if node is not out of the view
+        if nodex >=0 && nodey >=0 && nodex+get_node_size() <= ($win.window.geometry[2]-$win.window.geometry[0]) && nodey+get_node_size() <= ($win.window.geometry[3]-$win.window.geometry[1])
+	  move(item_x - @x, item_y - @y)
+          mapp=get_map()
+          if mapp != nil
+            $network[mapp].get_node().each_value {|n|
+              if n.node_view and n.node_view.selected?() and n!=node
+                #test if node will be out of view
+                nodex=n.x+(item_x - @x)
+                nodey=n.y+(item_y - @y)
+                if nodex >=0 && nodey >=0 && nodex+get_node_size() <= ($win.window.geometry[2]-$win.window.geometry[0]) && nodey+get_node_size() <= ($win.window.geometry[3]-$win.window.geometry[1])
+                  n.node_view.move(item_x - @x, item_y - @y)
+                end
+              end
+            }
+          end
+        end
+      end
+    end
+  end
+
+  def setup_item(item)
+    item.signal_connect('key_press_event') do |group, item, event|
+      item_event(group, event)
+    end
+    item.signal_connect('enter_notify_event') do |group, item, event|
+      item_event(group, event)
+    end
+    item.signal_connect('leave_notify_event') do |group, item, event|
+      item_event(group, event)
+    end
+    item.signal_connect('button_press_event') do |group, item, event|
+      item_event(group, event)
+    end    
+    item.signal_connect('button_release_event') do |group, item, event|
+      item_event(group, event)
+    end    
+    item.signal_connect('motion_notify_event') do |group, item, event|
+      item_event(group, event)
+    end
+  end
+
+end