Exemple #1
0
	def __drawingarea_button_release_event(self, point, button_type):
		if(self.start_type == 1):
			self.finish_x,self.finish_y=point
			self.drawingarea.set_drawing_rectangle(None)		
			
			#Swap coordinate if selected in reverse direction
			self.start_x,self.start_y,self.tmp_finish_x,self.tmp_finish_y = image_logics.order_rectangle(self.start_x,self.start_y,self.tmp_finish_x,self.tmp_finish_y)

			# finding the index of new box inside the box list
			index = image_logics.find_index_for_new_box(self.start_x,self.start_y,self.tmp_finish_x,self.tmp_finish_y,
			[[ row[1],row[2],row[3],row[4] ]  for row in self.rs ]);

			# Inserting the new box to the list
			self.rs.insert(index,[0,self.start_x,self.start_y,self.tmp_finish_x-self.start_x,self.tmp_finish_y-self.start_y,""])

			self.set_selected_item(len([ [row[1],row[2],row[3],row[4],row[0] ] for row in self.rs ])-1)
			self.treeview.set_list(self.rs)
			self.drawingarea.set_rectangle_list([[ row[0],row[1],row[2],row[3],row[4] ]  for row in self.rs ]);
			self.drawingarea.redraw()

			self.emit('list_updated')
		
			

		# 2 - Resize or 3 - Moving
		if(self.start_type == 2 or self.start_type == 3):
			self.set_selected_item(self.start_row_index)
			self.treeview.set_list(self.rs);
			self.emit('list_updated')
			

		self.start_type = 0;
