home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 January / maximum-cd-2011-01.iso / DiscContents / calibre-0.7.26.msi / file_2487 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-10-31  |  31.1 KB  |  923 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import re
  5. import operator
  6. import sys
  7. import wordmatcher
  8. import pyreadline.clipboard as clipboard
  9. from pyreadline.logger import log, log_sock
  10. from pyreadline.unicode_helper import ensure_unicode
  11. kill_ring_to_clipboard = False
  12.  
  13. class NotAWordError(IndexError):
  14.     pass
  15.  
  16.  
  17. def quote_char(c):
  18.     if ord(c) > 0:
  19.         return c
  20.  
  21.  
  22. class LinePositioner(object):
  23.     
  24.     def __call__(self, line):
  25.         NotImplementedError('Base class !!!')
  26.  
  27.  
  28.  
  29. class NextChar(LinePositioner):
  30.     
  31.     def __call__(self, line):
  32.         if line.point < len(line.line_buffer):
  33.             return line.point + 1
  34.         return line.point
  35.  
  36.  
  37. NextChar = NextChar()
  38.  
  39. class PrevChar(LinePositioner):
  40.     
  41.     def __call__(self, line):
  42.         if line.point > 0:
  43.             return line.point - 1
  44.         return line.point
  45.  
  46.  
  47. PrevChar = PrevChar()
  48.  
  49. class NextWordStart(LinePositioner):
  50.     
  51.     def __call__(self, line):
  52.         return line.next_start_segment(line.line_buffer, line.is_word_token)[line.point]
  53.  
  54.  
  55. NextWordStart = NextWordStart()
  56.  
  57. class NextWordEnd(LinePositioner):
  58.     
  59.     def __call__(self, line):
  60.         return line.next_end_segment(line.line_buffer, line.is_word_token)[line.point]
  61.  
  62.  
  63. NextWordEnd = NextWordEnd()
  64.  
  65. class PrevWordStart(LinePositioner):
  66.     
  67.     def __call__(self, line):
  68.         return line.prev_start_segment(line.line_buffer, line.is_word_token)[line.point]
  69.  
  70.  
  71. PrevWordStart = PrevWordStart()
  72.  
  73. class WordStart(LinePositioner):
  74.     
  75.     def __call__(self, line):
  76.         if line.is_word_token(line.get_line_text()[Point(line):Point(line) + 1]):
  77.             if Point(line) > 0 and line.is_word_token(line.get_line_text()[Point(line) - 1:Point(line)]):
  78.                 return PrevWordStart(line)
  79.             return line.point
  80.         line.is_word_token(line.get_line_text()[Point(line):Point(line) + 1])
  81.         raise NotAWordError('Point is not in a word')
  82.  
  83.  
  84. WordStart = WordStart()
  85.  
  86. class WordEnd(LinePositioner):
  87.     
  88.     def __call__(self, line):
  89.         if line.is_word_token(line.get_line_text()[Point(line):Point(line) + 1]):
  90.             if line.is_word_token(line.get_line_text()[Point(line) + 1:Point(line) + 2]):
  91.                 return NextWordEnd(line)
  92.             return line.point
  93.         line.is_word_token(line.get_line_text()[Point(line):Point(line) + 1])
  94.         raise NotAWordError('Point is not in a word')
  95.  
  96.  
  97. WordEnd = WordEnd()
  98.  
  99. class PrevWordEnd(LinePositioner):
  100.     
  101.     def __call__(self, line):
  102.         return line.prev_end_segment(line.line_buffer, line.is_word_token)[line.point]
  103.  
  104.  
  105. PrevWordEnd = PrevWordEnd()
  106.  
  107. class PrevSpace(LinePositioner):
  108.     
  109.     def __call__(self, line):
  110.         point = line.point
  111.         if line[point - 1:point].get_line_text() == ' ':
  112.             while point > 0 and line[point - 1:point].get_line_text() == ' ':
  113.                 point -= 1
  114.         
  115.         while point > 0 and line[point - 1:point].get_line_text() != ' ':
  116.             point -= 1
  117.         return point
  118.  
  119.  
  120. PrevSpace = PrevSpace()
  121.  
  122. class StartOfLine(LinePositioner):
  123.     
  124.     def __call__(self, line):
  125.         return 0
  126.  
  127.  
  128. StartOfLine = StartOfLine()
  129.  
  130. class EndOfLine(LinePositioner):
  131.     
  132.     def __call__(self, line):
  133.         return len(line.line_buffer)
  134.  
  135.  
  136. EndOfLine = EndOfLine()
  137.  
  138. class Point(LinePositioner):
  139.     
  140.     def __call__(self, line):
  141.         return line.point
  142.  
  143.  
  144. Point = Point()
  145.  
  146. class Mark(LinePositioner):
  147.     
  148.     def __call__(self, line):
  149.         return line.mark
  150.  
  151.  
  152. Mark = Mark()
  153. all_positioners = [] if isinstance(value, LinePositioner) else _[1]
  154. all_positioners.sort()
  155.  
  156. class LineSlice(object):
  157.     
  158.     def __call__(self, line):
  159.         NotImplementedError('Base class !!!')
  160.  
  161.  
  162.  
  163. class CurrentWord(LineSlice):
  164.     
  165.     def __call__(self, line):
  166.         return slice(WordStart(line), WordEnd(line), None)
  167.  
  168.  
  169. CurrentWord = CurrentWord()
  170.  
  171. class NextWord(LineSlice):
  172.     
  173.     def __call__(self, line):
  174.         work = TextLine(line)
  175.         work.point = NextWordStart
  176.         start = work.point
  177.         stop = NextWordEnd(work)
  178.         return slice(start, stop)
  179.  
  180.  
  181. NextWord = NextWord()
  182.  
  183. class PrevWord(LineSlice):
  184.     
  185.     def __call__(self, line):
  186.         work = TextLine(line)
  187.         work.point = PrevWordEnd
  188.         stop = work.point
  189.         start = PrevWordStart(work)
  190.         return slice(start, stop)
  191.  
  192.  
  193. PrevWord = PrevWord()
  194.  
  195. class PointSlice(LineSlice):
  196.     
  197.     def __call__(self, line):
  198.         return slice(Point(line), Point(line) + 1, None)
  199.  
  200.  
  201. PointSlice = PointSlice()
  202.  
  203. class TextLine(object):
  204.     
  205.     def __init__(self, txtstr, point = None, mark = None):
  206.         self.line_buffer = []
  207.         self._point = 0
  208.         self.mark = -1
  209.         self.undo_stack = []
  210.         self.overwrite = False
  211.         if isinstance(txtstr, TextLine):
  212.             self.line_buffer = txtstr.line_buffer[:]
  213.             if point is None:
  214.                 self.point = txtstr.point
  215.             else:
  216.                 self.point = point
  217.             if mark is None:
  218.                 self.mark = txtstr.mark
  219.             else:
  220.                 self.mark = mark
  221.         else:
  222.             self._insert_text(txtstr)
  223.             if point is None:
  224.                 self.point = 0
  225.             else:
  226.                 self.point = point
  227.             if mark is None:
  228.                 self.mark = -1
  229.             else:
  230.                 self.mark = mark
  231.         self.is_word_token = wordmatcher.is_word_token
  232.         self.next_start_segment = wordmatcher.next_start_segment
  233.         self.next_end_segment = wordmatcher.next_end_segment
  234.         self.prev_start_segment = wordmatcher.prev_start_segment
  235.         self.prev_end_segment = wordmatcher.prev_end_segment
  236.  
  237.     
  238.     def push_undo(self):
  239.         ltext = self.get_line_text()
  240.         if self.undo_stack and ltext == self.undo_stack[-1].get_line_text():
  241.             self.undo_stack[-1].point = self.point
  242.         else:
  243.             self.undo_stack.append(self.copy())
  244.  
  245.     
  246.     def pop_undo(self):
  247.         if len(self.undo_stack) >= 2:
  248.             self.undo_stack.pop()
  249.             self.set_top_undo()
  250.             self.undo_stack.pop()
  251.         else:
  252.             self.reset_line()
  253.             self.undo_stack = []
  254.  
  255.     
  256.     def set_top_undo(self):
  257.         if self.undo_stack:
  258.             undo = self.undo_stack[-1]
  259.             self.line_buffer = undo.line_buffer
  260.             self.point = undo.point
  261.             self.mark = undo.mark
  262.         
  263.  
  264.     
  265.     def __repr__(self):
  266.         return 'TextLine("%s",point=%s,mark=%s)' % (self.line_buffer, self.point, self.mark)
  267.  
  268.     
  269.     def copy(self):
  270.         return self.__class__(self)
  271.  
  272.     
  273.     def set_point(self, value):
  274.         if isinstance(value, LinePositioner):
  275.             value = value(self)
  276.         
  277.         if value > len(self.line_buffer):
  278.             value = len(self.line_buffer)
  279.         
  280.         self._point = value
  281.  
  282.     
  283.     def get_point(self):
  284.         return self._point
  285.  
  286.     point = property(get_point, set_point)
  287.     
  288.     def visible_line_width(self, position = Point):
  289.         extra_char_width = [](_[1])
  290.         return len(self[:position].quoted_text()) + self[:position].line_buffer.count('\t') * 7 + extra_char_width
  291.  
  292.     
  293.     def quoted_text(self):
  294.         quoted = [ quote_char(c) for c in self.line_buffer ]
  295.         self.line_char_width = [ len(c) for c in quoted ]
  296.         return u''.join(map(ensure_unicode, quoted))
  297.  
  298.     
  299.     def get_line_text(self):
  300.         buf = self.line_buffer
  301.         buf = map(ensure_unicode, buf)
  302.         return u''.join(buf)
  303.  
  304.     
  305.     def set_line(self, text, cursor = None):
  306.         self.line_buffer = [ c for c in str(text) ]
  307.  
  308.     
  309.     def reset_line(self):
  310.         self.line_buffer = []
  311.         self.point = 0
  312.  
  313.     
  314.     def end_of_line(self):
  315.         self.point = len(self.line_buffer)
  316.  
  317.     
  318.     def _insert_text(self, text):
  319.         pass
  320.  
  321.     
  322.     def __getitem__(self, key):
  323.         if isinstance(key, LineSlice):
  324.             key = key(self)
  325.         
  326.         if isinstance(key, slice):
  327.             if key.step is None:
  328.                 pass
  329.             else:
  330.                 raise Error
  331.             if (key.step is None).start is None:
  332.                 start = StartOfLine(self)
  333.             elif isinstance(key.start, LinePositioner):
  334.                 start = key.start(self)
  335.             else:
  336.                 start = key.start
  337.             if key.stop is None:
  338.                 stop = EndOfLine(self)
  339.             elif isinstance(key.stop, LinePositioner):
  340.                 stop = key.stop(self)
  341.             else:
  342.                 stop = key.stop
  343.             return self.__class__(self.line_buffer[start:stop], point = 0)
  344.         if isinstance(key, LinePositioner):
  345.             return self.line_buffer[key(self)]
  346.         if isinstance(key, tuple):
  347.             raise IndexError('Cannot use step in line buffer indexing')
  348.         isinstance(key, tuple)
  349.         return self.line_buffer[key]
  350.  
  351.     
  352.     def __delitem__(self, key):
  353.         point = self.point
  354.         if isinstance(key, LineSlice):
  355.             key = key(self)
  356.         
  357.         if isinstance(key, slice):
  358.             start = key.start
  359.             stop = key.stop
  360.             if isinstance(start, LinePositioner):
  361.                 start = start(self)
  362.             elif start is None:
  363.                 start = 0
  364.             
  365.             if isinstance(stop, LinePositioner):
  366.                 stop = stop(self)
  367.             elif stop is None:
  368.                 stop = EndOfLine(self)
  369.             
  370.         elif isinstance(key, LinePositioner):
  371.             start = key(self)
  372.             stop = start + 1
  373.         else:
  374.             start = key
  375.             stop = key + 1
  376.         prev = self.line_buffer[:start]
  377.         rest = self.line_buffer[stop:]
  378.         self.line_buffer = prev + rest
  379.         if point > stop:
  380.             self.point = point - stop - start
  381.         elif point >= start and point <= stop:
  382.             self.point = start
  383.         
  384.  
  385.     
  386.     def __setitem__(self, key, value):
  387.         if isinstance(key, LineSlice):
  388.             key = key(self)
  389.         
  390.         if isinstance(key, slice):
  391.             start = key.start
  392.             stop = key.stop
  393.         elif isinstance(key, LinePositioner):
  394.             start = key(self)
  395.             stop = start + 1
  396.         else:
  397.             start = key
  398.             stop = key + 1
  399.         prev = self.line_buffer[:start]
  400.         value = self.__class__(value).line_buffer
  401.         rest = self.line_buffer[stop:]
  402.         out = prev + value + rest
  403.         if len(out) >= len(self):
  404.             self.point = len(self)
  405.         
  406.         self.line_buffer = out
  407.  
  408.     
  409.     def __len__(self):
  410.         return len(self.line_buffer)
  411.  
  412.     
  413.     def upper(self):
  414.         self.line_buffer = [ x.upper() for x in self.line_buffer ]
  415.         return self
  416.  
  417.     
  418.     def lower(self):
  419.         self.line_buffer = [ x.lower() for x in self.line_buffer ]
  420.         return self
  421.  
  422.     
  423.     def capitalize(self):
  424.         self.set_line(self.get_line_text().capitalize(), self.point)
  425.         return self
  426.  
  427.     
  428.     def startswith(self, txt):
  429.         return self.get_line_text().startswith(txt)
  430.  
  431.     
  432.     def endswith(self, txt):
  433.         return self.get_line_text().endswith(txt)
  434.  
  435.     
  436.     def __contains__(self, txt):
  437.         return txt in self.get_line_text()
  438.  
  439.  
  440. lines = [
  441.     TextLine('abc'),
  442.     TextLine('abc def'),
  443.     TextLine('abc def  ghi'),
  444.     TextLine('  abc  def  ')]
  445. l = lines[2]
  446. l.point = 5
  447.  
  448. class ReadLineTextBuffer(TextLine):
  449.     
  450.     def __init__(self, txtstr, point = None, mark = None):
  451.         super(ReadLineTextBuffer, self).__init__(txtstr, point, mark)
  452.         self.enable_win32_clipboard = True
  453.         self.selection_mark = -1
  454.         self.enable_selection = True
  455.         self.kill_ring = []
  456.  
  457.     
  458.     def __repr__(self):
  459.         return 'ReadLineTextBuffer("%s",point=%s,mark=%s,selection_mark=%s)' % (self.line_buffer, self.point, self.mark, self.selection_mark)
  460.  
  461.     
  462.     def insert_text(self, char):
  463.         self.delete_selection()
  464.         self.selection_mark = -1
  465.         self._insert_text(char)
  466.  
  467.     
  468.     def to_clipboard(self):
  469.         if self.enable_win32_clipboard:
  470.             clipboard.set_clipboard_text(self.get_line_text())
  471.         
  472.  
  473.     
  474.     def beginning_of_line(self):
  475.         self.selection_mark = -1
  476.         self.point = StartOfLine
  477.  
  478.     
  479.     def end_of_line(self):
  480.         self.selection_mark = -1
  481.         self.point = EndOfLine
  482.  
  483.     
  484.     def forward_char(self, argument = 1):
  485.         if argument < 0:
  486.             self.backward_char(-argument)
  487.         
  488.         self.selection_mark = -1
  489.         for x in range(argument):
  490.             self.point = NextChar
  491.         
  492.  
  493.     
  494.     def backward_char(self, argument = 1):
  495.         if argument < 0:
  496.             self.forward_char(-argument)
  497.         
  498.         self.selection_mark = -1
  499.         for x in range(argument):
  500.             self.point = PrevChar
  501.         
  502.  
  503.     
  504.     def forward_word(self, argument = 1):
  505.         if argument < 0:
  506.             self.backward_word(-argument)
  507.         
  508.         self.selection_mark = -1
  509.         for x in range(argument):
  510.             self.point = NextWordStart
  511.         
  512.  
  513.     
  514.     def backward_word(self, argument = 1):
  515.         if argument < 0:
  516.             self.forward_word(-argument)
  517.         
  518.         self.selection_mark = -1
  519.         for x in range(argument):
  520.             self.point = PrevWordStart
  521.         
  522.  
  523.     
  524.     def forward_word_end(self, argument = 1):
  525.         if argument < 0:
  526.             self.backward_word_end(-argument)
  527.         
  528.         self.selection_mark = -1
  529.         for x in range(argument):
  530.             self.point = NextWordEnd
  531.         
  532.  
  533.     
  534.     def backward_word_end(self, argument = 1):
  535.         if argument < 0:
  536.             self.forward_word_end(-argument)
  537.         
  538.         self.selection_mark = -1
  539.         for x in range(argument):
  540.             self.point = NextWordEnd
  541.         
  542.  
  543.     
  544.     def beginning_of_line_extend_selection(self):
  545.         if self.enable_selection and self.selection_mark < 0:
  546.             self.selection_mark = self.point
  547.         
  548.         self.point = StartOfLine
  549.  
  550.     
  551.     def end_of_line_extend_selection(self):
  552.         if self.enable_selection and self.selection_mark < 0:
  553.             self.selection_mark = self.point
  554.         
  555.         self.point = EndOfLine
  556.  
  557.     
  558.     def forward_char_extend_selection(self, argument = 1):
  559.         if argument < 0:
  560.             self.backward_char_extend_selection(-argument)
  561.         
  562.         if self.enable_selection and self.selection_mark < 0:
  563.             self.selection_mark = self.point
  564.         
  565.         for x in range(argument):
  566.             self.point = NextChar
  567.         
  568.  
  569.     
  570.     def backward_char_extend_selection(self, argument = 1):
  571.         if argument < 0:
  572.             self.forward_char_extend_selection(-argument)
  573.         
  574.         if self.enable_selection and self.selection_mark < 0:
  575.             self.selection_mark = self.point
  576.         
  577.         for x in range(argument):
  578.             self.point = PrevChar
  579.         
  580.  
  581.     
  582.     def forward_word_extend_selection(self, argument = 1):
  583.         if argument < 0:
  584.             self.backward_word_extend_selection(-argument)
  585.         
  586.         if self.enable_selection and self.selection_mark < 0:
  587.             self.selection_mark = self.point
  588.         
  589.         for x in range(argument):
  590.             self.point = NextWordStart
  591.         
  592.  
  593.     
  594.     def backward_word_extend_selection(self, argument = 1):
  595.         if argument < 0:
  596.             self.forward_word_extend_selection(-argument)
  597.         
  598.         if self.enable_selection and self.selection_mark < 0:
  599.             self.selection_mark = self.point
  600.         
  601.         for x in range(argument):
  602.             self.point = PrevWordStart
  603.         
  604.  
  605.     
  606.     def forward_word_end_extend_selection(self, argument = 1):
  607.         if argument < 0:
  608.             self.backward_word_end_extend_selection(-argument)
  609.         
  610.         if self.enable_selection and self.selection_mark < 0:
  611.             self.selection_mark = self.point
  612.         
  613.         for x in range(argument):
  614.             self.point = NextWordEnd
  615.         
  616.  
  617.     
  618.     def backward_word_end_extend_selection(self, argument = 1):
  619.         if argument < 0:
  620.             self.forward_word_end_extend_selection(-argument)
  621.         
  622.         if self.enable_selection and self.selection_mark < 0:
  623.             self.selection_mark = self.point
  624.         
  625.         for x in range(argument):
  626.             self.point = PrevWordEnd
  627.         
  628.  
  629.     
  630.     def delete_selection(self):
  631.         if self.enable_selection and self.selection_mark >= 0:
  632.             if self.selection_mark < self.point:
  633.                 del self[self.selection_mark:self.point]
  634.                 self.selection_mark = -1
  635.             else:
  636.                 del self[self.point:self.selection_mark]
  637.                 self.selection_mark = -1
  638.             return True
  639.         self.selection_mark = -1
  640.         return False
  641.  
  642.     
  643.     def delete_char(self, argument = 1):
  644.         if argument < 0:
  645.             self.backward_delete_char(-argument)
  646.         
  647.         if self.delete_selection():
  648.             argument -= 1
  649.         
  650.         for x in range(argument):
  651.             del self[Point]
  652.         
  653.  
  654.     
  655.     def backward_delete_char(self, argument = 1):
  656.         if argument < 0:
  657.             self.delete_char(-argument)
  658.         
  659.         if self.delete_selection():
  660.             argument -= 1
  661.         
  662.         for x in range(argument):
  663.             if self.point > 0:
  664.                 self.backward_char()
  665.                 self.delete_char()
  666.                 continue
  667.         
  668.  
  669.     
  670.     def forward_delete_word(self, argument = 1):
  671.         if argument < 0:
  672.             self.backward_delete_word(-argument)
  673.         
  674.         if self.delete_selection():
  675.             argument -= 1
  676.         
  677.         for x in range(argument):
  678.             del self[Point:NextWordStart]
  679.         
  680.  
  681.     
  682.     def backward_delete_word(self, argument = 1):
  683.         if argument < 0:
  684.             self.forward_delete_word(-argument)
  685.         
  686.         if self.delete_selection():
  687.             argument -= 1
  688.         
  689.         for x in range(argument):
  690.             del self[PrevWordStart:Point]
  691.         
  692.  
  693.     
  694.     def delete_current_word(self):
  695.         if not self.delete_selection():
  696.             del self[CurrentWord]
  697.         
  698.         self.selection_mark = -1
  699.  
  700.     
  701.     def delete_horizontal_space(self):
  702.         if self[Point] in ' \t':
  703.             del self[PrevWordEnd:NextWordStart]
  704.         
  705.         self.selection_mark = -1
  706.  
  707.     
  708.     def upcase_word(self):
  709.         p = self.point
  710.         
  711.         try:
  712.             self[CurrentWord] = self[CurrentWord].upper()
  713.             self.point = p
  714.         except NotAWordError:
  715.             pass
  716.  
  717.  
  718.     
  719.     def downcase_word(self):
  720.         p = self.point
  721.         
  722.         try:
  723.             self[CurrentWord] = self[CurrentWord].lower()
  724.             self.point = p
  725.         except NotAWordError:
  726.             pass
  727.  
  728.  
  729.     
  730.     def capitalize_word(self):
  731.         p = self.point
  732.         
  733.         try:
  734.             self[CurrentWord] = self[CurrentWord].capitalize()
  735.             self.point = p
  736.         except NotAWordError:
  737.             pass
  738.  
  739.  
  740.     
  741.     def transpose_chars(self):
  742.         p2 = Point(self)
  743.         if p2 == 0:
  744.             return None
  745.         if p2 == len(self):
  746.             p2 = p2 - 1
  747.         
  748.         p1 = p2 - 1
  749.         self[p2] = self[p1]
  750.         self[p1] = self[p2]
  751.         self.point = p2 + 1
  752.  
  753.     
  754.     def transpose_words(self):
  755.         word1 = TextLine(self)
  756.         word2 = TextLine(self)
  757.         if self.point == len(self):
  758.             word2.point = PrevWordStart
  759.             word1.point = PrevWordStart(word2)
  760.         else:
  761.             word1.point = PrevWordStart
  762.             word2.point = NextWordStart
  763.         stop1 = NextWordEnd(word1)
  764.         stop2 = NextWordEnd(word2)
  765.         start1 = word1.point
  766.         start2 = word2.point
  767.         self[start2:stop2] = word1[Point:NextWordEnd]
  768.         self[start1:stop1] = word2[Point:NextWordEnd]
  769.         self.point = stop2
  770.  
  771.     
  772.     def kill_line(self):
  773.         self.add_to_kill_ring(self[self.point:])
  774.         del self.line_buffer[self.point:]
  775.  
  776.     
  777.     def kill_whole_line(self):
  778.         self.add_to_kill_ring(self[:])
  779.         del self[:]
  780.  
  781.     
  782.     def backward_kill_line(self):
  783.         del self[StartOfLine:Point]
  784.  
  785.     
  786.     def unix_line_discard(self):
  787.         del self[StartOfLine:Point]
  788.  
  789.     
  790.     def kill_word(self):
  791.         del self[Point:NextWordEnd]
  792.  
  793.     
  794.     def backward_kill_word(self):
  795.         if not self.delete_selection():
  796.             del self[PrevWordStart:Point]
  797.         
  798.         self.selection_mark = -1
  799.  
  800.     
  801.     def forward_kill_word(self):
  802.         if not self.delete_selection():
  803.             del self[Point:NextWordEnd]
  804.         
  805.         self.selection_mark = -1
  806.  
  807.     
  808.     def unix_word_rubout(self):
  809.         if not self.delete_selection():
  810.             del self[PrevSpace:Point]
  811.         
  812.         self.selection_mark = -1
  813.  
  814.     
  815.     def kill_region(self):
  816.         pass
  817.  
  818.     
  819.     def copy_region_as_kill(self):
  820.         pass
  821.  
  822.     
  823.     def copy_backward_word(self):
  824.         pass
  825.  
  826.     
  827.     def copy_forward_word(self):
  828.         pass
  829.  
  830.     
  831.     def yank(self):
  832.         self.paste_from_kill_ring()
  833.  
  834.     
  835.     def yank_pop(self):
  836.         pass
  837.  
  838.     
  839.     def set_mark(self):
  840.         self.mark = self.point
  841.  
  842.     
  843.     def exchange_point_and_mark(self):
  844.         pass
  845.  
  846.     
  847.     def copy_region_to_clipboard(self):
  848.         if self.enable_win32_clipboard:
  849.             mark = min(self.mark, len(self.line_buffer))
  850.             cursor = min(self.point, len(self.line_buffer))
  851.             if self.mark == -1:
  852.                 return None
  853.             begin = min(cursor, mark)
  854.             end = max(cursor, mark)
  855.             toclipboard = ''.join(self.line_buffer[begin:end])
  856.             clipboard.SetClipboardText(toclipboard)
  857.         
  858.  
  859.     
  860.     def copy_selection_to_clipboard(self):
  861.         if self.enable_win32_clipboard and self.enable_selection and self.selection_mark >= 0:
  862.             selection_mark = min(self.selection_mark, len(self.line_buffer))
  863.             cursor = min(self.point, len(self.line_buffer))
  864.             if self.selection_mark == -1:
  865.                 return None
  866.             begin = min(cursor, selection_mark)
  867.             end = max(cursor, selection_mark)
  868.             toclipboard = ''.join(self.line_buffer[begin:end])
  869.             clipboard.SetClipboardText(toclipboard)
  870.         
  871.  
  872.     
  873.     def cut_selection_to_clipboard(self):
  874.         self.copy_selection_to_clipboard()
  875.         self.delete_selection()
  876.  
  877.     
  878.     def add_to_kill_ring(self, txt):
  879.         self.kill_ring = [
  880.             txt]
  881.         if kill_ring_to_clipboard:
  882.             clipboard.SetClipboardText(txt.get_line_text())
  883.         
  884.  
  885.     
  886.     def paste_from_kill_ring(self):
  887.         if self.kill_ring:
  888.             self.insert_text(self.kill_ring[0])
  889.         
  890.  
  891.  
  892. q = ReadLineTextBuffer('asff asFArw  ewrWErhg', point = 8)
  893. q = TextLine('asff asFArw  ewrWErhg', point = 8)
  894.  
  895. def show_pos(buff, pos, chr = '.'):
  896.     l = len(buff.line_buffer)
  897.     
  898.     def choice(bool):
  899.         if bool:
  900.             return chr
  901.         return ' '
  902.  
  903.     return []([ choice(pos == idx) for idx in range(l + 1) ])
  904.  
  905.  
  906. def test_positioner(buff, points, positioner):
  907.     print (' %s ' % positioner.__class__.__name__).center(40, '-')
  908.     buffstr = buff.line_buffer
  909.     print '"%s"' % buffstr
  910.     for point in points:
  911.         b = TextLine(buff, point = point)
  912.         out = [
  913.             ' '] * (len(buffstr) + 1)
  914.         pos = positioner(b)
  915.         if pos == point:
  916.             out[pos] = '&'
  917.         else:
  918.             out[point] = '.'
  919.             out[pos] = '^'
  920.         print '"%s"' % ''.join(out)
  921.     
  922.  
  923.