c3492d052edc38b81cc947a8f92ec4dde26ca1d3
[debian/gnuradio] / grc / src / grc / gui / elements / Element.py
1 """
2 Copyright 2007 Free Software Foundation, Inc.
3 This file is part of GNU Radio
4
5 GNU Radio Companion is free software; you can redistribute it and/or
6 modify it under the terms of the GNU General Public License
7 as published by the Free Software Foundation; either version 2
8 of the License, or (at your option) any later version.
9
10 GNU Radio Companion is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
18 """
19 ##@package grc.gui.elements.Element
20 #Base class for graphical elements such as:
21 #signal blocks, input sockets, output sockets and connections.
22 #@author Josh Blum
23
24 import Colors
25 import pygtk
26 pygtk.require('2.0')
27 import gtk
28 import pango
29 from grc.Constants import *
30
31 class Element(object):
32         """
33         GraphicalElement is the base class for all graphical elements.
34         It contains an X,Y coordinate, a list of rectangular areas that the element occupies,
35         and methods to detect selection of those areas.
36         """
37
38         def __init__(self, *args, **kwargs):
39                 """!
40                 Make a new list of rectangular areas and lines, and set the coordinate and the rotation.
41                 """
42                 self.set_rotation(POSSIBLE_ROTATIONS[0])
43                 self.set_coordinate((0, 0))
44                 self.clear()
45                 self.set_highlighted(False)
46
47         def is_horizontal(self, rotation=None):
48                 """!
49                 Is this element horizontal?
50                 If rotation is None, use this element's rotation.
51                 @param rotation the optional rotation
52                 @return true if rotation is horizontal
53                 """
54                 rotation = rotation or self.get_rotation()
55                 return rotation in (0, 180)
56
57         def is_vertical(self, rotation=None):
58                 """!
59                 Is this element vertical?
60                 If rotation is None, use this element's rotation.
61                 @param rotation the optional rotation
62                 @return true if rotation is vertical
63                 """
64                 rotation = rotation or self.get_rotation()
65                 return rotation in (90, 270)
66
67         def get_gc(self): return self._gc
68
69         def draw(self, window, BG_color=Colors.BG_COLOR, FG_color=Colors.FG_COLOR):
70                 """!
71                 Draw in the given window.
72                 @param window the gtk window to draw on
73                 @param BG_color the background color
74                 @param FG_color the foreground color
75                 """
76                 gc = self.get_parent().get_gc()
77                 self._gc = gc
78                 X,Y = self.get_coordinate()
79                 for (rX,rY),(W,H) in self.areas_dict[self.get_rotation()]:
80                         aX = X + rX
81                         aY = Y + rY
82                         gc.foreground = BG_color
83                         window.draw_rectangle(gc, True, aX, aY, W, H)
84                         gc.foreground = self.is_highlighted() and Colors.H_COLOR or FG_color
85                         window.draw_rectangle(gc, False, aX, aY, W, H)
86                 for (x1, y1),(x2, y2) in self.lines_dict[self.get_rotation()]:
87                         gc.foreground = self.is_highlighted() and Colors.H_COLOR or FG_color
88                         window.draw_line(gc, X+x1, Y+y1, X+x2, Y+y2)
89
90         def rotate(self, direction):
91                 """!
92                 Rotate all of the areas by 90 degrees.
93                 @param direction 90 or 270 degrees
94                 """
95                 self.set_rotation((self.get_rotation() + direction)%360)
96
97         def clear(self):
98                 """Empty the lines and areas."""
99                 self.areas_dict = dict((rotation, list()) for rotation in POSSIBLE_ROTATIONS)
100                 self.lines_dict = dict((rotation, list()) for rotation in POSSIBLE_ROTATIONS)
101
102         def set_coordinate(self, coor):
103                 """!
104                 Set the reference coordinate.
105                 @param coor the coordinate tuple (x,y)
106                 """
107                 self.coor = coor
108
109         def get_parent(self):
110                 """!
111                 Get the parent of this element.
112                 @return the parent
113                 """
114                 return self.parent
115
116         def set_highlighted(self, highlighted):
117                 """!
118                 Set the highlight status.
119                 @param highlighted true to enable highlighting
120                 """
121                 self.highlighted = highlighted
122
123         def is_highlighted(self):
124                 """!
125                 Get the highlight status.
126                 @return true if highlighted
127                 """
128                 return self.highlighted
129
130         def get_coordinate(self):
131                 """!Get the coordinate.
132                 @return the coordinate tuple (x,y)
133                 """
134                 return self.coor
135
136         def move(self, delta_coor):
137                 """!
138                 Move the element by adding the delta_coor to the current coordinate.
139                 @param delta_coor (delta_x,delta_y) tuple
140                 """
141                 deltaX, deltaY = delta_coor
142                 X, Y = self.get_coordinate()
143                 self.set_coordinate((X+deltaX, Y+deltaY))
144
145         def add_area(self, rel_coor, area, rotation=None):
146                 """!
147                 Add an area to the area list.
148                 An area is actually a coordinate relative to the main coordinate
149                 with a width/height pair relative to the area coordinate.
150                 A positive width is to the right of the coordinate.
151                 A positive height is above the coordinate.
152                 The area is associated with a rotation.
153                 If rotation is not specified, the element's current rotation is used.
154                 @param rel_coor (x,y) offset from this element's coordinate
155                 @param area (width,height) tuple
156                 @param rotation rotation in degrees
157                 """
158                 self.areas_dict[rotation or self.get_rotation()].append((rel_coor, area))
159
160         def add_line(self, rel_coor1, rel_coor2, rotation=None):
161                 """!
162                 Add a line to the line list.
163                 A line is defined by 2 relative coordinates.
164                 Lines must be horizontal or vertical.
165                 The line is associated with a rotation.
166                 If rotation is not specified, the element's current rotation is used.
167                 @param rel_coor1 relative (x1,y1) tuple
168                 @param rel_coor2 relative (x2,y2) tuple
169                 @param rotation rotation in degrees
170                 """
171                 self.lines_dict[rotation or self.get_rotation()].append((rel_coor1, rel_coor2))
172
173         def what_is_selected(self, coor, coor_m=None):
174                 """!
175                 One coordinate specified:
176                         Is this element selected at given coordinate?
177                         ie: is the coordinate encompassed by one of the areas or lines?
178                 Both coordinates specified:
179                         Is this element within the rectangular region defined by both coordinates?
180                         ie: do any area corners or line endpoints fall within the region?
181                 @param coor the selection coordinate, tuple x, y
182                 @param coor_m an additional selection coordinate.
183                 @return self if one of the areas/lines encompasses coor, else None.
184                 """
185                 #function to test if p is between a and b (inclusive)
186                 in_between = lambda p, a, b: p >= min(a, b) and p <= max(a, b)
187                 #relative coordinate
188                 x, y = [a-b for a,b in zip(coor, self.get_coordinate())]
189                 if coor_m:
190                         x_m, y_m = [a-b for a,b in zip(coor_m, self.get_coordinate())]
191                         #handle rectangular areas
192                         for (x1,y1), (w,h) in self.areas_dict[self.get_rotation()]:
193                                 if in_between(x1, x, x_m) and in_between(y1, y, y_m) or \
194                                         in_between(x1+w, x, x_m) and in_between(y1, y, y_m) or \
195                                         in_between(x1, x, x_m) and in_between(y1+h, y, y_m) or \
196                                         in_between(x1+w, x, x_m) and in_between(y1+h, y, y_m):
197                                         return self
198                         #handle horizontal or vertical lines
199                         for (x1, y1), (x2, y2) in self.lines_dict[self.get_rotation()]:
200                                 if in_between(x1, x, x_m) and in_between(y1, y, y_m) or \
201                                         in_between(x2, x, x_m) and in_between(y2, y, y_m):
202                                         return self
203                         return None
204                 else:
205                         #handle rectangular areas
206                         for (x1,y1), (w,h) in self.areas_dict[self.get_rotation()]:
207                                 if in_between(x, x1, x1+w) and in_between(y, y1, y1+h): return self
208                         #handle horizontal or vertical lines
209                         for (x1, y1), (x2, y2) in self.lines_dict[self.get_rotation()]:
210                                 if x1 == x2: x1, x2 = x1-CONNECTION_SELECT_SENSITIVITY, x2+CONNECTION_SELECT_SENSITIVITY
211                                 if y1 == y2: y1, y2 = y1-CONNECTION_SELECT_SENSITIVITY, y2+CONNECTION_SELECT_SENSITIVITY
212                                 if in_between(x, x1, x2) and in_between(y, y1, y2): return self
213                         return None
214
215         def get_rotation(self):
216                 """!
217                 Get the rotation in degrees.
218                 @return the rotation
219                 """
220                 return self.rotation
221
222         def set_rotation(self, rotation):
223                 """!
224                 Set the rotation in degrees.
225                 @param rotation the rotation"""
226                 if rotation not in POSSIBLE_ROTATIONS:
227                         raise Exception('"%s" is not one of the possible rotations: (%s)'%(rotation,POSSIBLE_ROTATIONS))
228                 self.rotation = rotation
229
230         def update(self):
231                 """Do nothing for the update. Dummy method."""
232                 pass
233
234