Exemple #2
0
    def __drawingarea_motion_notify_event(self, point):
        x, y = point
        max_width = self.drawingarea.get_width()
        max_height = self.drawingarea.get_height()

        # 1 - Select
        if (self.start_type == 1):
            if (image_logics.detect_out_of_range(x, y, max_width, max_height)):
                return

            start_x, start_y, end_x, end_y = image_logics.order_rectangle(
                self.start_x, self.start_y, x, y)
            if (image_logics.detect_overlap([[row[1], row[2], row[3], row[4]]
                                             for row in self.rs], start_x,
                                            start_y, end_x, end_y)):
                return

            self.tmp_finish_x, self.tmp_finish_y = point
            self.drawingarea.set_drawing_rectangle(
                (self.start_x, self.start_y, self.tmp_finish_x - self.start_x,
                 self.tmp_finish_y - self.start_y))

            self.drawingarea.redraw()

        # 2 - Resize
        if (self.start_type == 2):
            if (image_logics.detect_out_of_range(x, y, max_width, max_height)):
                return

            if (self.start_position_type == 1):
                if (not image_logics.is_overlapping(
                    [[row[1], row[2], row[3], row[4]]
                     for row in self.rs], self.start_row_index, x, y,
                        self.rs[self.start_row_index][3] +
                    (self.rs[self.start_row_index][1] - x),
                        self.rs[self.start_row_index][4] +
                    (self.rs[self.start_row_index][2] - y))):
                    self.rs[self.start_row_index][4] = self.rs[
                        self.start_row_index][4] + (
                            self.rs[self.start_row_index][2] - y)
                    self.rs[self.start_row_index][2] = y
                    self.rs[self.start_row_index][3] = self.rs[
                        self.start_row_index][3] + (
                            self.rs[self.start_row_index][1] - x)
                    self.rs[self.start_row_index][1] = x

            elif (self.start_position_type == 2):
                if (not image_logics.is_overlapping(
                    [[row[1], row[2], row[3], row[4]] for row in self.rs],
                        self.start_row_index, self.rs[self.start_row_index][1],
                        y, self.rs[self.start_row_index][3],
                        y + self.rs[self.start_row_index][4] - y)):
                    self.rs[self.start_row_index][4] = self.rs[
                        self.start_row_index][4] + (
                            self.rs[self.start_row_index][2] - y)
                    self.rs[self.start_row_index][2] = y

            elif (self.start_position_type == 3):
                if (not image_logics.is_overlapping(
                    [[row[1], row[2], row[3], row[4]] for row in self.rs],
                        self.start_row_index, self.rs[self.start_row_index][1],
                        y, x - self.rs[self.start_row_index][1],
                        self.rs[self.start_row_index][4] +
                    (self.rs[self.start_row_index][2] - y))):
                    self.rs[self.start_row_index][4] = self.rs[
                        self.start_row_index][4] + (
                            self.rs[self.start_row_index][2] - y)
                    self.rs[self.start_row_index][2] = y
                    self.rs[self.start_row_index][3] = x - self.rs[
                        self.start_row_index][1]

            elif (self.start_position_type == 4):
                if (not image_logics.is_overlapping(
                    [[row[1], row[2], row[3], row[4]]
                     for row in self.rs], self.start_row_index, x,
                        self.rs[self.start_row_index][2],
                        self.rs[self.start_row_index][3] +
                    (self.rs[self.start_row_index][1] - x),
                        self.rs[self.start_row_index][4])):
                    self.rs[self.start_row_index][3] = self.rs[
                        self.start_row_index][3] + (
                            self.rs[self.start_row_index][1] - x)
                    self.rs[self.start_row_index][1] = x

            elif (self.start_position_type == 6):
                if (not image_logics.is_overlapping(
                    [[row[1], row[2], row[3], row[4]] for row in self.rs],
                        self.start_row_index, self.rs[self.start_row_index][1],
                        self.rs[self.start_row_index][2],
                        x - self.rs[self.start_row_index][1],
                        self.rs[self.start_row_index][4])):
                    self.rs[self.start_row_index][3] = x - self.rs[
                        self.start_row_index][1]

            elif (self.start_position_type == 7):
                if (not image_logics.is_overlapping(
                    [[row[1], row[2], row[3], row[4]]
                     for row in self.rs], self.start_row_index, x,
                        self.rs[self.start_row_index][2],
                        self.rs[self.start_row_index][3] +
                    (self.rs[self.start_row_index][1] - x),
                        y - self.rs[self.start_row_index][2])):
                    self.rs[self.start_row_index][4] = y - self.rs[
                        self.start_row_index][2]
                    self.rs[self.start_row_index][3] = self.rs[
                        self.start_row_index][3] + (
                            self.rs[self.start_row_index][1] - x)
                    self.rs[self.start_row_index][1] = x

            elif (self.start_position_type == 8):
                if (not image_logics.is_overlapping(
                    [[row[1], row[2], row[3], row[4]] for row in self.rs],
                        self.start_row_index, self.rs[self.start_row_index][1],
                        self.rs[self.start_row_index][2],
                        self.rs[self.start_row_index][3],
                        y - self.rs[self.start_row_index][2])):
                    self.rs[self.start_row_index][4] = y - self.rs[
                        self.start_row_index][2]

            elif (self.start_position_type == 9):
                if (not image_logics.is_overlapping(
                    [[row[1], row[2], row[3], row[4]] for row in self.rs],
                        self.start_row_index, self.rs[self.start_row_index][1],
                        self.rs[self.start_row_index][2],
                        x - self.rs[self.start_row_index][1],
                        y - self.rs[self.start_row_index][2])):
                    self.rs[self.start_row_index][4] = y - self.rs[
                        self.start_row_index][2]
                    self.rs[self.start_row_index][3] = x - self.rs[
                        self.start_row_index][1]

            self.treeview.set_list(self.rs)
            self.drawingarea.set_rectangle_list(
                [[row[0], row[1], row[2], row[3], row[4]] for row in self.rs])

        # 3 - Moving
        if (self.start_type == 3):
            #Detect if anyof the new rectangle porsion is not feesible
            if (image_logics.detect_out_of_range(
                    x - self.rs[self.start_row_index][3] / 2,
                    y - self.rs[self.start_row_index][4] / 2, max_width,
                    max_height) or image_logics.detect_out_of_range(
                        x + self.rs[self.start_row_index][3] / 2,
                        y + self.rs[self.start_row_index][4] / 2, max_width,
                        max_height)):
                return

            if (image_logics.is_overlapping(
                [[row[1], row[2], row[3], row[4]]
                 for row in self.rs], self.start_row_index,
                    x - self.rs[self.start_row_index][3] / 2,
                    y - self.rs[self.start_row_index][4] / 2,
                    self.rs[self.start_row_index][3],
                    self.rs[self.start_row_index][4])):
                return
            self.rs[self.start_row_index][
                1] = x - self.rs[self.start_row_index][3] / 2
            self.rs[self.start_row_index][
                2] = y - self.rs[self.start_row_index][4] / 2

            self.treeview.set_list(self.rs)
            self.drawingarea.set_rectangle_list(
                [[row[0], row[1], row[2], row[3], row[4]] for row in self.rs])

        # 0 - Simply hovering
        if (self.start_type == 0):
            area_x_start, area_y_start = self.get_image_view_scrolled_start_points(
            )
            width, height = self.get_image_view_size_on_screen()
            _type, row_index, position_type = image_logics.get_point_type(
                x, y, area_x_start, area_y_start, width, height,
                [[row[1], row[2], row[3], row[4]] for row in self.rs])
            self.drawingarea.set_mouse_pointer_type(position_type)

            # if self.previus_row_index not equll to row_index then the
            # mouse pointer moved from current box so we draw it

            if (self.previus_row_index != row_index):
                # While hovering over boxes the treeview cursor change handler function should not be called
                # because it simply scroll drawing area for each boxes which leads to flicker
                self.treeview.block_cursor_change_signal()
                if (row_index != -1):
                    # The mouse is over the box at row_index
                    self.set_selected_item(row_index)
                    self.treeview.set_list(self.rs)
                    self.drawingarea.set_rectangle_list(
                        [[row[0], row[0], row[1], row[2], row[3]]
                         for row in self.rs])
                    self.treeview.set_cursor(row_index)
                elif (self.start_row_index != -1):
                    # If user made a selection then it should be preserved even after hovering other boxes
                    self.set_selected_item(self.start_row_index)
                    self.treeview.set_list(self.rs)
                    self.drawingarea.set_rectangle_list(
                        [[row[0], row[0], row[1], row[2], row[3]]
                         for row in self.rs])
                    self.treeview.set_cursor(self.start_row_index)

                self.drawingarea.set_rectangle_list(
                    [[row[0], row[1], row[2], row[3], row[4]]
                     for row in self.rs])
                self.treeview.unblock_cursor_change_signal()
            self.previus_row_index = row_index
        self.drawingarea.redraw()
