# cslist.py - embeddable changeset/patch list component
#
# Copyright 2009 Yuki KODAMA <endflow.net@gmail.com>
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2, incorporated herein by reference.

import os
import gtk
import gobject

from mercurial import hg, ui

from tortoisehg.util.i18n import _
from tortoisehg.util import hglib, paths

from tortoisehg.hgtk import csinfo, gtklib

CSL_DND_ITEM     = 1024
CSL_DND_URI_LIST = 1025

ASYNC_LIMIT = 60

class ChangesetList(gtk.Frame):

    __gsignals__ = {
        'list-updated': (gobject.SIGNAL_RUN_FIRST,
                         gobject.TYPE_NONE,
                         (object, # number of all items or None
                          object, # number of selections or None
                          object, # number of showings or None
                          bool)), # whether cslist is updating
        'files-dropped': (gobject.SIGNAL_RUN_FIRST,
                          gobject.TYPE_NONE,
                          (object, # list of dropped files
                           str)),  # raw string data
        'item-activated': (gobject.SIGNAL_RUN_FIRST,
                           gobject.TYPE_NONE,
                           (str,     # revision number or patch file path
                            object)) # reference of csinfo widget
    }

    def __init__(self):
        gtk.Frame.__init__(self)
        self.set_shadow_type(gtk.SHADOW_IN)

        # member variables
        self.curitems = None
        self.currepo = None
        self.showitems = None
        self.chkmap = {}
        self.limit = 20
        self.curfactory = None

        self.timeout_queue = []
        self.sel_enable = False
        self.dnd_enable = False
        self.act_enable = False

        # dnd variables
        self.itemmap = {}
        self.hlsep = None
        self.dnd_pb = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, True, 8, 1, 1)
        self.scroll_timer = None

        # base box
        basebox = gtk.VBox()
        self.add(basebox)

        ## status box
        self.statusbox = statusbox = gtk.HBox()
        basebox.pack_start(statusbox, False, False)
        basebox.pack_start(gtk.HSeparator(), False, False, 2)

        # copy form thgstrip.py
        def createlabel():
            label = gtk.Label()
            label.set_alignment(0, 0.5)
            label.set_size_request(-1, 24)
            label.size_request()
            return label

        ### status label
        self.statuslabel = createlabel()
        statusbox.pack_start(self.statuslabel, False, False, 2)

        ### show all button
        self.allbtn = gtk.Button(_('Show all')) # add later

        ### list option
        self.compactopt = gtk.CheckButton(_('Use compact view'))
        statusbox.pack_end(self.compactopt, False, False, 2)

        ## item list
        scroll = gtk.ScrolledWindow()
        basebox.add(scroll)
        self.scroll = scroll
        scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        scroll.set_size_request(400, 180)
        scroll.size_request()
        self.csbox = gtk.VBox()
        self.csevent = csevent = gtk.EventBox()
        csevent.add(self.csbox)
        csevent.add_events(gtk.gdk.BUTTON_PRESS_MASK |
                           gtk.gdk.BUTTON_RELEASE_MASK)
        scroll.add_with_viewport(csevent)
        scroll.child.set_shadow_type(gtk.SHADOW_NONE)
        self.csbox.set_border_width(4)

        # signal handlers
        self.allbtn.connect('clicked', lambda b: self.expand_items())
        self.compactopt.connect('toggled', lambda b: self.update( \
                self.curitems, self.currepo, queue=False, keep=True))

        # dnd setup
        self.dnd_targets = [('thg-dnd', gtk.TARGET_SAME_WIDGET, CSL_DND_ITEM)]
        targets = self.dnd_targets + [('text/uri-list', 0, CSL_DND_URI_LIST)]
        csevent.drag_dest_set(gtk.DEST_DEFAULT_MOTION | gtk.DEST_DEFAULT_DROP,
                              targets, gtk.gdk.ACTION_MOVE)
        csevent.connect('drag-begin', self.dnd_begin)
        csevent.connect('drag-end', self.dnd_end)
        csevent.connect('drag-motion', self.dnd_motion)
        csevent.connect('drag-leave', self.dnd_leave)
        csevent.connect('drag-data-received', self.dnd_received)
        csevent.connect('drag-data-get', self.dnd_get)
        csevent.connect('button-press-event', self.button_press)

        # csetinfo
        def data_func(widget, item, ctx):
            if item in ('item', 'item_l'):
                if not isinstance(ctx, csinfo.patchctx):
                    return True # dummy
                revid = widget.get_data('revid')
                if not revid:
                    return widget.target
                filename = os.path.basename(widget.target)
                return filename, revid
            raise csinfo.UnknownItem(item)
        def label_func(widget, item):
            if item in ('item', 'item_l'):
                if not isinstance(widget.ctx, csinfo.patchctx):
                    return _('Revision:')
                return _('Patch:')
            raise csinfo.UnknownItem(item)
        def markup_func(widget, item, value):
            if item in ('item', 'item_l'):
                if not isinstance(widget.ctx, csinfo.patchctx):
                    if item == 'item':
                        return widget.get_markup('rev')
                    return widget.get_markup('revnum')
                mono = dict(face='monospace', size='9000')
                if isinstance(value, basestring):
                    return gtklib.markup(value, **mono)
                filename = gtklib.markup(value[0])
                revid = gtklib.markup(value[1], **mono)
                if item == 'item':
                    return '%s (%s)' % (filename, revid)
                return filename
            raise csinfo.UnknownItem(item)
        self.custom = csinfo.custom(data=data_func, label=label_func,
                                    markup=markup_func)
        self.lstyle = csinfo.labelstyle(
                             contents=('%(item_l)s:', ' %(branch)s',
                                       ' %(tags)s', ' %(summary)s'))
        self.pstyle = csinfo.panelstyle(
                             contents=('item', 'summary', 'user','dateage',
                                       'rawbranch', 'tags', 'transplant',
                                       'p4', 'svn'))

        # prepare to show
        gtklib.idle_add_single_call(self.after_init)

    ### public functions ###

    def update(self, items=None, repo=None, limit=True, queue=False, **kargs):
        """
        Update the item list.

        Public arguments:
        items: List of revision numbers and/or patch file path.
               You can pass mixed list.  The order will be respected.
               If omitted, previous items will be used to show them.
               Default: None.
        repo: Repository used to get changeset information.
              If omitted, previous repo will be used to show them.
              Default: None.
        limit: If True, some of items will be shown.  Default: True.
        queue: If True, the update request will be queued to prevent
               frequent updatings.  In some cases, this option will help
               to improve UI response.  Default: False.

        Internal argument:
        keep: If True, it keeps previous selection states and 'limit' value
              after refreshing.  Note that if you use 'limit' and this options
              at the same time, 'limit' value is used against previous value.
              Default: False.

        return: True if the item list was updated successfully,
                False if it wasn't updated.
        """
        # check parameters
        if not items or not repo:
            self.clear()
            return False
        elif queue:
            def timeout(eid, items, repo):
                if self.timeout_queue and self.timeout_queue[-1] == eid[0]:
                    self.timeout_queue = []
                    self.update(items, repo, limit, False)
                return False # don't repeat
            eid = [None]
            eid[0] = gobject.timeout_add(650, timeout, eid, items, repo)
            self.timeout_queue.append(eid[0])
            return False

        # determine whether to keep previous 'limit' state
        if kargs.get('keep', False) and self.has_limit() is False:
            limit = False

        # initialize variables
        self.curitems = items
        self.currepo = repo
        self.itemmap = {}

        if self.sel_enable and not kargs.get('keep', False):
            self.chkmap = {}
            for item in items:
                self.chkmap[item] = True

        # determine items to show
        numtotal = len(items)
        if limit and self.limit < numtotal:
            toshow, lastitem = items[:self.limit-1], items[-1]
        else:
            toshow, lastitem = items, None
        numshow = len(toshow) + (lastitem and 1 or 0)
        self.showitems = toshow + (lastitem and [lastitem] or [])

        # prepare to update item list
        self.curfactory = csinfo.factory(repo, self.custom, withupdate=True)

        def add_sep():
            sep = self.create_sep()
            self.csbox.pack_start(sep, False, False)

        # clear item list
        self.csbox.foreach(lambda c: c.parent.remove(c))

        # update item list
        def proc():
            # add csinfo widgets
            for index, r in enumerate(toshow):
                self.add_csinfo(r)
            if lastitem:
                self.add_snip()
                self.add_csinfo(lastitem)
            add_sep()
            self.csbox.show_all()

            # show/hide separators
            self.update_seps()

            # update status
            self.update_status()

        # determine doing it now or later
        if numshow < ASYNC_LIMIT:
            proc()
        else:
            self.update_status(updating=True)
            gtklib.idle_add_single_call(proc)

        return True

    def clear(self):
        """ Clear the item list  """
        self.csbox.foreach(lambda c: c.parent.remove(c))
        self.curitems = None
        self.update_status()

    def get_items(self, sel=False):
        """
        Return a list of items or tuples contained 2 values:
        'item' (String) and 'selection state' (Boolean).
        If cslist lists no items, it returns an empty list.

        sel: If True, it returns a list of tuples.  Default: False.
        """
        items = self.curitems
        if items:
            if not sel:
                return items
            return [(item, self.chkmap[item]) for item in items]
        return []

    def get_list_limit(self):
        """ Return number of items to limit to display """
        return self.limit

    def set_list_limit(self, limit):
        """
        Set number of items to limit to display.

        limit: Integer, must be more than 3.  Default: 20.
        """
        if limit < 3:
            limit = 3
        self.limit = limit

    def get_dnd_enable(self):
        """ Return whether drag and drop feature is enabled """
        return self.dnd_enable

    def set_dnd_enable(self, enable):
        """
        Set whether drag and drop feature is enabled.

        enable: Boolean, if True, drag and drop feature will be enabled.
                Default: False.
        """
        self.dnd_enable = enable

    def get_checkbox_enable(self):
        """ Return whether the selection feature is enabled """
        return self.sel_enable

    def set_checkbox_enable(self, enable):
        """
        Set whether the selection feature is enabled.
        When it's enabled, checboxes will be placed at the left of
        csinfo widgets.

        enable: Boolean, if True, the selection feature will be enabled.
                Default: False.
        """
        self.sel_enable = enable

    def get_activatable_enable(self):
        """ Return whether items are activatable """
        return self.act_enable

    def set_activatable_enable(self, enable):
        """
        Set whether items are activatable.
        By enabling this, items in the list will be emitted 'item-activated'
        signal when the user double-clicked on the list.

        enable: Boolean, if True, items will be selectable.  Default: False.
        """
        self.act_enable = enable

    def get_compact_view(self):
        """ Return whether the compact view is enabled """
        return self.compactopt.get_active()

    def set_compact_view(self, compact):
        """
        Set whether the compact view is enabled.

        enable: Boolean, if True, the compact view will be enabled.
                Default: False.
        """
        self.compactopt.set_active(compact)

    def has_limit(self):
        """
        Return whether the item list shows all items.
        If the item list has no items, it will return None.
        """
        if self.curitems:
            num = len(self.curitems)
            return self.limit < num and len(self.showitems) != num
        return None

    ### internal functions ###

    def after_init(self):
        self.statusbox.pack_start(self.allbtn, False, False, 4)

    def update_status(self, updating=False):
        numshow = numsel = numtotal = all = None
        if self.curitems is None:
            button = False
            text = _('No items to display')
        else:
            # prepare data
            numshow, numtotal = len(self.showitems), len(self.curitems)
            data = dict(count=numshow, total=numtotal)
            if self.sel_enable:
                items = self.get_items(sel=True)
                numsel = len([item for item, sel in items if sel])
                data['sel'] = numsel
            all = data['count'] == data['total']
            button = not all
            # generate status text
            if updating:
                text = _('Updating...')
            elif self.sel_enable:
                if all:
                    text = _('Selecting %(sel)d of %(total)d, displaying '
                             'all items') % data
                else:
                    text = _('Selecting %(sel)d, displaying %(count)d of '
                             '%(total)d items') % data
            else:
                if all:
                    text = _('Displaying all items')
                else:
                    text = _('Displaying %(count)d of %(total)d items') % data
        self.statuslabel.set_text(text)
        self.allbtn.set_property('visible', button)
        self.emit('list-updated', numtotal, numsel, numshow, updating)

    def setup_dnd(self, restart=False):
        if not restart and self.scroll_timer is None:
            self.scroll_timer = gobject.timeout_add(25, self.scroll_timeout)

    def teardown_dnd(self, pause=False):
        first = self.get_sep(0)
        if first:
            first.set_visible(False)
        last = self.get_sep(-1)
        if last:
            last.set_visible(False)
        if self.hlsep:
            self.hlsep.drag_unhighlight()
            self.hlsep = None
        if not pause and self.scroll_timer:
            gobject.source_remove(self.scroll_timer)
            self.scroll_timer = None

    def get_item_pos(self, y, detail=False):
        pos = None
        items = self.curitems
        num = len(items)
        numshow = len(self.showitems)
        first = self.itemmap[items[0]]
        beforesnip = self.itemmap[items[numshow - 2]]
        snip = self.has_limit() and self.itemmap['snip'] or None
        last = self.itemmap[items[-1]]
        def calc_ratio(geom):
            return (y - geom['y']) / float(geom['height'])
        if y < first['y']:
            start, end = -1, 0
        elif last['bottom'] < y:
            start, end = num - 1, num
        elif snip and beforesnip['bottom'] < y and y < last['y']:
            ratio = calc_ratio(snip)
            if ratio < 0.5:
                start, end = numshow - 2, numshow - 1
            else:
                start, end = num - 2, num - 1
        else:
            # calc item showitems pos (binary search)
            def mid(start, end):
                return (start + end) / 2
            start, end = 0, numshow - 1
            pos = mid(start, end)
            while start < end:
                data = self.itemmap[self.showitems[pos]]
                if y < data['y']:
                    end = pos - 1
                elif data['bottom'] < y:
                    start = pos + 1
                else:
                    break
                pos = mid(start, end)
            # translate to curitems pos
            pos = self.trans_to_cur(pos)
            # calc detailed pos if need
            if detail:
                data = self.itemmap[items[pos]]
                ratio = calc_ratio(data)
                if ratio < 0.5:
                    start, end = pos - 1, pos
                else:
                    start, end = pos, pos + 1
        if detail:
            return pos, start, end
        return pos

    def get_sep(self, pos):
        """
        pos: Number, the position of separator you need.
             If -1 or list length, indicates the last separator.
        """
        # invalid position/condition
        if pos < -1 or not self.showitems:
            return None
        def get_last():
            child = self.csbox.get_children()[-1]
            return isinstance(child, FixedHSeparator) and child or None
        # last separator
        if pos == -1:
            return get_last()
        # limiting case
        if self.has_limit():
            # snip box separator
            if pos == self.limit - 1:
                return self.itemmap['snip']['sep']
            # list length (+ snip box)
            if pos == self.limit + 1:
                return get_last()
            # separators after snip box
            if self.limit - 1 < pos:
                return self.itemmap[self.showitems[pos-1]]['sep']
        # list length
        elif pos == len(self.showitems):
            return get_last()
        # others
        return self.itemmap[self.showitems[pos]]['sep']

    def get_sep_by_y(self, y):
        pos, start, end = self.get_item_pos(y, detail=True)
        if self.has_limit() and self.limit - 1 < end:
            end -= len(self.curitems) - self.limit - 1
        return self.get_sep(end)

    def update_seps(self):
        """ Update visibility of all separators """
        compact = self.get_compact_view()
        for item in self.showitems[1:]:
            sep = self.itemmap[item]['sep']
            sep.set_visible(not compact)
        if self.has_limit():
            self.itemmap['snip']['sep'].set_visible(False)
            self.itemmap[self.showitems[-1]]['sep'].set_visible(False)
        self.get_sep(0).set_visible(False)
        self.get_sep(-1).set_visible(False)

    def expand_items(self):
        if not self.has_limit():
            return

        # fix up snipped items
        rest = self.curitems[self.limit - 1:-1]

        def proc():
            # insert snipped csinfo
            for pos, item in enumerate(rest):
                self.insert_csinfo(item, self.limit + pos)
            # remove snip
            self.remove_snip()

            self.showitems = self.curitems[:]
            self.update_seps()
            self.update_status()

        # determine doing it now or later
        if len(rest) < ASYNC_LIMIT:
            proc()
        else:
            self.update_status(updating=True)
            gtklib.idle_add_single_call(proc)

    def reorder_item(self, pos, insert):
        """
        pos: Number, the position of item to move. This must be curitems
             index, not showitems index.
        insert: Number, the new position to insert target item.
                If list length, indicates the end of the list.
                This must be curitems index, not showitems index.
        """
        # reject unneeded reordering
        if pos == insert or pos + 1 == insert:
            return

        # reorder target csinfo
        if self.has_limit() and self.limit - 1 <= pos:
            item = self.curitems[pos]
            if insert < self.limit - 1:
                # move target csinfo to insert pos
                target = self.itemmap[item]['widget']
                self.csbox.reorder_child(target, insert)

                # remove csinfo to be snipped
                item = self.showitems[-2]
                self.remove_csinfo(item)
            else:
                # remove target csinfo
                self.remove_csinfo(item)

            # insert csinfo the end of the item list
            item = self.curitems[-2]
            self.insert_csinfo(item, -1)

        elif self.has_limit() and self.limit - 1 < insert:
            if self.trans_to_show(insert) < self.limit:
                # remove target csinfo
                rm_item = self.curitems[pos]
            else:
                # move target csinfo to the end of VBox
                item = self.curitems[pos]
                target = self.itemmap[item]['widget']
                numc = len(self.csbox.get_children())
                self.csbox.reorder_child(target, numc - 2)

                # remove last csinfo
                rm_item = self.showitems[-1]

            # remove it
            self.remove_csinfo(rm_item)

            # insert csinfo before snip box
            item = self.curitems[self.limit - 1]
            self.insert_csinfo(item, self.limit - 1)
        else:
            info = self.itemmap[self.showitems[pos]]['widget']
            if insert < pos:
                self.csbox.reorder_child(info, insert)
            else:
                self.csbox.reorder_child(info, insert - 1)

        # reorder curitems
        item = self.curitems[pos]
        items = self.curitems[:pos] + self.curitems[pos+1:]
        if insert < pos:
            items.insert(insert, item)
        else:
            items.insert(insert - 1, item)
        self.curitems = items

        # reorder showitems
        if self.has_limit():
            self.showitems = items[:self.limit-1] + [items[-1]]
        else:
            self.showitems = items

        # show/hide separators
        self.update_seps()

        # just emit 'list-updated' signal
        self.update_status()

    def trans_to_show(self, index):
        """ Translate from curitems index to showitems index """
        numrest = len(self.curitems) - self.limit
        if self.has_limit() and numrest <= index:
            return index - numrest
        return index

    def trans_to_cur(self, index):
        """ Translate from showitems index to curitems index """
        if self.has_limit() and self.limit - 1 <= index:
            return index + len(self.curitems) - self.limit
        return index

    def create_sep(self):
        return FixedHSeparator()

    def add_csinfo(self, item):
        self.insert_csinfo(item, -1)

    def insert_csinfo(self, item, pos):
        """
        item: String, revision number or patch file path to display.
        pos: Number, an index of insertion point.  If -1, indicates
        the end of the item list.
        """
        # create csinfo
        wrapbox = gtk.VBox()
        sep = self.create_sep()
        wrapbox.pack_start(sep, False, False)
        style = self.get_compact_view() and self.lstyle or self.pstyle
        if self.dnd_enable:
            style['selectable'] = False
        info = self.curfactory(item, style)
        if self.sel_enable:
            check = gtk.CheckButton()
            check.set_active(self.chkmap[item])
            check.connect('toggled', self.check_toggled, item)
            align = gtk.Alignment(0.5, 0)
            align.add(check)
            hbox = gtk.HBox()
            hbox.pack_start(align, False, False)
            hbox.pack_start(info, False, False)
            info = hbox
        wrapbox.pack_start(info, False, False)
        wrapbox.show_all()
        self.csbox.pack_start(wrapbox, False, False)
        self.itemmap[item] = {'widget': wrapbox,
                              'info': info,
                              'sep': sep}

        # reorder it
        children = self.csbox.get_children()
        if 1 < len(children) and isinstance(children[-2], FixedHSeparator):
            if pos == -1:
                numc = len(children)
                pos = numc - 2
            elif self.has_limit():
                pos = pos - 1
            self.csbox.reorder_child(wrapbox, pos)

    def remove_csinfo(self, item):
        info = self.itemmap[item]['widget']
        self.csbox.remove(info)
        del self.itemmap[item]

    def add_snip(self):
        wrapbox = gtk.VBox()
        sep = self.create_sep()
        wrapbox.pack_start(sep, False, False)
        snipbox = gtk.HBox()
        wrapbox.pack_start(snipbox, False, False)
        spacer = gtk.Label()
        snipbox.pack_start(spacer, False, False)
        spacer.set_width_chars(24)
        sniplbl = gtk.Label()
        snipbox.pack_start(sniplbl, False, False)
        sniplbl.set_markup('<span size="large" weight="heavy"'
                           ' font_family="monospace">...</span>')
        sniplbl.set_angle(90)
        snipbox.pack_start(gtk.Label())
        self.csbox.pack_start(wrapbox, False, False, 2)
        self.itemmap['snip'] = {'widget': wrapbox,
                                'snip': snipbox,
                                'sep': sep}

    def remove_snip(self):
        if not self.has_limit():
            return
        snip = self.itemmap['snip']['widget']
        self.csbox.remove(snip)
        del self.itemmap['snip']

    ### signal handlers ###

    def check_toggled(self, button, item):
        self.chkmap[item] = button.get_active()
        self.update_status()

    def allbtn_clicked(self, button):
        self.update(self.curitems, self.currepo, limit=False,
                    queue=False, keep=True)

    ### dnd signal handlers ###

    def dnd_begin(self, widget, context):
        self.setup_dnd()
        context.set_icon_pixbuf(self.dnd_pb, 0, 0)

    def dnd_end(self, widget, context):
        self.teardown_dnd()

    def dnd_motion(self, widget, context, x, y, event_time):
        if hasattr(self, 'item_drag') and self.item_drag is not None:
            num = len(self.curitems)
            if not self.hlsep:
                self.setup_dnd(restart=True)
            # highlight separator
            sep = self.get_sep_by_y(y)
            first = self.get_sep(0)
            first.set_visible(first == sep)
            last = self.get_sep(-1)
            last.set_visible(last == sep)
            if self.hlsep != sep:
                if self.hlsep:
                    self.hlsep.drag_unhighlight()
                sep.drag_highlight()
                self.hlsep = sep

    def dnd_leave(self, widget, context, event_time):
        self.teardown_dnd(pause=True)

    def dnd_received(self, widget, context, x, y, sel, target_type, *args):
        if target_type == CSL_DND_ITEM:
            items = self.curitems
            pos, start, end = self.get_item_pos(y, detail=True)
            self.reorder_item(self.item_drag, end)
        elif target_type == CSL_DND_URI_LIST:
            paths = gtklib.normalize_dnd_paths(sel.data)
            if paths:
                self.emit('files-dropped', paths, sel.data)

    def dnd_get(self, widget, context, sel, target_type, event_time):
        pos = self.item_drag
        if target_type == CSL_DND_ITEM and pos is not None:
            sel.set(sel.target, 8, str(self.curitems[pos]))

    def button_press(self, widget, event):
        if not self.curitems:
            return
        # gather geometry data
        items = self.showitems
        if self.has_limit():
            items.append('snip')
        for item in items:
            data = self.itemmap[item]
            alloc = data['widget'].allocation
            data.update(y=alloc.y, height=alloc.height)
            data['bottom'] = alloc.y + alloc.height
        # get pressed csinfo widget based on pointer position
        pos = self.get_item_pos(event.y)
        if pos is None:
            return
        # emit activated signal
        if self.act_enable and event.type == gtk.gdk._2BUTTON_PRESS:
            item = self.curitems[pos]
            self.emit('item-activated', item, self.itemmap[item]['widget'])
        # dnd setup
        if self.dnd_enable and event.type == gtk.gdk.BUTTON_PRESS \
                           and 1 < len(self.curitems):
            # prepare for dnd auto-scrolling
            W = 20
            alloc = self.scroll.child.allocation
            self.areas = {}
            def add(name, arg):
                region = gtk.gdk.region_rectangle(arg)
                self.areas[name] = (region, gtk.gdk.Rectangle(*arg))
            add('top', (0, 0, alloc.width, W))
            add('right', (alloc.width - W, 0, W, alloc.height))
            add('bottom', (0, alloc.height - W, alloc.width, W))
            add('left', (0, 0, W, alloc.height))
            add('center', (W, W, alloc.width - 2 * W, alloc.height - 2 * W))
            # start dnd
            self.item_drag = pos
            self.csevent.drag_begin(self.dnd_targets,
                                    gtk.gdk.ACTION_MOVE, 1, event)

    def scroll_timeout(self):
        x, y = self.scroll.get_pointer()
        if not self.areas['center'][0].point_in(x, y):
            def hscroll(left=False, fast=False):
                amount = 2
                if left: amount *= -1
                if fast: amount *= 3
                hadj = self.scroll.get_hadjustment()
                hadj.set_value(hadj.get_value() + amount)
            def vscroll(up=False, fast=False):
                amount = 2
                if up: amount *= -1
                if fast: amount *= 3
                vadj = self.scroll.get_vadjustment()
                vadj.set_value(vadj.get_value() + amount)
            top, topr = self.areas['top']
            bottom, bottomr = self.areas['bottom']
            if y < topr.y:
                vscroll(up=True, fast=True)
            elif top.point_in(x, y):
                vscroll(up=True)
            elif (bottomr.y + bottomr.height) < y:
                vscroll(fast=True)
            elif bottom.point_in(x, y):
                vscroll()
            left, leftr = self.areas['left']
            right, rightr = self.areas['right']
            if x < leftr.x:
                hscroll(left=True, fast=True)
            elif left.point_in(x, y):
                hscroll(left=True)
            elif (rightr.x + rightr.width) < x:
                hscroll(fast=True)
            elif right.point_in(x, y):
                hscroll()
        return True # repeat

class FixedHSeparator(gtk.VBox):

    def __init__(self, visible=True):
        gtk.VBox.__init__(self)
        self.set_size_request(-1, 2)

        self.visible = visible

        self.sep = gtk.HSeparator()
        self.pack_start(self.sep, False, False)
        self.sep.set_no_show_all(not visible)

    def set_visible(self, visible):
        if self.visible != visible:
            self.visible = visible
            self.sep.set_no_show_all(False)
            self.sep.set_property('visible', visible)
            self.sep.set_no_show_all(not visible)