Mercurial Repositories > eric / file comparison

comparison: eric6/ThirdParty/Pygments/pygments/formatters/img.py

eric6/ThirdParty/Pygments/pygments/formatters/img.py

changeset 6942
2602857055c5
parent 6651
e8f3b5568b21
child 7547
21b0534faebc
equal deleted inserted replaced
6941:f99d60d6b59b 6942:2602857055c5
1 # -*- coding: utf-8 -*-
2 """
3 pygments.formatters.img
4 ~~~~~~~~~~~~~~~~~~~~~~~
5
6 Formatter for Pixmap output.
7
8 :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
9 :license: BSD, see LICENSE for details.
10 """
11
12 import os
13 import sys
14
15 from pygments.formatter import Formatter
16 from pygments.util import get_bool_opt, get_int_opt, get_list_opt, \
17 get_choice_opt, xrange
18
19 import subprocess
20
21 # Import this carefully
22 try:
23 from PIL import Image, ImageDraw, ImageFont
24 pil_available = True
25 except ImportError:
26 pil_available = False
27
28 try:
29 import _winreg
30 except ImportError:
31 try:
32 import winreg as _winreg
33 except ImportError:
34 _winreg = None
35
36 __all__ = ['ImageFormatter', 'GifImageFormatter', 'JpgImageFormatter',
37 'BmpImageFormatter']
38
39
40 # For some unknown reason every font calls it something different
41 STYLES = {
42 'NORMAL': ['', 'Roman', 'Book', 'Normal', 'Regular', 'Medium'],
43 'ITALIC': ['Oblique', 'Italic'],
44 'BOLD': ['Bold'],
45 'BOLDITALIC': ['Bold Oblique', 'Bold Italic'],
46 }
47
48 # A sane default for modern systems
49 DEFAULT_FONT_NAME_NIX = 'Bitstream Vera Sans Mono'
50 DEFAULT_FONT_NAME_WIN = 'Courier New'
51 DEFAULT_FONT_NAME_MAC = 'Courier New'
52
53
54 class PilNotAvailable(ImportError):
55 """When Python imaging library is not available"""
56
57
58 class FontNotFound(Exception):
59 """When there are no usable fonts specified"""
60
61
62 class FontManager(object):
63 """
64 Manages a set of fonts: normal, italic, bold, etc...
65 """
66
67 def __init__(self, font_name, font_size=14):
68 self.font_name = font_name
69 self.font_size = font_size
70 self.fonts = {}
71 self.encoding = None
72 if sys.platform.startswith('win'):
73 if not font_name:
74 self.font_name = DEFAULT_FONT_NAME_WIN
75 self._create_win()
76 elif sys.platform.startswith('darwin'):
77 if not font_name:
78 self.font_name = DEFAULT_FONT_NAME_MAC
79 self._create_mac()
80 else:
81 if not font_name:
82 self.font_name = DEFAULT_FONT_NAME_NIX
83 self._create_nix()
84
85 def _get_nix_font_path(self, name, style):
86 proc = subprocess.Popen(['fc-list', "%s:style=%s" % (name, style), 'file'],
87 stdout=subprocess.PIPE, stderr=None)
88 stdout, _ = proc.communicate()
89 if proc.returncode == 0:
90 lines = stdout.splitlines()
91 for line in lines:
92 if line.startswith(b'Fontconfig warning:'):
93 continue
94 path = line.decode().strip().strip(':')
95 if path:
96 return path
97 return None
98
99 def _create_nix(self):
100 for name in STYLES['NORMAL']:
101 path = self._get_nix_font_path(self.font_name, name)
102 if path is not None:
103 self.fonts['NORMAL'] = ImageFont.truetype(path, self.font_size)
104 break
105 else:
106 raise FontNotFound('No usable fonts named: "%s"' %
107 self.font_name)
108 for style in ('ITALIC', 'BOLD', 'BOLDITALIC'):
109 for stylename in STYLES[style]:
110 path = self._get_nix_font_path(self.font_name, stylename)
111 if path is not None:
112 self.fonts[style] = ImageFont.truetype(path, self.font_size)
113 break
114 else:
115 if style == 'BOLDITALIC':
116 self.fonts[style] = self.fonts['BOLD']
117 else:
118 self.fonts[style] = self.fonts['NORMAL']
119
120 def _get_mac_font_path(self, font_map, name, style):
121 return font_map.get((name + ' ' + style).strip().lower())
122
123 def _create_mac(self):
124 font_map = {}
125 for font_dir in (os.path.join(os.getenv("HOME"), 'Library/Fonts/'),
126 '/Library/Fonts/', '/System/Library/Fonts/'):
127 font_map.update(
128 ((os.path.splitext(f)[0].lower(), os.path.join(font_dir, f))
129 for f in os.listdir(font_dir) if f.lower().endswith('ttf')))
130
131 for name in STYLES['NORMAL']:
132 path = self._get_mac_font_path(font_map, self.font_name, name)
133 if path is not None:
134 self.fonts['NORMAL'] = ImageFont.truetype(path, self.font_size)
135 break
136 else:
137 raise FontNotFound('No usable fonts named: "%s"' %
138 self.font_name)
139 for style in ('ITALIC', 'BOLD', 'BOLDITALIC'):
140 for stylename in STYLES[style]:
141 path = self._get_mac_font_path(font_map, self.font_name, stylename)
142 if path is not None:
143 self.fonts[style] = ImageFont.truetype(path, self.font_size)
144 break
145 else:
146 if style == 'BOLDITALIC':
147 self.fonts[style] = self.fonts['BOLD']
148 else:
149 self.fonts[style] = self.fonts['NORMAL']
150
151 def _lookup_win(self, key, basename, styles, fail=False):
152 for suffix in ('', ' (TrueType)'):
153 for style in styles:
154 try:
155 valname = '%s%s%s' % (basename, style and ' '+style, suffix)
156 val, _ = _winreg.QueryValueEx(key, valname)
157 return val
158 except EnvironmentError:
159 continue
160 else:
161 if fail:
162 raise FontNotFound('Font %s (%s) not found in registry' %
163 (basename, styles[0]))
164 return None
165
166 def _create_win(self):
167 try:
168 key = _winreg.OpenKey(
169 _winreg.HKEY_LOCAL_MACHINE,
170 r'Software\Microsoft\Windows NT\CurrentVersion\Fonts')
171 except EnvironmentError:
172 try:
173 key = _winreg.OpenKey(
174 _winreg.HKEY_LOCAL_MACHINE,
175 r'Software\Microsoft\Windows\CurrentVersion\Fonts')
176 except EnvironmentError:
177 raise FontNotFound('Can\'t open Windows font registry key')
178 try:
179 path = self._lookup_win(key, self.font_name, STYLES['NORMAL'], True)
180 self.fonts['NORMAL'] = ImageFont.truetype(path, self.font_size)
181 for style in ('ITALIC', 'BOLD', 'BOLDITALIC'):
182 path = self._lookup_win(key, self.font_name, STYLES[style])
183 if path:
184 self.fonts[style] = ImageFont.truetype(path, self.font_size)
185 else:
186 if style == 'BOLDITALIC':
187 self.fonts[style] = self.fonts['BOLD']
188 else:
189 self.fonts[style] = self.fonts['NORMAL']
190 finally:
191 _winreg.CloseKey(key)
192
193 def get_char_size(self):
194 """
195 Get the character size.
196 """
197 return self.fonts['NORMAL'].getsize('M')
198
199 def get_font(self, bold, oblique):
200 """
201 Get the font based on bold and italic flags.
202 """
203 if bold and oblique:
204 return self.fonts['BOLDITALIC']
205 elif bold:
206 return self.fonts['BOLD']
207 elif oblique:
208 return self.fonts['ITALIC']
209 else:
210 return self.fonts['NORMAL']
211
212
213 class ImageFormatter(Formatter):
214 """
215 Create a PNG image from source code. This uses the Python Imaging Library to
216 generate a pixmap from the source code.
217
218 .. versionadded:: 0.10
219
220 Additional options accepted:
221
222 `image_format`
223 An image format to output to that is recognised by PIL, these include:
224
225 * "PNG" (default)
226 * "JPEG"
227 * "BMP"
228 * "GIF"
229
230 `line_pad`
231 The extra spacing (in pixels) between each line of text.
232
233 Default: 2
234
235 `font_name`
236 The font name to be used as the base font from which others, such as
237 bold and italic fonts will be generated. This really should be a
238 monospace font to look sane.
239
240 Default: "Bitstream Vera Sans Mono" on Windows, Courier New on \\*nix
241
242 `font_size`
243 The font size in points to be used.
244
245 Default: 14
246
247 `image_pad`
248 The padding, in pixels to be used at each edge of the resulting image.
249
250 Default: 10
251
252 `line_numbers`
253 Whether line numbers should be shown: True/False
254
255 Default: True
256
257 `line_number_start`
258 The line number of the first line.
259
260 Default: 1
261
262 `line_number_step`
263 The step used when printing line numbers.
264
265 Default: 1
266
267 `line_number_bg`
268 The background colour (in "#123456" format) of the line number bar, or
269 None to use the style background color.
270
271 Default: "#eed"
272
273 `line_number_fg`
274 The text color of the line numbers (in "#123456"-like format).
275
276 Default: "#886"
277
278 `line_number_chars`
279 The number of columns of line numbers allowable in the line number
280 margin.
281
282 Default: 2
283
284 `line_number_bold`
285 Whether line numbers will be bold: True/False
286
287 Default: False
288
289 `line_number_italic`
290 Whether line numbers will be italicized: True/False
291
292 Default: False
293
294 `line_number_separator`
295 Whether a line will be drawn between the line number area and the
296 source code area: True/False
297
298 Default: True
299
300 `line_number_pad`
301 The horizontal padding (in pixels) between the line number margin, and
302 the source code area.
303
304 Default: 6
305
306 `hl_lines`
307 Specify a list of lines to be highlighted.
308
309 .. versionadded:: 1.2
310
311 Default: empty list
312
313 `hl_color`
314 Specify the color for highlighting lines.
315
316 .. versionadded:: 1.2
317
318 Default: highlight color of the selected style
319 """
320
321 # Required by the pygments mapper
322 name = 'img'
323 aliases = ['img', 'IMG', 'png']
324 filenames = ['*.png']
325
326 unicodeoutput = False
327
328 default_image_format = 'png'
329
330 def __init__(self, **options):
331 """
332 See the class docstring for explanation of options.
333 """
334 if not pil_available:
335 raise PilNotAvailable(
336 'Python Imaging Library is required for this formatter')
337 Formatter.__init__(self, **options)
338 self.encoding = 'latin1' # let pygments.format() do the right thing
339 # Read the style
340 self.styles = dict(self.style)
341 if self.style.background_color is None:
342 self.background_color = '#fff'
343 else:
344 self.background_color = self.style.background_color
345 # Image options
346 self.image_format = get_choice_opt(
347 options, 'image_format', ['png', 'jpeg', 'gif', 'bmp'],
348 self.default_image_format, normcase=True)
349 self.image_pad = get_int_opt(options, 'image_pad', 10)
350 self.line_pad = get_int_opt(options, 'line_pad', 2)
351 # The fonts
352 fontsize = get_int_opt(options, 'font_size', 14)
353 self.fonts = FontManager(options.get('font_name', ''), fontsize)
354 self.fontw, self.fonth = self.fonts.get_char_size()
355 # Line number options
356 self.line_number_fg = options.get('line_number_fg', '#886')
357 self.line_number_bg = options.get('line_number_bg', '#eed')
358 self.line_number_chars = get_int_opt(options,
359 'line_number_chars', 2)
360 self.line_number_bold = get_bool_opt(options,
361 'line_number_bold', False)
362 self.line_number_italic = get_bool_opt(options,
363 'line_number_italic', False)
364 self.line_number_pad = get_int_opt(options, 'line_number_pad', 6)
365 self.line_numbers = get_bool_opt(options, 'line_numbers', True)
366 self.line_number_separator = get_bool_opt(options,
367 'line_number_separator', True)
368 self.line_number_step = get_int_opt(options, 'line_number_step', 1)
369 self.line_number_start = get_int_opt(options, 'line_number_start', 1)
370 if self.line_numbers:
371 self.line_number_width = (self.fontw * self.line_number_chars +
372 self.line_number_pad * 2)
373 else:
374 self.line_number_width = 0
375 self.hl_lines = []
376 hl_lines_str = get_list_opt(options, 'hl_lines', [])
377 for line in hl_lines_str:
378 try:
379 self.hl_lines.append(int(line))
380 except ValueError:
381 pass
382 self.hl_color = options.get('hl_color',
383 self.style.highlight_color) or '#f90'
384 self.drawables = []
385
386 def get_style_defs(self, arg=''):
387 raise NotImplementedError('The -S option is meaningless for the image '
388 'formatter. Use -O style=<stylename> instead.')
389
390 def _get_line_height(self):
391 """
392 Get the height of a line.
393 """
394 return self.fonth + self.line_pad
395
396 def _get_line_y(self, lineno):
397 """
398 Get the Y coordinate of a line number.
399 """
400 return lineno * self._get_line_height() + self.image_pad
401
402 def _get_char_width(self):
403 """
404 Get the width of a character.
405 """
406 return self.fontw
407
408 def _get_char_x(self, charno):
409 """
410 Get the X coordinate of a character position.
411 """
412 return charno * self.fontw + self.image_pad + self.line_number_width
413
414 def _get_text_pos(self, charno, lineno):
415 """
416 Get the actual position for a character and line position.
417 """
418 return self._get_char_x(charno), self._get_line_y(lineno)
419
420 def _get_linenumber_pos(self, lineno):
421 """
422 Get the actual position for the start of a line number.
423 """
424 return (self.image_pad, self._get_line_y(lineno))
425
426 def _get_text_color(self, style):
427 """
428 Get the correct color for the token from the style.
429 """
430 if style['color'] is not None:
431 fill = '#' + style['color']
432 else:
433 fill = '#000'
434 return fill
435
436 def _get_style_font(self, style):
437 """
438 Get the correct font for the style.
439 """
440 return self.fonts.get_font(style['bold'], style['italic'])
441
442 def _get_image_size(self, maxcharno, maxlineno):
443 """
444 Get the required image size.
445 """
446 return (self._get_char_x(maxcharno) + self.image_pad,
447 self._get_line_y(maxlineno + 0) + self.image_pad)
448
449 def _draw_linenumber(self, posno, lineno):
450 """
451 Remember a line number drawable to paint later.
452 """
453 self._draw_text(
454 self._get_linenumber_pos(posno),
455 str(lineno).rjust(self.line_number_chars),
456 font=self.fonts.get_font(self.line_number_bold,
457 self.line_number_italic),
458 fill=self.line_number_fg,
459 )
460
461 def _draw_text(self, pos, text, font, **kw):
462 """
463 Remember a single drawable tuple to paint later.
464 """
465 self.drawables.append((pos, text, font, kw))
466
467 def _create_drawables(self, tokensource):
468 """
469 Create drawables for the token content.
470 """
471 lineno = charno = maxcharno = 0
472 for ttype, value in tokensource:
473 while ttype not in self.styles:
474 ttype = ttype.parent
475 style = self.styles[ttype]
476 # TODO: make sure tab expansion happens earlier in the chain. It
477 # really ought to be done on the input, as to do it right here is
478 # quite complex.
479 value = value.expandtabs(4)
480 lines = value.splitlines(True)
481 # print lines
482 for i, line in enumerate(lines):
483 temp = line.rstrip('\n')
484 if temp:
485 self._draw_text(
486 self._get_text_pos(charno, lineno),
487 temp,
488 font = self._get_style_font(style),
489 fill = self._get_text_color(style)
490 )
491 charno += len(temp)
492 maxcharno = max(maxcharno, charno)
493 if line.endswith('\n'):
494 # add a line for each extra line in the value
495 charno = 0
496 lineno += 1
497 self.maxcharno = maxcharno
498 self.maxlineno = lineno
499
500 def _draw_line_numbers(self):
501 """
502 Create drawables for the line numbers.
503 """
504 if not self.line_numbers:
505 return
506 for p in xrange(self.maxlineno):
507 n = p + self.line_number_start
508 if (n % self.line_number_step) == 0:
509 self._draw_linenumber(p, n)
510
511 def _paint_line_number_bg(self, im):
512 """
513 Paint the line number background on the image.
514 """
515 if not self.line_numbers:
516 return
517 if self.line_number_fg is None:
518 return
519 draw = ImageDraw.Draw(im)
520 recth = im.size[-1]
521 rectw = self.image_pad + self.line_number_width - self.line_number_pad
522 draw.rectangle([(0, 0), (rectw, recth)],
523 fill=self.line_number_bg)
524 draw.line([(rectw, 0), (rectw, recth)], fill=self.line_number_fg)
525 del draw
526
527 def format(self, tokensource, outfile):
528 """
529 Format ``tokensource``, an iterable of ``(tokentype, tokenstring)``
530 tuples and write it into ``outfile``.
531
532 This implementation calculates where it should draw each token on the
533 pixmap, then calculates the required pixmap size and draws the items.
534 """
535 self._create_drawables(tokensource)
536 self._draw_line_numbers()
537 im = Image.new(
538 'RGB',
539 self._get_image_size(self.maxcharno, self.maxlineno),
540 self.background_color
541 )
542 self._paint_line_number_bg(im)
543 draw = ImageDraw.Draw(im)
544 # Highlight
545 if self.hl_lines:
546 x = self.image_pad + self.line_number_width - self.line_number_pad + 1
547 recth = self._get_line_height()
548 rectw = im.size[0] - x
549 for linenumber in self.hl_lines:
550 y = self._get_line_y(linenumber - 1)
551 draw.rectangle([(x, y), (x + rectw, y + recth)],
552 fill=self.hl_color)
553 for pos, value, font, kw in self.drawables:
554 draw.text(pos, value, font=font, **kw)
555 im.save(outfile, self.image_format.upper())
556
557
558 # Add one formatter per format, so that the "-f gif" option gives the correct result
559 # when used in pygmentize.
560
561 class GifImageFormatter(ImageFormatter):
562 """
563 Create a GIF image from source code. This uses the Python Imaging Library to
564 generate a pixmap from the source code.
565
566 .. versionadded:: 1.0
567 """
568
569 name = 'img_gif'
570 aliases = ['gif']
571 filenames = ['*.gif']
572 default_image_format = 'gif'
573
574
575 class JpgImageFormatter(ImageFormatter):
576 """
577 Create a JPEG image from source code. This uses the Python Imaging Library to
578 generate a pixmap from the source code.
579
580 .. versionadded:: 1.0
581 """
582
583 name = 'img_jpg'
584 aliases = ['jpg', 'jpeg']
585 filenames = ['*.jpg']
586 default_image_format = 'jpeg'
587
588
589 class BmpImageFormatter(ImageFormatter):
590 """
591 Create a bitmap image from source code. This uses the Python Imaging Library to
592 generate a pixmap from the source code.
593
594 .. versionadded:: 1.0
595 """
596
597 name = 'img_bmp'
598 aliases = ['bmp', 'bitmap']
599 filenames = ['*.bmp']
600 default_image_format = 'bmp'

Mercurial Repository: eric

eric ide

mercurial