src/FukuiNoNamari/thread_view.py

   1 # Copyright (C) 2007 by Aiwota Programmer
   2 # aiwotaprog@tetteke.tk
   3 #
   4 # This program is free software; you can redistribute it and/or modify
   5 # it under the terms of the GNU General Public License as published by
   6 # the Free Software Foundation; either version 2 of the License, or
   7 # (at your option) any later version.
   8 #
   9 # This program is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 # GNU General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU General Public License
  15 # along with this program; if not, write to the Free Software
  16 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17
  18 import pygtk
  19 pygtk.require('2.0')
  20 import gtk
  21 import pango
  22 import gobject
  23 import itertools
  24 from FukuiNoNamariExt import thread_view_extend
  25
  26
  27 def get_approximate_char_height(pango_context):
  28     desc = pango_context.get_font_description()
  29     font = pango_context.load_font(desc)
  30     ink, log = font.get_glyph_extents(0)
  31     return log[3] / pango.SCALE + 2
  32
  33
  34 class Rectangle:
  35     def __init__(self, x, y, width, height):
  36         self.x = x
  37         self.y = y
  38         self.width = width
  39         self.height = height
  40
  41
  42 class Line:
  43
  44     HEIGHT = 15
  45
  46     def __init__(self, start_index, end_index, rectangle):
  47         self.start_index = start_index
  48         self.end_index = end_index
  49         self.rectangle = rectangle
  50
  51     def is_on_xy(self, x, y):
  52         left = self.rectangle.x
  53         right = left + self.rectangle.width
  54         top = self.rectangle.y
  55         bottom = top + self.rectangle.height
  56         return x >= left and x < right and y >= top and y < bottom
  57
  58
  59 class ElementEmpty:
  60
  61     def __init__(self, pango_layout):
  62         self.pango_layout = pango_layout
  63         self.initialize()
  64
  65     def recalc_char_widths(self):
  66         pass
  67
  68     def initialize(self):
  69         self.line_list = []
  70
  71     def is_on_xy(self, x, y):
  72         for line in self.line_list:
  73             if line.is_on_xy(x, y):
  74                 return True
  75         return False
  76
  77     def xy_to_index(self, x, y):
  78         return 0
  79
  80     def build_line_list(self, x, y, width, left_margin):
  81         self.initialize()
  82
  83         line = Line(0, 0, Rectangle(
  84             x, y, width - x,
  85             get_approximate_char_height(self.pango_layout.get_context())))
  86         self.line_list.append(line)
  87
  88         return width, y
  89
  90     def get_text(self, selection=False, start_index=0, end_index=0xffffff):
  91         return ""
  92
  93     def draw(self, drawingarea, y_offset, pango_layout,
  94              selection=False, start_index=0, end_index=0xffffff):
  95         pass
  96
  97
  98 class ElementText:
  99
 100     ch_width_dict = {}   # key: char, value: width
 101
 102     def __init__(self, text, pango_layout):
 103         self.text = text
 104         self.pango_layout = pango_layout
 105
 106         self.recalc_char_widths()
 107
 108         self.line_list = []
 109
 110     def recalc_char_widths(self):
 111         self.widths = [i for i in itertools.repeat(0, len(self.text))]
 112
 113         dict = self._get_ch_width_dict()
 114         need_to_get = False
 115         for index, ch in enumerate(self.text):
 116             if ch not in dict:
 117                 need_to_get = True
 118                 break
 119             else:
 120                 width = dict[ch]
 121                 self.widths[index] = width
 122
 123         if need_to_get:
 124             attrlist = self._get_attrs()
 125             self.widths = thread_view_extend.get_char_width(
 126                 self.pango_layout.get_context(), self.text, attrlist)
 127             for index, width in enumerate(self.widths):
 128                 dict[self.text[index]] = self.widths[index]
 129
 130     def _get_ch_width_dict(self):
 131         return ElementText.ch_width_dict
 132
 133     def _get_attrs(self):
 134         attrs = pango.AttrList()
 135         return attrs
 136
 137     def is_on_xy(self, x, y):
 138         for line in self.line_list:
 139             if line.is_on_xy(x, y):
 140                 return True
 141         return False
 142
 143     def xy_to_index(self, x, y):
 144         for line in self.line_list:
 145             top = line.rectangle.y
 146             bottom = top + line.rectangle.height
 147             if y >= top and y < bottom:
 148                 sum_of_widths = line.rectangle.x
 149                 index = line.start_index
 150                 for width in self.widths[line.start_index:line.end_index]:
 151                     if sum_of_widths + width/2 > x:
 152                         break
 153                     sum_of_widths += width
 154                     index += 1
 155                 return index
 156
 157     def build_line_list(self, x, y, width, left_margin):
 158         self.line_list = []
 159
 160         current_line_start_index = 0
 161         current_line_x = x
 162         current_line_y = y
 163         current_line_width = 0
 164
 165         ch_h = get_approximate_char_height(self.pango_layout.get_context())
 166
 167         for index, ch in enumerate(self.text):
 168             ch_w = self.widths[index]
 169             if current_line_x + current_line_width + ch_w > width:
 170                 line = Line(
 171                     current_line_start_index, index,
 172                     Rectangle(
 173                     current_line_x, current_line_y,
 174                     current_line_width, ch_h))
 175                 self.line_list.append(line)
 176
 177                 current_line_start_index = index
 178                 current_line_x = left_margin
 179                 current_line_y += ch_h
 180                 current_line_width = ch_w
 181             else:
 182                 current_line_width += ch_w
 183
 184         if current_line_start_index < len(self.text):
 185             line = Line(current_line_start_index, len(self.text),
 186                         Rectangle(current_line_x,
 187                                           current_line_y,
 188                                           current_line_width,
 189                                           ch_h))
 190             self.line_list.append(line)
 191
 192             current_line_x += current_line_width
 193
 194         return current_line_x, current_line_y
 195
 196     def get_text(self, selection=False, start_index=0, end_index=0xffffff):
 197
 198         text = ""
 199
 200         for line in self.line_list:
 201
 202             t = self.text[line.start_index:line.end_index]
 203             if selection:
 204                 s = start_index - line.start_index
 205                 s = max(s, 0)
 206                 s = min(s, line.end_index - line.start_index)
 207
 208                 e = end_index - line.start_index
 209                 e = min(e, line.end_index - line.start_index)
 210                 e = max(e, 0)
 211
 212                 t = t[s:e]
 213
 214             text += t
 215
 216         return text
 217
 218     def draw(self, drawingarea, y_offset, pango_layout,
 219              selection=False, start_index=0, end_index=0xffffff):
 220
 221         if drawingarea.get_property("has-focus"):
 222             selection_fg = drawingarea.style.text[gtk.STATE_SELECTED]
 223             selection_bg = drawingarea.style.base[gtk.STATE_SELECTED]
 224         else:
 225             selection_fg = drawingarea.style.text[gtk.STATE_ACTIVE]
 226             selection_bg = drawingarea.style.base[gtk.STATE_ACTIVE]
 227
 228         for line in self.line_list:
 229
 230             text = self.text[line.start_index:line.end_index]
 231             u_text = text.encode("utf8")
 232             gc = drawingarea.window.new_gc()
 233             gc.set_foreground(drawingarea.style.text[gtk.STATE_NORMAL])
 234             gc.set_background(drawingarea.style.base[gtk.STATE_NORMAL])
 235             attrs = self._get_attrs()
 236             if selection:
 237
 238                 s = start_index - line.start_index
 239                 s = max(s, 0)
 240                 s = min(s, line.end_index - line.start_index)
 241                 s = len(text[:s].encode("utf8"))
 242
 243                 e = end_index - line.start_index
 244                 e = min(e, line.end_index - line.start_index)
 245                 e = max(e, 0)
 246                 e = len(text[:e].encode("utf8"))
 247
 248                 selection_all_attr_fg = pango.AttrForeground(
 249                     selection_fg.red, selection_fg.green, selection_fg.blue,
 250                     s, e)
 251                 selection_all_attr_bg= pango.AttrBackground(
 252                     selection_bg.red, selection_bg.green, selection_bg.blue,
 253                     s, e)
 254                 attrs.insert(selection_all_attr_fg)
 255                 attrs.insert(selection_all_attr_bg)
 256
 257             pango_layout.set_text(u_text)
 258             pango_layout.set_attributes(attrs)
 259             drawingarea.window.draw_layout(
 260                 gc, int(line.rectangle.x), line.rectangle.y + y_offset,
 261                 pango_layout)
 262
 263
 264 class ElementBoldText(ElementText):
 265
 266     def _get_attrs(self):
 267         attrlist = pango.AttrList()
 268         attr = pango.AttrWeight(pango.WEIGHT_BOLD,
 269                                    end_index=0xffffff)
 270         attrlist.insert(attr)
 271         return attrlist
 272
 273     def recalc_char_widths(self):
 274         attrlist = self._get_attrs()
 275         self.widths = thread_view_extend.get_char_width(
 276             self.pango_layout.get_context(), self.text, attrlist)
 277
 278
 279 class ElementLink(ElementText):
 280
 281     def __init__(self, text, href, pango_layout):
 282         self.href = href
 283         ElementText.__init__(self, text, pango_layout)
 284
 285     def _get_attrs(self):
 286         attrlist = pango.AttrList()
 287         attr = pango.AttrUnderline(pango.UNDERLINE_SINGLE,
 288                                    end_index=0xffffff)
 289         attrlist.insert(attr)
 290         return attrlist
 291
 292
 293 class ResLayout:
 294 # represent one line
 295
 296     def __init__(self, left_margin, resnum, pango_layout):
 297         self.element_list = [ElementEmpty(pango_layout)]
 298         self.width = 0
 299         self.height = 0
 300         self.pango_layout = pango_layout
 301         self.left_margin = left_margin
 302         self.resnum = resnum
 303         self.posY = 0
 304         self.list_index = 0
 305
 306     def add_text(self, text, bold, href):
 307         if isinstance(self.element_list[0], ElementEmpty):
 308             self.element_list = []
 309
 310         if href:
 311             element = ElementLink(text, href, self.pango_layout)
 312             self.element_list.append(element)
 313         elif bold:
 314             element = ElementBoldText(text, self.pango_layout)
 315             self.element_list.append(element)
 316         else:
 317             element = ElementText(text, self.pango_layout)
 318             self.element_list.append(element)
 319
 320     def get_element_from_xy(self, x, y):
 321         for element in self.element_list:
 322             if element.is_on_xy(x, y):
 323                 return element
 324         return None
 325
 326     def get_close_element_from_xy(self, x, y):
 327         x= max(x, self.left_margin)
 328         element = self.get_element_from_xy(x, y)
 329         if element is None and len(self.element_list) != 0:
 330             element = self.element_list[len(self.element_list) - 1]
 331         return element
 332
 333     def recalc_char_widths(self):
 334         for element in self.element_list:
 335             element.recalc_char_widths()
 336
 337     def set_width(self, width):
 338
 339         self.width = width
 340
 341         current_x = self.left_margin
 342         current_y = 0
 343
 344         for element in self.element_list:
 345             current_x, current_y = element.build_line_list(
 346                 current_x, current_y, width, self.left_margin)
 347
 348         self.height = current_y + get_approximate_char_height(self.pango_layout.get_context())
 349
 350     def get_pixel_size(self):
 351         return self.width, self.height
 352
 353     def get_text(self, selection_start, selection_end):
 354         s_s = selection_start
 355         e_s = selection_end
 356         s_l, s_e, s_i = selection_start
 357         e_l, e_e, e_i = selection_end
 358
 359         text = ""
 360
 361         if (s_l is None or s_e is None or s_i is None or
 362             e_l is None or e_e is None or e_i is None or
 363             self.posY < s_l.posY or self.posY > e_l.posY):
 364
 365             # nothing to do
 366             pass
 367
 368         elif self.posY > s_s[0].posY and self.posY < e_s[0].posY:
 369
 370             for element in self.element_list:
 371                 text += element.get_text(selection=True)
 372
 373         elif self == s_s[0] and self == e_s[0]:
 374
 375             selection = False
 376
 377             for element in self.element_list:
 378                 if s_e == element:
 379                     selection = True
 380                     start = s_i
 381                     end = 0xffffff
 382                     if e_e == element:
 383                         end = e_i
 384                         selection = False
 385                     text += element.get_text(selection=True, start_index=start,
 386                                              end_index=end)
 387                 elif e_e == element:
 388                     end = e_i
 389                     selection = False
 390                     text += element.get_text(
 391                         selection=True, end_index=end)
 392                 elif selection:
 393                     text += element.get_text(selection=True)
 394
 395         elif self == s_s[0]:
 396
 397             selection = False
 398
 399             for element in self.element_list:
 400                 if s_e == element:
 401                     selection = True
 402                     start = s_i
 403                     text += element.get_text(selection=True, start_index=start)
 404                 elif selection:
 405                     text += element.get_text(selection=True)
 406
 407         elif self == e_s[0]:
 408
 409             selection = True
 410
 411             for element in self.element_list:
 412                 if e_e == element:
 413                     end = e_i
 414                     text += element.get_text(selection=True, end_index=e_i)
 415                     selection = False
 416                 elif selection:
 417                     text += element.get_text(selection=True)
 418
 419         else:
 420             # nothing to do
 421             pass
 422
 423         return text
 424
 425
 426     def draw(self, drawingarea, x_offset, y_offset,
 427              start_selection, end_selection):
 428
 429         s_s = start_selection
 430         e_s = end_selection
 431
 432         s_l, s_e, s_i = s_s
 433         e_l, e_e, e_i = e_s
 434
 435         if (s_l is None or s_e is None or s_i is None or
 436             e_l is None or e_e is None or e_i is None or
 437             self.posY < s_l.posY or self.posY > e_l.posY):
 438
 439             for element in self.element_list:
 440                 element.draw(drawingarea, y_offset, self.pango_layout)
 441
 442         elif self.posY > s_s[0].posY and self.posY < e_s[0].posY:
 443
 444             for element in self.element_list:
 445                 element.draw(drawingarea, y_offset, self.pango_layout,
 446                              selection=True)
 447
 448         elif self == s_s[0] and self == e_s[0]:
 449
 450             selection = False
 451
 452             for element in self.element_list:
 453                 if s_e == element:
 454                     selection = True
 455                     start = s_i
 456                     end = 0xffffff
 457                     if e_e == element:
 458                         end = e_i
 459                         selection = False
 460                     element.draw(drawingarea, y_offset, self.pango_layout,
 461                                  selection=True,
 462                                  start_index=start,
 463                                  end_index=end)
 464                 elif e_e == element:
 465                     end = e_i
 466                     selection = False
 467                     element.draw(drawingarea, y_offset, self.pango_layout,
 468                                  selection=True, end_index=end)
 469                 else:
 470                     element.draw(drawingarea, y_offset, self.pango_layout,
 471                                  selection=selection)
 472
 473         elif self == s_s[0]:
 474
 475             selection = False
 476
 477             for element in self.element_list:
 478                 if s_e == element:
 479                     selection = True
 480                     start = s_i
 481                     element.draw(drawingarea, y_offset, self.pango_layout,
 482                                  selection=selection, start_index = start)
 483                 else:
 484                     element.draw(drawingarea, y_offset, self.pango_layout,
 485                                  selection=selection)
 486
 487         elif self == e_s[0]:
 488
 489             selection = True
 490
 491             for element in self.element_list:
 492                 if e_e == element:
 493                     end = e_i
 494                     element.draw(drawingarea, y_offset, self.pango_layout,
 495                                  selection=selection, end_index=e_i)
 496                     selection = False
 497                 else:
 498                     element.draw(drawingarea, y_offset, self.pango_layout,
 499                                  selection=selection)
 500
 501         else:
 502             for element in self.element_list:
 503                 element.draw(drawingarea, y_offset, self.pango_layout)
 504
 505     def clone(self):
 506         import copy
 507         layout = ResLayout(self.left_margin, self.resnum, self.pango_layout)
 508         layout.element_list = []
 509         for element in self.element_list:
 510             layout.element_list.append(copy.copy(element))
 511         return layout
 512
 513
 514 class ThreadView(gtk.HBox):
 515     __gsignals__ = {
 516         "cursor-over-link-event":
 517         (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (object, object, )),
 518         "uri-clicked-event":
 519         (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (object, ))
 520         }
 521
 522     hand_cursor = gtk.gdk.Cursor(gtk.gdk.HAND2)
 523     regular_cursor = gtk.gdk.Cursor(gtk.gdk.XTERM)
 524     arrow_cursor = gtk.gdk.Cursor(gtk.gdk.LEFT_PTR)
 525
 526     def __init__(self):
 527         gtk.HBox.__init__(self, False, 0)
 528         self.drawingarea = gtk.DrawingArea()
 529         self.drawingarea.set_property("can_focus", True)
 530
 531         self.vscrollbar = gtk.VScrollbar()
 532         self.pack_start(self.drawingarea)
 533         self.pack_start(self.vscrollbar, expand=False)
 534         self.adjustment  = self.vscrollbar.get_adjustment()
 535
 536         self.drawingarea.add_events(
 537             gtk.gdk.KEY_PRESS_MASK |
 538             gtk.gdk.SCROLL_MASK |
 539             gtk.gdk.POINTER_MOTION_MASK |
 540             gtk.gdk.BUTTON_PRESS_MASK |
 541             gtk.gdk.BUTTON_RELEASE_MASK)
 542
 543         self.drawingarea_prev_width = 0
 544
 545         self.drawingarea.connect(
 546             "expose-event", self.on_drawingarea_expose_event)
 547         self.drawingarea.connect(
 548             "configure-event", self.on_drawingarea_configure_event)
 549         self.drawingarea.connect(
 550             "scroll-event", self.on_drawingarea_scroll_event)
 551         self.drawingarea.connect(
 552             "motion-notify-event", self.on_drawingrarea_motion_notify_event)
 553         self.drawingarea.connect(
 554             "button-press-event", self.on_drawingarea_button_press_event)
 555         self.drawingarea.connect(
 556             "button-release-event", self.on_drawingarea_button_release_event)
 557         self.drawingarea.connect(
 558             "style-set", self.on_drawingarea_style_set)
 559         self.drawingarea.connect(
 560             "key-press-event", self.on_drawingarea_key_press_event)
 561         self.adjustment.connect(
 562             "value-changed", self.on_adjustment_value_changed)
 563         self.adjustment.connect(
 564             "changed", self.on_adjustment_changed)
 565
 566         self.pango_layout = self.drawingarea.create_pango_layout("")
 567
 568         self.initialize_buffer()
 569
 570         self.button1_pressed = False
 571         self.current_pressed_uri = None
 572
 573         self.popupmenu = None
 574         self.menu_openuri = None
 575         self.menu_copylinkaddress = None
 576         self.menu_separator_link = None
 577         self.menu_copyselection = None
 578         self.menu_openasuri = None
 579         self.menu_separator_selection = None
 580
 581         self.menud_uri = None
 582
 583         # for selection
 584         self.button_pressed_pt = (None, None, None)
 585         self.button_moving_pt = (None, None, None)
 586
 587     def initialize_buffer(self):
 588         self.res_layout_list = []
 589
 590     def add_layout(self, res_layout):
 591         if (len(self.res_layout_list) != 0):
 592             last = self.res_layout_list[len(self.res_layout_list)-1]
 593             x, y = last.get_pixel_size()
 594             res_layout.posY = last.posY + y
 595         self.set_layout_width(res_layout)
 596         res_layout.list_index = len(self.res_layout_list)
 597         self.res_layout_list.append(res_layout)
 598
 599         x, y = res_layout.get_pixel_size()
 600         self.adjustment.upper = res_layout.posY + y
 601         # do not use this method in a loop because expensive.
 602         # self.redraw()
 603
 604     def create_res_layout(self, left_margin, resnum):
 605         return ResLayout(left_margin, resnum, self.pango_layout)
 606
 607     def set_layout_width(self, layout):
 608         width = self.drawingarea.allocation.width
 609         layout.set_width(width)
 610
 611     def redraw(self):
 612         self.drawingarea.queue_draw()
 613
 614     def wrap_relayout(self):
 615         # before relayout, find top layout on gdkwindow
 616         top_layout = self.get_layout_on_y(self.adjustment.value)
 617         delta = 0
 618
 619         if top_layout is not None:
 620             delta = top_layout.posY - self.adjustment.value
 621
 622         self.relayout()
 623         self.drawingarea_prev_width = self.drawingarea.allocation.width
 624
 625         # after relayout, set adjustment.value to top layout's posY
 626         if top_layout is not None:
 627             self.adjustment.value = top_layout.posY - delta
 628
 629     def relayout(self):
 630         width = self.drawingarea.allocation.width
 631         sum_height = 0
 632         for layout in self.res_layout_list:
 633             layout.set_width(width)
 634             layout.posY = sum_height
 635             x, y = layout.get_pixel_size()
 636             sum_height += y
 637
 638         self.adjustment.upper = sum_height
 639
 640     def change_vscrollbar_visible(self):
 641         if self.adjustment.upper <= self.adjustment.page_size:
 642             self.vscrollbar.hide()
 643         else:
 644             self.vscrollbar.show()
 645
 646     def _set_adjustment_value(self, value):
 647         value = min(self.adjustment.upper - self.adjustment.page_size, value)
 648         value = max(self.adjustment.lower, value)
 649         self.adjustment.value = value
 650
 651     def jump(self, value):
 652         self._set_adjustment_value(value)
 653
 654     def jump_to_layout(self, layout):
 655         self.jump(layout.posY)
 656
 657     def jump_to_the_end(self):
 658         value = self.adjustment.upper - self.adjustment.page_size
 659         self._set_adjustment_value(value)
 660
 661     def jump_to_res(self, resnum):
 662         for layout in self.res_layout_list:
 663             if layout.resnum == resnum:
 664                 self.jump_to_layout(layout)
 665                 return True
 666         return False
 667
 668
 669     def _get_selection_start_end(self):
 670         pressed_layout, pressed_element, pressed_index = self.button_pressed_pt
 671         moving_layout, moving_element, moving_index = self.button_moving_pt
 672
 673         if (pressed_layout is None or pressed_element is None or
 674             pressed_index is None or moving_layout is None or
 675             moving_element is None or moving_index is None):
 676             return (None, None, None), (None, None, None)
 677
 678         if pressed_layout == moving_layout:
 679             if pressed_element == moving_element:
 680                 if moving_index < pressed_index:
 681                     return self.button_moving_pt, self.button_pressed_pt
 682             else:
 683                 pressed_element_index = pressed_layout.element_list.index(
 684                     pressed_element)
 685                 moving_element_index = moving_layout.element_list.index(
 686                     moving_element)
 687                 if moving_element_index < pressed_element_index:
 688                     return self.button_moving_pt, self.button_pressed_pt
 689         elif moving_layout.posY < pressed_layout.posY:
 690             return self.button_moving_pt, self.button_pressed_pt
 691
 692         return self.button_pressed_pt, self.button_moving_pt
 693
 694     def draw_viewport(self, area):
 695         view_y = self.adjustment.value
 696         self.drawingarea.window.draw_rectangle(
 697             self.drawingarea.style.base_gc[0],
 698             True, area.x, area.y, area.width, area.height)
 699
 700         selection_start, selection_end = self._get_selection_start_end()
 701
 702         top_layout = self.get_layout_on_y(view_y)
 703         if top_layout is None:
 704             return
 705         #area_top = view_y + area.y
 706         area_bottom = view_y + area.y + area.height
 707
 708         iter = range(top_layout.list_index, len(self.res_layout_list))
 709         iter = itertools.imap(lambda index: self.res_layout_list[index], iter)
 710         iter = itertools.takewhile(lambda lay: lay.posY <= area_bottom, iter)
 711         for layout in iter:
 712             layout.draw(self.drawingarea, 0, layout.posY - int(view_y),
 713                 selection_start, selection_end)
 714
 715     def transform_coordinate_gdk_to_adj(self, y):
 716         return y + self.adjustment.value
 717
 718     def transform_coordinate_adj_to_layout(self, x, y, layout):
 719         return x, y - layout.posY
 720
 721     def transform_coordinate_gdk_to_layout(self, x, y, layout):
 722         return self.transform_coordinate_adj_to_layout(
 723             x, self.transform_coordinate_gdk_to_adj(y), layout)
 724
 725     def get_layout_on_y(self, y):
 726
 727         def binary_search(lst, start, end, func):
 728
 729             if end - start <= 0:
 730                 return None
 731
 732             m = (start + end) / 2
 733             ret = func(lst[m])
 734
 735             if ret == 0:
 736                 return m
 737             if ret > 0:
 738                 return binary_search(lst, start, m, func)
 739             return binary_search(lst, m+1, end, func)
 740
 741         def on_y(layout, _y):
 742             top = layout.posY
 743             width, height = layout.get_pixel_size()
 744             bottom = top + height
 745             if _y >= top and _y < bottom:
 746                 return 0
 747             if _y < top:
 748                 return 1
 749             return -1
 750
 751         ret = binary_search(
 752             self.res_layout_list, 0, len(self.res_layout_list),
 753             lambda x: on_y(x, y))
 754         if ret is not None:
 755             return self.res_layout_list[ret]
 756         return None
 757
 758     def ptrpos_to_layout(self, x, y):
 759         # transform coordinate, GdkWindow -> adjustment
 760         adj_y = self.transform_coordinate_gdk_to_adj(y)
 761         return self.get_layout_on_y(adj_y)
 762
 763     def ptrpos_to_uri(self,  x, y):
 764         # x, y is GdkWindow coordinate
 765
 766         layout = self.ptrpos_to_layout(x, y)
 767
 768         if layout is None:
 769             return None, None, None
 770
 771         # transform coordinate, GdkWindow -> res_layout_list
 772         lay_x, lay_y = self.transform_coordinate_gdk_to_layout(x, y, layout)
 773
 774         # xy -> element
 775         element = layout.get_element_from_xy(lay_x, lay_y)
 776         if isinstance(element, ElementLink):
 777             return element.href, layout, element
 778
 779         return None, layout, None
 780
 781     def get_selected_text(self):
 782         selection_start, selection_end = self._get_selection_start_end()
 783         s_l, s_e, s_i = selection_start
 784         e_l, e_e, e_i = selection_end
 785
 786         if (s_l is None or s_e is None or s_i is None or
 787             e_l is None or e_e is None or e_i is None):
 788             return ""
 789
 790         text = ""
 791         index = s_l.list_index
 792         end = e_l.list_index
 793
 794         while index <= end:
 795             layout = self.res_layout_list[index]
 796
 797             text += layout.get_text(selection_start, selection_end)
 798             if index != end:
 799                 text += "\n"
 800
 801             index += 1
 802
 803         return text
 804
 805     def _set_button_pressed_pt(self, pt):
 806         self.button_pressed_pt = (None, None, None)
 807         if pt == None:
 808             return
 809
 810         x, y = pt
 811         layout = self.ptrpos_to_layout(x, y)
 812         if layout is None:
 813             return
 814
 815         x, y = self.transform_coordinate_gdk_to_layout(x, y, layout)
 816         element = layout.get_element_from_xy(x, y)
 817         if element is None:
 818             element = layout.get_close_element_from_xy(x, y)
 819
 820         if element is None:
 821             return
 822
 823         index = element.xy_to_index(x, y)
 824         if index is None:
 825             return
 826
 827         self.button_pressed_pt = (layout, element, index)
 828
 829     def _set_button_moving_pt(self, pt):
 830         self.button_moving_pt = (None, None, None)
 831         if pt == None:
 832             return
 833
 834         x, y = pt
 835         layout = self.ptrpos_to_layout(x, y)
 836         if layout is None:
 837             return
 838
 839         x, y = self.transform_coordinate_gdk_to_layout(x, y, layout)
 840         element = layout.get_element_from_xy(x, y)
 841         if element is None:
 842             element = layout.get_close_element_from_xy(x, y)
 843
 844         if element is None:
 845             return
 846
 847         index = element.xy_to_index(x, y)
 848         if index is None:
 849             return
 850
 851         self.button_moving_pt = (layout, element, index)
 852
 853     def on_drawingarea_expose_event(self, widget, event, data=None):
 854         self.draw_viewport(event.area)
 855
 856     def on_drawingarea_configure_event(self, widget, event, data=None):
 857         if event.width != self.drawingarea_prev_width:
 858             self.wrap_relayout()
 859
 860         self.adjustment.page_size = self.drawingarea.allocation.height
 861         self.adjustment.step_increment = 20
 862         self.adjustment.page_increment = self.drawingarea.allocation.height
 863
 864         # re-set 'value' for prevent overflow
 865         self._set_adjustment_value(self.adjustment.value)
 866
 867     def on_adjustment_value_changed(self, widget, data=None):
 868         self.drawingarea.queue_draw()
 869
 870     def on_adjustment_changed(self, widget, data=None):
 871         self.change_vscrollbar_visible()
 872
 873     def on_drawingarea_scroll_event(self, widget, event, data=None):
 874         self.vscrollbar.emit("scroll-event", event)
 875
 876     def on_drawingrarea_motion_notify_event(self, widget, event, data=None):
 877         if event.state & gtk.gdk.BUTTON1_MASK != gtk.gdk.BUTTON1_MASK:
 878             self.button1_pressed = False
 879
 880         if self.button1_pressed and self.current_pressed_uri is None:
 881             old_lay, old_elem, old_idx = self.button_moving_pt
 882             self._set_button_moving_pt((event.x, event.y))
 883             new_lay, new_elem, new_idx = self.button_moving_pt
 884             if (old_lay != new_lay
 885                 or old_elem != new_elem
 886                 or old_idx != new_idx):
 887                 view_y = self.adjustment.value
 888                 o_y = old_lay.posY
 889                 n_y = new_lay.posY
 890                 o_width, o_height = old_lay.get_pixel_size()
 891                 n_width, n_height = new_lay.get_pixel_size()
 892
 893                 y = min(o_y, n_y)
 894                 height = max(o_y, n_y) - y
 895                 if o_y > n_y: height += o_height
 896                 else: height += n_height
 897
 898                 y -= view_y
 899
 900                 self.drawingarea.queue_draw_area(0, y, n_width, height+1)
 901                 #self.drawingarea.window.process_updates(False)
 902
 903         cursor = ThreadView.regular_cursor
 904
 905         uri, layout, element = self.ptrpos_to_uri(event.x, event.y)
 906         if layout is None:
 907             cursor = ThreadView.arrow_cursor
 908         else:
 909             if uri is not None and uri != "":
 910                 cursor = ThreadView.hand_cursor
 911                 self.emit("cursor-over-link-event", event, uri)
 912
 913         self.drawingarea.window.set_cursor(cursor)
 914
 915     def on_drawingarea_button_press_event(self, widget, event, data=None):
 916         if event.button == 1:
 917             self.current_pressed_uri = None
 918             self.button1_pressed = True
 919             uri, layout, element = self.ptrpos_to_uri(event.x, event.y)
 920             if uri is not None and layout is not None and element is not None:
 921                 self.current_pressed_uri = (uri, layout, element)
 922             else:
 923                 self._set_button_moving_pt((event.x, event.y))
 924                 self._set_button_pressed_pt((event.x, event.y))
 925                 self.drawingarea.queue_draw()
 926
 927         elif event.button == 3:
 928             time = event.time
 929             uri, layout, element = self.ptrpos_to_uri(event.x, event.y)
 930             if uri is not None and layout is not None and element is not None:
 931                 self.menu_openuri.show()
 932                 self.menu_copylinkaddress.show()
 933                 self.menu_separator_link.show()
 934                 self.menu_openuri.uri = uri
 935                 self.menu_copylinkaddress.uri = uri
 936             else:
 937                 self.menu_openuri.hide()
 938                 self.menu_copylinkaddress.hide()
 939                 self.menu_separator_link.hide()
 940                 self.menu_openuri.uri = None
 941                 self.menu_copylinkaddress.uri = None
 942
 943             text = self.get_selected_text()
 944             if text and len(text) > 0:
 945                 self.menu_copyselection.show()
 946                 self.menu_openasuri.show()
 947                 self.menu_separator_selection.show()
 948             else:
 949                 self.menu_copyselection.hide()
 950                 self.menu_openasuri.hide()
 951                 self.menu_separator_selection.hide()
 952
 953             self.popupmenu.popup(None, None, None, event.button, time)
 954             return True
 955
 956
 957     def on_drawingarea_button_release_event(self, widget, event, data=None):
 958         if event.button == 1:
 959             button1_pressed = self.button1_pressed
 960             self.button1_pressed = False
 961
 962             if button1_pressed and self.current_pressed_uri is not None:
 963                 uri, layout, element = self.ptrpos_to_uri(event.x, event.y)
 964                 p_uri, p_layout, p_element = self.current_pressed_uri
 965                 self.current_pressed_uri = None
 966                 if (uri == p_uri and layout == p_layout and
 967                     element == p_element):
 968                     self.emit("uri-clicked-event", uri)
 969
 970     def on_drawingarea_style_set(self, widget, previous_style, data=None):
 971         if previous_style is None:
 972             return False
 973
 974         new = widget.style.font_desc.hash()
 975         old = previous_style.font_desc.hash()
 976         if new != old:
 977             for layout in self.res_layout_list:
 978                 layout.recalc_char_widths()
 979             self.wrap_relayout()
 980
 981     def on_drawingarea_key_press_event(self, widget, event, data=None):
 982         if event.type is not gtk.gdk.KEY_PRESS:
 983             return
 984
 985         if event.keyval in (gtk.keysyms.Up, gtk.keysyms.Down,
 986                             gtk.keysyms.Page_Up, gtk.keysyms.Page_Down,
 987                             gtk.keysyms.Home):
 988             value = self.adjustment.value
 989             if event.keyval == gtk.keysyms.Up:
 990                 step_increment = self.adjustment.step_increment
 991                 value = value - step_increment
 992             elif event.keyval == gtk.keysyms.Down:
 993                 step_increment = self.adjustment.step_increment
 994                 value = value + step_increment
 995             elif event.keyval == gtk.keysyms.Page_Up:
 996                 step_increment = self.adjustment.page_increment
 997                 value = value - step_increment
 998             elif event.keyval == gtk.keysyms.Page_Down:
 999                 step_increment = self.adjustment.page_increment
1000                 value = value + step_increment
1001             elif event.keyval == gtk.keysyms.Home:
1002                 value = 0
1003             self.jump(value)
1004         elif event.keyval == gtk.keysyms.End:
1005             self.jump_to_the_end()