Exemple #3
0
	def __drawingarea_motion_notify_event(self, point):
		x,y = point;
		max_width = self.drawingarea.get_width()
		max_height = self.drawingarea.get_height()
		
		# 1 - Select
		if (self.start_type == 1):
			if(image_logics.detect_out_of_range(x,y,max_width,max_height)):
				return
			
			start_x,start_y,end_x,end_y = image_logics.order_rectangle(self.start_x,self.start_y,x,y);
			if(image_logics.detect_overlap([ [row[1],row[2],row[3],row[4] ] for row in self.rs ],start_x,start_y,end_x,end_y)):
				return

			self.tmp_finish_x,self.tmp_finish_y = point
			self.drawingarea.set_drawing_rectangle((self.start_x,self.start_y,
			self.tmp_finish_x-self.start_x,self.tmp_finish_y-self.start_y))
			
			self.drawingarea.redraw()

		# 2 - Resize
		if (self.start_type == 2):
			if(image_logics.detect_out_of_range(x,y,max_width,max_height)):
				return
			
			if(self.start_position_type == 1):
				if( not image_logics.is_overlapping([ [row[1],row[2],row[3],row[4] ] for row in self.rs ],self.start_row_index,
				x,y,self.rs[self.start_row_index][3]+(self.rs[self.start_row_index][1] - x),
				self.rs[self.start_row_index][4]+(self.rs[self.start_row_index][2] - y))):
					self.rs[self.start_row_index][4] = self.rs[self.start_row_index][4]+(self.rs[self.start_row_index][2] - y)
					self.rs[self.start_row_index][2] = y
					self.rs[self.start_row_index][3] = self.rs[self.start_row_index][3]+(self.rs[self.start_row_index][1] - x)
					self.rs[self.start_row_index][1] = x
				
			elif(self.start_position_type == 2):
				if( not image_logics.is_overlapping([ [row[1],row[2],row[3],row[4] ] for row in self.rs ],self.start_row_index,
				self.rs[self.start_row_index][1],y,self.rs[self.start_row_index][3],y+self.rs[self.start_row_index][4] -y)):
					self.rs[self.start_row_index][4] = self.rs[self.start_row_index][4]+(self.rs[self.start_row_index][2] - y)
					self.rs[self.start_row_index][2] = y					

			elif(self.start_position_type == 3):
				if(not image_logics.is_overlapping([ [row[1],row[2],row[3],row[4] ] for row in self.rs ],self.start_row_index,
				self.rs[self.start_row_index][1],y,
				x - self.rs[self.start_row_index][1],
				self.rs[self.start_row_index][4]+(self.rs[self.start_row_index][2] - y))):
					self.rs[self.start_row_index][4] = self.rs[self.start_row_index][4]+(self.rs[self.start_row_index][2] - y)
					self.rs[self.start_row_index][2] = y
					self.rs[self.start_row_index][3] = x - self.rs[self.start_row_index][1]		
															
			elif(self.start_position_type == 4):
				if( not image_logics.is_overlapping([ [row[1],row[2],row[3],row[4] ] for row in self.rs ],self.start_row_index,
				x,self.rs[self.start_row_index][2],
				self.rs[self.start_row_index][3]+(self.rs[self.start_row_index][1] - x),
				self.rs[self.start_row_index][4])):
					self.rs[self.start_row_index][3] = self.rs[self.start_row_index][3]+(self.rs[self.start_row_index][1] - x)
					self.rs[self.start_row_index][1] = x
				
			elif(self.start_position_type == 6):
				if( not image_logics.is_overlapping([ [row[1],row[2],row[3],row[4] ] for row in self.rs ],self.start_row_index,
				self.rs[self.start_row_index][1],self.rs[self.start_row_index][2],
				x - self.rs[self.start_row_index][1],self.rs[self.start_row_index][4])):
					self.rs[self.start_row_index][3] = x - self.rs[self.start_row_index][1]

			elif(self.start_position_type == 7):
				if( not image_logics.is_overlapping([ [row[1],row[2],row[3],row[4] ] for row in self.rs ],self.start_row_index,
				x,self.rs[self.start_row_index][2],
				self.rs[self.start_row_index][3]+(self.rs[self.start_row_index][1] - x),
				y - self.rs[self.start_row_index][2])):
					self.rs[self.start_row_index][4] = y - self.rs[self.start_row_index][2]
					self.rs[self.start_row_index][3] = self.rs[self.start_row_index][3]+(self.rs[self.start_row_index][1] - x)
					self.rs[self.start_row_index][1] = x					

			elif(self.start_position_type == 8):
				if( not image_logics.is_overlapping([ [row[1],row[2],row[3],row[4] ] for row in self.rs ],self.start_row_index,
				self.rs[self.start_row_index][1],self.rs[self.start_row_index][2],
				self.rs[self.start_row_index][3],y - self.rs[self.start_row_index][2])):
					self.rs[self.start_row_index][4] = y - self.rs[self.start_row_index][2]		
		
			elif(self.start_position_type == 9):
				if( not image_logics.is_overlapping([ [row[1],row[2],row[3],row[4] ] for row in self.rs ],self.start_row_index,
				self.rs[self.start_row_index][1],self.rs[self.start_row_index][2],
				x - self.rs[self.start_row_index][1],y - self.rs[self.start_row_index][2])):
					self.rs[self.start_row_index][4] = y - self.rs[self.start_row_index][2]
					self.rs[self.start_row_index][3] = x - self.rs[self.start_row_index][1]
			
			self.treeview.set_list(self.rs)
			self.drawingarea.set_rectangle_list([[ row[0],row[1],row[2],row[3],row[4] ] for row in self.rs ])
		

		# 3 - Moving
		if (self.start_type == 3):
			#Detect if anyof the new rectangle porsion is not feesible
			if(image_logics.detect_out_of_range(x - self.rs[self.start_row_index][3]/2,y - self.rs[self.start_row_index][4]/2,max_width,max_height) or
			image_logics.detect_out_of_range(x + self.rs[self.start_row_index][3]/2,y + self.rs[self.start_row_index][4]/2,max_width,max_height)):
				return
			
			if(image_logics.is_overlapping([ [row[1],row[2],row[3],row[4] ] for row in self.rs ],self.start_row_index,x - self.rs[self.start_row_index][3]/2,
			y - self.rs[self.start_row_index][4]/2,self.rs[self.start_row_index][3],self.rs[self.start_row_index][4])):
				return
			self.rs[self.start_row_index][1] = x - self.rs[self.start_row_index][3]/2;
			self.rs[self.start_row_index][2] = y - self.rs[self.start_row_index][4]/2;
			
			self.treeview.set_list(self.rs)
			self.drawingarea.set_rectangle_list([[ row[0],row[1],row[2],row[3],row[4] ] for row in self.rs ])
		
		# 0 - Simply hovering 
		if (self.start_type == 0):
			area_x_start, area_y_start = self.get_image_view_scrolled_start_points()
			width,height = self.get_image_view_size_on_screen()
			_type, row_index, position_type = image_logics.get_point_type(x,y,area_x_start, area_y_start, width, height,[[row[1],row[2],row[3],row[4] ] for row in  self.rs ])
			self.drawingarea.set_mouse_pointer_type(position_type);

			# if self.previus_row_index not equll to row_index then the
			# mouse pointer moved from current box so we draw it

			if (self.previus_row_index != row_index):
				# While hovering over boxes the treeview cursor change handler function should not be called
				# because it simply scroll drawing area for each boxes which leads to flicker
				self.treeview.block_cursor_change_signal()
				if ( row_index != -1 ):
					# The mouse is over the box at row_index
					self.set_selected_item(row_index)
					self.treeview.set_list(self.rs);
					self.drawingarea.set_rectangle_list([[ row[0],row[0],row[1],row[2],row[3] ] for row in self.rs ])
					self.treeview.set_cursor(row_index)
				elif( self.start_row_index != -1 ):
					# If user made a selection then it should be preserved even after hovering other boxes
					self.set_selected_item(self.start_row_index)
					self.treeview.set_list(self.rs);
					self.drawingarea.set_rectangle_list([[ row[0],row[0],row[1],row[2],row[3] ] for row in self.rs ])
					self.treeview.set_cursor(self.start_row_index)

				self.drawingarea.set_rectangle_list([[ row[0],row[1],row[2],row[3],row[4] ] for row in self.rs ])
				self.treeview.unblock_cursor_change_signal()
			self.previus_row_index = row_index;
		self.drawingarea.redraw()