cleanup.
[minwii.git] / src / pgu / gui / textarea.py
1 """
2 """
3 import pygame
4 from pygame.locals import *
5
6 from const import *
7 import widget
8
9 class TextArea(widget.Widget):
10 """A multi-line text input.
11
12 <pre>TextArea(value="",width = 120, height = 30, size=20)</pre>
13
14 <dl>
15 <dt>value<dd>initial text
16 <dt>size<dd>size for the text box, in characters
17 </dl>
18
19 <strong>Example</strong>
20 <code>
21 w = TextArea(value="Cuzco the Goat",size=20)
22
23 w = TextArea("Marbles")
24
25 w = TextArea("Groucho\nHarpo\nChico\nGummo\nZeppo\n\nMarx", 200, 400, 12)
26 </code>
27
28 """
29 def __init__(self,value="",width = 120, height = 30, size=20,**params):
30 params.setdefault('cls','input')
31 params.setdefault('width', width)
32 params.setdefault('height', height)
33
34 widget.Widget.__init__(self,**params)
35 self.value = value # The value of the TextArea
36 self.pos = len(str(value)) # The position of the cursor
37 self.vscroll = 0 # The number of lines that the TextArea is currently scrolled
38 self.font = self.style.font # The font used for rendering the text
39 self.cursor_w = 2 # Cursor width (NOTE: should be in a style)
40 w,h = self.font.size("e"*size)
41 if not self.style.height: self.style.height = h
42 if not self.style.width: self.style.width = w
43
44 def resize(self,width=None,height=None):
45 if (width != None) and (height != None):
46 self.rect = pygame.Rect(self.rect.x, self.rect.y, width, height)
47 return self.rect.w, self.rect.h
48
49 def paint(self,s):
50
51 # TODO: What's up with this 20 magic number? It's the margin of the left and right sides, but I'm not sure how this should be gotten other than by trial and error.
52 max_line_w = self.rect.w - 20
53
54 # Update the line allocation for the box's value
55 self.doLines(max_line_w)
56
57 # Make sure that the vpos and hpos of the cursor is set properly
58 self.updateCursorPos()
59
60 # Make sure that we're scrolled vertically such that the cursor is visible
61 if (self.vscroll < 0):
62 self.vscroll = 0
63 if (self.vpos < self.vscroll):
64 self.vscroll = self.vpos
65 elif ((self.vpos - self.vscroll + 1) * self.line_h > self.rect.h):
66 self.vscroll = - (self.rect.h / self.line_h - self.vpos - 1)
67
68 # Blit each of the lines in turn
69 cnt = 0
70 for line in self.lines:
71 line_pos = (0, (cnt - self.vscroll) * self.line_h)
72 if (line_pos[1] >= 0) and (line_pos[1] < self.rect.h):
73 s.blit( self.font.render(line, 1, self.style.color), line_pos )
74 cnt += 1
75
76 # If the textarea is focused, then also show the cursor
77 if self.container.myfocus is self:
78 r = self.getCursorRect()
79 s.fill(self.style.color,r)
80
81 # This function updates self.vpos and self.hpos based on self.pos
82 def updateCursorPos(self):
83 self.vpos = 0 # Reset the current line that the cursor is on
84 self.hpos = 0
85
86 line_cnt = 0
87 char_cnt = 0
88
89 for line in self.lines:
90 line_char_start = char_cnt # The number of characters at the start of the line
91
92 # Keep track of the character count for words
93 char_cnt += len(line)
94
95 # If our cursor count is still less than the cursor position, then we can update our cursor line to assume that it's at least on this line
96 if (char_cnt > self.pos):
97 self.vpos = line_cnt
98 self.hpos = self.pos - line_char_start
99
100 break # Now that we know where our cursor is, we exit the loop
101
102 line_cnt += 1
103
104 if (char_cnt <= self.pos) and (len(self.lines) > 0):
105 self.vpos = len(self.lines) - 1
106 self.hpos = len(self.lines[ self.vpos ] )
107
108 # Returns a rectangle that is of the size and position of where the cursor is drawn
109 def getCursorRect(self):
110 lw = 0
111 if (len(self.lines) > 0):
112 lw, lh = self.font.size( self.lines[ self.vpos ][ 0:self.hpos ] )
113
114 r = pygame.Rect(lw, (self.vpos - self.vscroll) * self.line_h, self.cursor_w, self.line_h)
115 return r
116
117 # This function sets the cursor position according to an x/y value (such as by from a mouse click)
118 def setCursorByXY(self, (x, y)):
119 self.vpos = ((int) (y / self.line_h)) + self.vscroll
120 if (self.vpos >= len(self.lines)):
121 self.vpos = len(self.lines) - 1
122
123 currentLine = self.lines[ self.vpos ]
124
125 for cnt in range(0, len(currentLine) ):
126 self.hpos = cnt
127 lw, lh = self.font.size( currentLine[ 0:self.hpos + 1 ] )
128 if (lw > x):
129 break
130
131 lw, lh = self.font.size( currentLine )
132 if (lw < x):
133 self.hpos = len(currentLine)
134
135 self.setCursorByHVPos()
136
137 # This function sets the cursor position by the horizontal/vertical cursor position.
138 def setCursorByHVPos(self):
139 line_cnt = 0
140 char_cnt = 0
141
142 for line in self.lines:
143 line_char_start = char_cnt # The number of characters at the start of the line
144
145 # Keep track of the character count for words
146 char_cnt += len(line)
147
148 # If we're on the proper line
149 if (line_cnt == self.vpos):
150 # Make sure that we're not trying to go over the edge of the current line
151 if ( self.hpos >= len(line) ):
152 self.hpos = len(line) - 1
153 # Set the cursor position
154 self.pos = line_char_start + self.hpos
155 break # Now that we've set our cursor position, we exit the loop
156
157 line_cnt += 1
158
159 # Splits up the text found in the control's value, and assigns it into the lines array
160 def doLines(self, max_line_w):
161 self.line_h = 10
162 self.lines = [] # Create an empty starter list to start things out.
163
164 inx = 0
165 line_start = 0
166 while inx >= 0:
167 # Find the next breakable whitespace
168 # HACK: Find a better way to do this to include tabs and system characters and whatnot.
169 prev_word_start = inx # Store the previous whitespace
170 spc_inx = self.value.find(' ', inx+1)
171 nl_inx = self.value.find('\n', inx+1)
172
173 if (min(spc_inx, nl_inx) == -1):
174 inx = max(spc_inx, nl_inx)
175 else:
176 inx = min(spc_inx, nl_inx)
177
178 # Measure the current line
179 lw, self.line_h = self.font.size( self.value[ line_start : inx ] )
180
181 # If we exceeded the max line width, then create a new line
182 if (lw > max_line_w):
183 #Fall back to the previous word start
184 self.lines.append(self.value[ line_start : prev_word_start + 1 ])
185 line_start = prev_word_start + 1
186 # TODO: Check for extra-long words here that exceed the length of a line, to wrap mid-word
187
188 # If we reached the end of our text
189 if (inx < 0):
190 # Then make sure we added the last of the line
191 if (line_start < len( self.value ) ):
192 self.lines.append( self.value[ line_start : len( self.value ) ] )
193 # If we reached a hard line break
194 elif (self.value[inx] == "\n"):
195 # Then make a line break here as well.
196 newline = self.value[ line_start : inx + 1 ]
197 newline = newline.replace("\n", " ") # HACK: We know we have a newline character, which doesn't print nicely, so make it into a space. Comment this out to see what I mean.
198 self.lines.append( newline )
199
200 line_start = inx + 1
201 else:
202 # Otherwise, we just continue progressing to the next space
203 pass
204
205 def _setvalue(self,v):
206 self.__dict__['value'] = v
207 self.send(CHANGE)
208
209 def event(self,e):
210 used = None
211 if e.type == KEYDOWN:
212 if e.key == K_BACKSPACE:
213 if self.pos:
214 self._setvalue(self.value[:self.pos-1] + self.value[self.pos:])
215 self.pos -= 1
216 elif e.key == K_DELETE:
217 if len(self.value) > self.pos:
218 self._setvalue(self.value[:self.pos] + self.value[self.pos+1:])
219 elif e.key == K_HOME:
220 # Find the previous newline
221 newPos = self.value.rfind('\n', 0, self.pos)
222 if (newPos >= 0):
223 self.pos = newPos
224 elif e.key == K_END:
225 # Find the previous newline
226 newPos = self.value.find('\n', self.pos, len(self.value) )
227 if (newPos >= 0):
228 self.pos = newPos
229 elif e.key == K_LEFT:
230 if self.pos > 0: self.pos -= 1
231 used = True
232 elif e.key == K_RIGHT:
233 if self.pos < len(self.value): self.pos += 1
234 used = True
235 elif e.key == K_UP:
236 self.vpos -= 1
237 self.setCursorByHVPos()
238 elif e.key == K_DOWN:
239 self.vpos += 1
240 self.setCursorByHVPos()
241 # The following return/tab keys are standard for PGU widgets, but I took them out here to facilitate multi-line text editing
242 # elif e.key == K_RETURN:
243 # self.next()
244 # elif e.key == K_TAB:
245 # pass
246 else:
247 #c = str(e.unicode)
248 try:
249 if (e.key == K_RETURN):
250 c = "\n"
251 elif (e.key == K_TAB):
252 c = " "
253 else:
254 c = (e.unicode).encode('latin-1')
255 if c:
256 self._setvalue(self.value[:self.pos] + c + self.value[self.pos:])
257 self.pos += len(c)
258 except: #ignore weird characters
259 pass
260 self.repaint()
261 elif e.type == MOUSEBUTTONDOWN:
262 self.setCursorByXY(e.pos)
263 self.repaint()
264
265 elif e.type == FOCUS:
266 self.repaint()
267 elif e.type == BLUR:
268 self.repaint()
269
270 self.pcls = ""
271 if self.container.myfocus is self: self.pcls = "focus"
272
273 return used
274
275 def __setattr__(self,k,v):
276 if k == 'value':
277 if v == None: v = ''
278 v = str(v)
279 self.pos = len(v)
280 _v = self.__dict__.get(k,NOATTR)
281 self.__dict__[k]=v
282 if k == 'value' and _v != NOATTR and _v != v:
283 self.send(CHANGE)
284 self.repaint()
285
286 # The first version of this code was done by Clint Herron, and is a modified version of input.py (by Phil Hassey).
287 # It is under the same license as the rest of the PGU library.