• Home
  • Categories
  • WIKI
  • LANGUAGE: en
    • 本人用python为 treeview写了一种数据结构
    社区开发 2778 views · 6 replies ·
    Tofloor
    poster avatar
    vala2012
    deepin
    2013-04-14 00:20
    Author
    2. #!coding:utf-8
    3. import gtk
    5. class TreeViewBase(gtk.Button):
    6.     def __init__(self):
    7.         self.nodes = Nodes()
    8.         self.nodes.connect("update-data", self.__nodes_update_data_event)
    9.       
    10.     def __nodes_update_data_event(self, nodes):
    11.         print "__nodes_update_data_event:", nodes.text
    13. class Nodes(list):
    14.     def __init__(self):
    15.         list.__init__(self)
    16.         self.this = None
    17.         self.__function_dict = {}
    19.     def add(self, text):
    20.         node = Node()
    21.         node.text = text
    22.         node.parent = self
    23.         if self.this:
    24.             node.leave  = self.this.leave + 1
    25.         node.connect("update-data", self.__node_update_data_event)
    26.         self.append(node)
    27.         self.emit("update-data", node)
    28.         return node
    30.     def __node_update_data_event(self, node):
    31.         self.emit("update-data", node)
    33.     def connect(self, event_name, function_point):
    34.         self.__function_dict[event_name] = function_point
    36.     def emit(self, event_name, *arg):
    37.         if self.__function_dict.has_key(event_name):
    38.             self.__function_dict[event_name](*arg)
    40. class Node(object):
    41.     def __init__(self):
    42.         self.__function_dict = {}
    43.         self.text  = ""
    44.         self.__pixbuf      = None
    45.         self.children = []
    46.         #
    47.         self.nodes = Nodes()
    48.         self.nodes.this = self
    49.         self.nodes.connect("update-data", self.__nodes_update_data_event)
    50.         #
    51.         self.parent = None # 获取当前树节点的夫节点.
    52.         self.leave  = 0    # 树的深度,不懂的看数据结构.
    53.         self.__last_node  = []   # 获取最后一个子树节点.
    54.         self.__first_node = []   # 获取树节点集合中的第一个子树节点.
    55.         self.__next_node  = []   # 获取下一个同级节点.
    56.         self.__prev_node  = []   # 获取上一个同级节点.
    57.         self.__index      = None # 获取树节点在树节点集合中的位置.
    58.         ####################
    59.         self.is_expanded = True # 是否展开状态.
    60.         self.is_selected = False # 是否选中状态.
    61.         self.is_editing  = False # 是否可编辑状态.
    62.         ####################
    63.         self.node_font   = None  # 字体.
    64.         self.next_visible_node = None # 获取下一个可见树节点.
    65.         self.is_visible  = True # 是否可见.
    67.     def __nodes_update_data_event(self, nodes):
    68.         self.emit("update-data", nodes)
    70.     def connect(self, event_name, function_point):
    71.         self.__function_dict[event_name] = function_point
    73.     def emit(self, event_name, *arg):
    74.         if self.__function_dict.has_key(event_name):
    75.             self.__function_dict[event_name](*arg)
    77.     def add_widget(self, child_widget):
    78.         self.children.append(child_widget)
    79.         self.emit()
    81.     @property
    82.     def last_node(self):
    83.     # 获取最后一个子树节点.
    84.         return self.__last_node
    86.     @last_node.getter
    87.     def last_node(self):
    88.         if self.nodes == []:
    89.             return None
    90.         else:
    91.             return self.nodes[len(self.nodes)-1]
    93.     @property
    94.     def first_node(self):
    95.     # 获取树节点集合中的第一个子树节点.
    96.         return self.__first_node
    98.     @first_node.getter
    99.     def first_node(self):
    100.         if self.nodes == []:
    101.             return None
    102.         else:
    103.             return self.nodes[0]
    105.     @property
    106.     def prev_node(self):
    107.         return self.__prev_node
    108.    
    109.     @prev_node.getter
    110.     def prev_node(self):
    111.         # 获取上一个同级节点.
    112.         if self.parent:
    113.             index = self.parent.index(self)
    114.             if index:
    115.                 node = self.parent[index - 1]
    116.                 self.__prev_node = node
    117.                 return self.__prev_node
    118.         return None
    120.     @property
    121.     def next_node(self):
    122.         # 获取下一个同级节点.
    123.         return self.__next_node
    125.     @next_node.getter
    126.     def next_node(self):
    127.         if self.parent:
    128.             index = self.parent.index(self)
    129.             if index < len(self.parent) - 1:
    130.                 node = self.parent[index + 1]
    131.                 self.__next_node = node
    132.                 return self.__next_node
    133.         return None
    135.     @next_node.deleter
    136.     def next_node(self):
    137.         del self.__next_node
    139.     @property
    140.     def index(self):
    141.         return self.__index
    143.     @index.getter
    144.     def index(self):
    145.         if self.parent:
    146.             _index = self.parent.index(self)
    147.             return _index
    148.         return None
    150.     @property
    151.     def pixbuf(self):
    152.         return self.__pixbuf
    154.     @pixbuf.getter
    155.     def pixbuf(self):
    156.         return self.__pixbuf
    158.     @pixbuf.setter
    159.     def pixbuf(self, pixbuf):
    160.         self.__pixbuf = pixbuf
    161.         self.emit()
    163.     @pixbuf.deleter
    164.     def pixbuf(self, pixbuf):
    165.         del self.__pixbuf
    168. if __name__ == "__main__":
    169.     win = gtk.Window(gtk.WINDOW_TOPLEVEL)
    170.     win.set_size_request(300, 300)
    171.     treeview_base = TreeViewBase()
    172.     treeview_base.set_size_request(1500, 15000)
    173.     scroll_win = gtk.ScrolledWindow()
    174.     #
    175.     node1 = treeview_base.nodes.add("root1")
    176.     node2 = treeview_base.nodes.add("root2")
    177.     node3 = treeview_base.nodes.add("root3")
    178.     node4 = treeview_base.nodes.add("root4")
    179.     '''
    180.     for i in range(1, 30000):
    181.         treeview_base.nodes.add("root" + str(i))
    182.     '''
    183.     node1_1 = node1.nodes.add("roo1-1")
    184.     node1_2 = node1.nodes.add("roo1-2")
    185.     node1_3 = node1.nodes.add("roo1-3")
    186.     node1_1_1 = node1_1.nodes.add("root1-1-1")
    187.     node1_4 = node1.nodes.add("roo1-4")
    188.     node1_5 = node1.nodes.add("roo1-5")
    189.     print node1.nodes[1].next_node.text
    190.     print node1.nodes[1].prev_node.text
    191.     #
    192.     #
    193.     scroll_win.add_with_viewport(treeview_base)
    194.     win.add(scroll_win)
    195.     win.show_all()
    196.     gtk.main()
    Copy the Code

    连接信号后,只要数据层更新,就能通知上层...
    在界面层的代码中加入这个.
    nodes = Nodes()
    nodes.connect("update-data", ...........), 这样的方法类似于 C语言的 函数指针

    nodes[0].nodes[3].is_expand = True ; 展开
    nodes[0].nodes[3].is_expand = False ; 关闭展开.
    nodes[0].nodes[3]. prev_node / next_node; 获取同级的兄弟节点(左右).
    加上可以获取父亲节点，通过父亲节点去获取他的兄弟节点， 这样就可以将 leavel 为0的全部获取出来.
    或者leave 为 3 的全部获取出来.

    选区_012.png
    选区_013.png
    选区_014.png
    我重载函数以后,我自绘....是不是很有味道.....  但数据更新和改变,删除的时候,如果不是重绘的区域,是不会进行重绘的...
    哪怕后面删除了1万个数据,绘制层上的可视区域内没有这个数据在上面,是不进行重绘的. 重绘代表的是可视区域的,不是全部高度和宽度.
    后续加入 改变一个数据的时候,只对这个可视区域的 这一个数据的区域进行重绘.
    选区_015.png
    完全高仿C#哦... ...

    源码...
    5. from utils import get_match_parent
    6. #from utils import propagate_expose
    7. from utils import get_text_size
    8. from draw  import draw_text, draw_pixbuf
    9. from color import alpha_color_hex_to_cairo, color_hex_to_cairo
    10. import gtk
    11. from gtk import gdk
    12. import gobject
    13. import random
    16. def type_check(type_name, type_str):
    17.     return type(type_name).__name__ == type_str
    19. class TreeViewChild(object):
    20.     widget = None
    21.     x = 0
    22.     y = 0
    23.     w = 80
    24.     h = 40
    26. class TreeViewBase(gtk.Container):
    27.     def __init__(self):
    28.         gtk.Container.__init__(self)
    29.         self.__init_values()
    31.     def __init_values(self):
    32.         self.add_events(gtk.gdk.ALL_EVENTS_MASK)
    33.         #
    34.         self.header_height = 35
    35.         self.node_height   = 35
    36.         self.leave_width   = 20
    37.         #
    38.         self.children = []
    39.         #
    40.         self.paint_nodes_event = self.__paint_nodes_event
    41.         self.paint_nodes_background = self.__paint_nodes_background
    42.         #
    43.         self.__function_dict = {}
    44.         self.__nodes_list = []
    45.         self.nodes = Nodes()
    46.         self.nodes.connect("update-data", self.__nodes_update_data_event)
    47.         self.nodes.connect("added-data",  self.__nodes_added_data_event)
    48.         self.nodes.connect("remove-data", self.__nodes_remove_data_event)
    49.         self.nodes.connect("is-expanded", self.__nodes_is_expanded_event)
    50.         self.__init_values_columns()
    52.     def __nodes_update_data_event(self, node):
    53.         # 当有数据更新时,进行重绘.
    54.         # 判断是否在重绘的区域内,如果不是,只设置数据.
    55.         if self.tree_view_find_node_in_draw_area(node):
    56.             self.tree_view_queue_draw_area()
    58.     def __nodes_added_data_event(self, node):
    59.         # 添加数据更新树型结构的映射列表.
    60.         if node.parent == self.nodes:
    61.             self.__nodes_list.append(node)
    62.             self.__tree_view_set_add_size()
    63.       
    64.     def __nodes_is_expanded_event(self, node):
    65.         #print "__nodes_is_expanded_event", node.text
    66.         if node.is_expanded:
    67.             if node.nodes: # 判断是否有子节点.
    68.                 if node.leave: # 判断是不是根节点.
    69.                     if not node.parent.this.is_expanded: # 判断父亲节点是否已经展开了.
    70.                         node.parent.this.is_expanded = True
    71.                         for child_node in node.nodes:
    72.                             self.__nodes_add_data(child_node)
    73.                     else:
    74.                         for child_node in node.nodes:
    75.                             self.__nodes_add_data(child_node)
    76.                 else:
    77.                     for child_node in node.nodes:
    78.                         self.__nodes_add_data(child_node)
    79.         elif not node.is_expanded:
    80.             for flase_child_node in node.nodes:
    81.                 flase_child_node.is_expanded = False
    82.                 self.__nodes_remove_data(flase_child_node)
    84.     def __nodes_add_data(self, node):
    85.         parent = node.parent
    86.         node_to_parent_index = parent.index(node)
    87.         parent_to_list_index = self.__nodes_list.index(parent.this)
    88.         index = parent_to_list_index + node_to_parent_index + 1
    89.         self.__nodes_list.insert(index, node)
    90.         self.__tree_view_set_add_size()
    92.     def __nodes_remove_data(self, node):
    93.         index = self.__nodes_list.index(node)
    94.         self.__nodes_list.pop(index)
    95.         self.__tree_view_set_remove_size()
    97.     def __tree_view_set_add_size(self):
    98.         size = self.get_size_request()
    99.         self.set_size_request(size[0], size[1] + self.node_height)
    101.     def __tree_view_set_remove_size(self):
    102.         size = self.get_size_request()
    103.         self.set_size_request(size[0], size[1] - self.node_height)
    105.     def __nodes_remove_data_event(self, node):
    106.         # 当有数据删除时,更新映射列表.
    107.         print "remove............", node.text
    108.         if node in self.__nodes_list:
    109.             self.__nodes_list.remove(node)
    110.         # 判断删除的数据是否在重绘区域,如果不是,不进行重绘.
    111.         if self.tree_view_find_node_in_draw_area(node):
    112.             self.tree_view_queue_draw_area()
    114.     def __init_values_columns(self):
    115.         self.columns = []
    117.     def connect_event(self, event_name, function_potion):
    118.         self.__function_dict[event_name] = function_point
    120.     def emit(self, event_name, *arg):
    121.         if self.__function_dict.has_key(event_name):
    122.             self.__function_dict[event_name](*arg)
    123.         
    124.     def do_map(self):
    125.         print "do..map.."
    126.         gtk.Container.do_map(self)
    127.         self.set_flags(gtk.MAPPED)
    128.         #
    129.         self.window.show()
    131.     def do_umap(self):
    132.         print "do_map:"
    133.         gtk.Container.do_umap(self)
    134.         self.window.hide()
    136.     def do_realize(self):
    137.         print "do_realize..."
    138.         self.set_realized(True)
    139.         #
    140.         self.__init_window()
    141.         #
    142.         self.__init_children()
    143.         #
    144.         self.scroll_win = get_match_parent(self, ["ScrolledWindow"])
    145.         self.hadjustment = self.scroll_win.get_hadjustment()
    146.         self.vadjustment = self.scroll_win.get_vadjustment()
    147.         self.hadjustment.connect("value-changed", self.__list_view_adjustments_changed)
    148.         self.vadjustment.connect("value-changed", self.__list_view_adjustments_changed)
    149.         self.queue_resize()
    151.     def __list_view_adjustments_changed(self, adjustments):
    152.         self.tree_view_queue_draw_area()
    154.     def __init_window(self):
    155.         self.window = gdk.Window(
    156.             self.get_parent_window(),
    157.             window_type=gdk.WINDOW_CHILD,
    158.             x=self.allocation.x,
    159.             y=self.allocation.y,
    160.             width=self.allocation.width,
    161.             height=self.allocation.height,
    162.             colormap=self.get_colormap(),
    163.             wclass=gdk.INPUT_OUTPUT,
    164.             visual=self.get_visual(),
    165.             event_mask=(self.get_events()
    166.             | gtk.gdk.VISIBILITY_NOTIFY
    167.             | gdk.EXPOSURE_MASK
    168.             | gdk.SCROLL_MASK
    169.             | gdk.POINTER_MOTION_MASK
    170.             | gdk.ENTER_NOTIFY_MASK
    171.             | gdk.LEAVE_NOTIFY_MASK
    172.             | gdk.BUTTON_PRESS_MASK
    173.             | gdk.BUTTON_RELEASE_MASK
    174.             | gdk.KEY_PRESS_MASK
    175.             | gdk.KEY_RELEASE_MASK
    176.             ))
    177.         self.window.set_user_data(self)
    178.         self.style.set_background(self.window, gtk.STATE_NORMAL)
    181.     def __init_children(self):
    182.         for child in self.children:
    183.             print "child:", child.widget.set_parent_window(self.window)
    185.     def do_unrealize(self):
    186.         #
    187.         pass
    189.     def do_expose_event(self, e):
    190.         gtk.Container.do_expose_event(self, e)
    191.         if e.window == self.window:
    192.             cr = self.window.cairo_create()
    193.             start_index  = max(int(self.scroll_win.get_vadjustment().get_value() / self.node_height), 0)
    194.             end_index    = (start_index + (self.scroll_win.allocation.height) / self.node_height) + 1
    195.             y_padding = 0 + start_index * self.node_height
    196.             # draw background.
    197.             x = 0
    198.             y = 0 + start_index * self.node_height
    199.             w = self.scroll_win.allocation.width
    200.             h = self.scroll_win.allocation.height + self.node_height * 2
    201.             self.paint_nodes_background(cr, x, y, w, h)
    202.             # draw node.
    203.             for node in self.__nodes_list[start_index:end_index]:
    204.                 node_event = NodesEvent()
    205.                 node_event.cr = cr
    206.                 node_event.node = node
    207.                 node_event.x = 0
    208.                 node_event.y = y_padding
    209.                 node_event.w = self.scroll_win.allocation.width
    210.                 node_event.h = self.node_height #self.scroll_win.allocation.height
    211.                 '''
    212.                 node_event.draw_text = draw_text # 写成 set/get , 忽略 cr参数.
    213.                 node_event.draw_pixbuf = draw_pixbuf # 写成 set/get , 忽略 cr参数.
    214.                 '''
    215.                 self.paint_nodes_event(node_event)
    216.                 y_padding += self.node_height
    217.         #
    218.         return False
    220.     def __paint_nodes_background(self, cr, x, y, w, h):
    221.         cr.set_source_rgba(0, 0, 0, 0.85)
    222.         cr.rectangle(x, y, w, h)
    223.         cr.fill()
    225.     def __paint_nodes_event(self, node_event):
    226.         if node_event.node.leave == 0: # 根节点.
    227.             x = node_event.x + 10
    228.             if node_event.node.is_expanded:
    229.                 draw_text(node_event.cr,
    230.                           "-",
    231.                           node_event.x,
    232.                           node_event.y + get_text_size("+")[1]/2)
    233.             else:
    234.                 draw_text(node_event.cr,
    235.                           "+",
    236.                           node_event.x,
    237.                           node_event.y + get_text_size("+")[1]/2)
    238.         else:
    239.             x_padding = node_event.node.leave * self.leave_width
    240.             x = node_event.x + 10 + x_padding
    241.             if node_event.node.is_expanded:
    242.                 draw_text(node_event.cr,
    243.                           "*",
    244.                           node_event.x + x_padding,
    245.                           node_event.y + get_text_size("*")[1]/2)
    246.             else:
    247.                 if node_event.node.leave < 2:
    248.                     draw_text(node_event.cr,
    249.                               ">",
    250.                               node_event.x + x_padding,
    251.                               node_event.y + get_text_size(">")[1]/2)
    252.         draw_text(node_event.cr,
    253.                   node_event.node.text,
    254.                   x,
    255.                   node_event.y + get_text_size(node_event.node.text)[1]/2)
    257.     def tree_view_queue_draw_area(self):
    258.         self.scroll_win = get_match_parent(self, ["ScrolledWindow"])
    259.         if self.scroll_win:
    260.             start_index  = max(int(self.scroll_win.get_vadjustment().get_value() / self.node_height), 0)
    261.             end_index    = (start_index + (self.scroll_win.allocation.height) / self.node_height) + 1
    262.             w = self.scroll_win.allocation.width
    263.             h = self.scroll_win.allocation.height
    264.         else:
    265.             start_index = 0
    266.             end_index = self.allocation.height / self.allocation.height
    267.             w = self.allocation.width
    268.             h = self.allocation.height
    269.         x = 0
    270.         y = 0 + start_index * self.node_height
    271.         self.queue_draw_area(x, y, w, h)
    273.     def tree_view_find_node_in_draw_area(self, node):
    274.         if node in self.__nodes_list:
    275.             index = self.__nodes_list.index(node)
    276.             #
    277.             self.scroll_win = get_match_parent(self, "ScrolledWindow")
    278.             if self.scroll_win:
    279.                 start_index  = max(int(self.scroll_win.get_vadjustment().get_value() / self.node_height), 0)
    280.                 end_index    = (start_index + (self.scroll_win.allocation.height) / self.node_height) + 1
    281.             else:
    282.                 start_index = 0
    283.                 end_index = 0
    284.             if start_index <= index <= end_index:
    285.                 return True
    286.         return False
    288.     def do_motion_notify_event(self, e):
    289.         #print "do--mo--no--ev", e.x
    290.         if e.window == self.window:
    291.             index = int(e.y) / self.node_height
    292.             self.tree_view_queue_draw_area()
    293.         return False
    295.     def do_button_press_event(self, e):
    296.         #node.is_expanded = False #not node.is_expanded
    297.         #node.is_expanded = True
    298.         node = self.__nodes_list[int(e.y/self.node_height)]
    299.         node.is_expanded = not node.is_expanded
    300.         self.tree_view_queue_draw_area()
    301.         return False
    304.     def do_button_release_event(self, e):
    305.         #print "do_button_release_event..."
    306.         return False
    308.     def do_enter_notify_event(self, e):
    309.         #print "do_enter_notify_event..."
    310.         return False
    312.     def do_leave_notify_event(self, e):
    313.         #print "do_leave_notify_event..."
    314.         return False
    316.     def do_key_press_event(self, e):
    317.         print "do_key_press_event..."
    319.     def do_key_release_event(self, e):
    320.         print "do_key_release_event..."
    322.     def do_size_request(self, req):
    323.         '''
    324.         for child in self.children:
    325.             child.widget.size_request()
    326.         '''
    328.     def do_size_allocate(self, allocation):
    329.         print "do_size_allocate..."
    330.         gtk.Container.do_size_allocate(self, allocation)
    331.         '''
    332.         for child in self.children:
    333.             allocation = gdk.Rectangle()
    334.             allocation.x  = child.x
    335.             allocation.y  = child.y
    336.             allocation.width = child.w
    337.             allocation.height = child.h
    338.             child.widget.size_allocate(allocation)
    339.         '''
    340.         #
    341.         if self.get_realized():
    342.             self.window.move_resize(
    343.                     self.allocation.x,
    344.                     self.allocation.y,
    345.                     self.allocation.width,
    346.                     self.allocation.height)
    348.     def do_show(self):
    349.         gtk.Container.do_show(self)
    350.         #self.edit_entry.set_visible(False)
    352.     def do_destroy(self):
    353.         print "do_destroy..."
    355.     def do_forall(self, include_internals, callback, data):
    356.         '''
    357.         for child in self.children:
    358.             callback(child.widget, data)
    359.         '''
    360.         pass
    362.     def add_widget(self, child, x=0, y=0, w=0, h=0):
    363.         if self.window:
    364.             child.set_parent_window(self.window)
    365.         else:
    366.             child.set_parent(self)
    367.         tree_view_child = TreeViewChild()
    368.         tree_view_child.widget = child
    369.         tree_view_child.x = x
    370.         tree_view_child.y = y
    371.         tree_view_child.w = max(w, 80)
    372.         tree_view_child.h = max(h, self.node_height)
    373.         self.children.append(tree_view_child)
    375.     ############################################################
    376.     def delete(self, node): # 删除数据.
    377.         node.parent.delete(node)
    379.     def expanded_all(self): # 展开所有节点.
    380.         pass
    383. gobject.type_register(TreeViewBase)
    386. class NodesEvent(object):
    387.     def __init__(self):
    388.         self.cr = None
    389.         self.x  = 0
    390.         self.y  = 0
    391.         self.w  = 0
    392.         self.h  = 0
    393.         self.node = None
    394.         '''
    395.         self.draw_pixbuf
    396.         self.draw_text
    397.         '''
    400. class Nodes(list):
    401.     def __init__(self):
    402.         list.__init__(self)
    403.         self.this = None
    404.         self.__function_dict = {}
    406.     def add(self, text):
    407.         node = Node()
    408.         node.text = text
    409.         node.parent = self
    410.         if self.this:
    411.             node.leave  = self.this.leave + 1
    412.         node.connect("update-data", self.__node_update_data_event)
    413.         node.connect("added-data",  self.__node_added_data_event)
    414.         node.connect("remove-data", self.__node_remove_data_event)
    415.         node.connect("is-expanded", self.__Node_is_expanded_event)
    416.         self.append(node)
    417.         self.emit("added-data", node)
    418.         return node
    420.     def delete(self, node):
    421.         self.emit("remove-data", node)
    422.         self.remove(node)
    423.         for child_node in node.nodes[:]:
    424.             node.nodes.delete(child_node)
    426.     def __node_update_data_event(self, node):
    427.         self.emit("update-data", node)
    429.     def __node_added_data_event(self, node):
    430.         self.emit("added-data", node)
    432.     def __node_remove_data_event(self, node):
    433.         self.emit("remove-data", node)
    435.     def __Node_is_expanded_event(self, node):
    436.         self.emit("is-expanded", node)
    438.     def connect(self, event_name, function_point):
    439.         self.__function_dict[event_name] = function_point
    441.     def emit(self, event_name, *arg):
    442.         if self.__function_dict.has_key(event_name):
    443.             self.__function_dict[event_name](*arg)
    445. class Node(object):
    446.     def __init__(self):
    447.         self.__function_dict = {}
    448.         self.text  = ""
    449.         #self.sub_items = SubItems()
    450.         self.__pixbuf      = None
    451.         self.children = []
    452.         #
    453.         self.nodes = Nodes()
    454.         self.nodes.this = self
    455.         self.nodes.connect("update-data", self.__nodes_update_data_event)
    456.         self.nodes.connect("added-data",  self.__nodes_added_data_event)
    457.         self.nodes.connect("remove-data", self.__nodes_remove_data_event)
    458.         self.nodes.connect("is-expanded", self.__nodes_is_expanded_event)
    459.         #
    460.         self.parent = None # 获取当前树节点的夫节点.
    461.         self.leave  = 0    # 树的深度,不懂的看数据结构.
    462.         self.__last_node  = []   # 获取最后一个子树节点.
    463.         self.__first_node = []   # 获取树节点集合中的第一个子树节点.
    464.         self.__next_node  = []   # 获取下一个同级节点.
    465.         self.__prev_node  = []   # 获取上一个同级节点.
    466.         self.__index      = None # 获取树节点在树节点集合中的位置.
    467.         ####################
    468.         self.__is_expanded = False # 是否展开状态.
    469.         self.is_selected = False # 是否选中状态.
    470.         self.is_editing  = False # 是否可编辑状态.
    471.         ####################
    472.         self.node_font   = None  # 字体.
    473.         self.next_visible_node = None # 获取下一个可见树节点.
    474.         self.is_visible  = True # 是否可见.
    476.     def __nodes_update_data_event(self, nodes):
    477.         self.emit("update-data", nodes)
    479.     def __nodes_added_data_event(self, nodes):
    480.         self.emit("added-data", nodes)
    482.     def __nodes_remove_data_event(self, nodes):
    483.         self.emit("remove-data", nodes)
    485.     def __nodes_is_expanded_event(self, nodes):
    486.         self.emit("is-expanded", nodes)
    488.     def connect(self, event_name, function_point):
    489.         self.__function_dict[event_name] = function_point
    491.     def emit(self, event_name, *arg):
    492.         if self.__function_dict.has_key(event_name):
    493.             self.__function_dict[event_name](*arg)
    495.     '''
    496.     def add_widget(self, child_widget):
    497.         self.children.append(child_widget)
    498.     '''
    500.     @property
    501.     def is_expanded(self):
    502.         return self.__is_expanded
    504.     @is_expanded.setter
    505.     def is_expanded(self, check):
    506.         # 判断 is_expanded 不能相同 却 nodes不为空.
    507.         if self.__is_expanded != check and self.nodes:
    508.             self.__is_expanded = check
    509.             self.emit("is-expanded", self)
    511.     @is_expanded.getter
    512.     def is_expanded(self):
    513.         return self.__is_expanded
    515.     @property
    516.     def text(self):
    517.         return self.__text
    519.     @text.setter
    520.     def text(self, text):
    521.         self.__text = text
    522.         self.emit("update-data", self)
    524.     @text.getter
    525.     def text(self):
    526.         return self.__text
    528.     @property
    529.     def last_node(self):
    530.     # 获取最后一个子树节点.
    531.         return self.__last_node
    533.     @last_node.getter
    534.     def last_node(self):
    535.         if self.nodes == []:
    536.             return None
    537.         else:
    538.             return self.nodes[len(self.nodes)-1]
    540.     @property
    541.     def first_node(self):
    542.     # 获取树节点集合中的第一个子树节点.
    543.         return self.__first_node
    545.     @first_node.getter
    546.     def first_node(self):
    547.         if self.nodes == []:
    548.             return None
    549.         else:
    550.             return self.nodes[0]
    552.     @property
    553.     def prev_node(self):
    554.         return self.__prev_node
    555.    
    556.     @prev_node.getter
    557.     def prev_node(self):
    558.         # 获取上一个同级节点.
    559.         if self.parent:
    560.             index = self.parent.index(self)
    561.             if index:
    562.                 node = self.parent[index - 1]
    563.                 self.__prev_node = node
    564.                 return self.__prev_node
    565.         return None
    567.     @property
    568.     def next_node(self):
    569.         # 获取下一个同级节点.
    570.         return self.__next_node
    572.     @next_node.getter
    573.     def next_node(self):
    574.         if self.parent:
    575.             index = self.parent.index(self)
    576.             if index < len(self.parent) - 1:
    577.                 node = self.parent[index + 1]
    578.                 self.__next_node = node
    579.                 return self.__next_node
    580.         return None
    582.     @next_node.deleter
    583.     def next_node(self):
    584.         del self.__next_node
    586.     @property
    587.     def index(self):
    588.         return self.__index
    590.     @index.getter
    591.     def index(self):
    592.         if self.parent:
    593.             _index = self.parent.index(self)
    594.             return _index
    595.         return None
    597.     @property
    598.     def pixbuf(self):
    599.         return self.__pixbuf
    601.     @pixbuf.getter
    602.     def pixbuf(self):
    603.         return self.__pixbuf
    605.     @pixbuf.setter
    606.     def pixbuf(self, pixbuf):
    607.         self.__pixbuf = pixbuf
    608.         #self.emit()
    610.     @pixbuf.deleter
    611.     def pixbuf(self, pixbuf):
    612.         del self.__pixbuf
    615. if __name__ == "__main__":
    616.     def test_paint_nodes_event(e):
    617.         if e.node.leave == 0: # 根节点.
    618.             draw_text(e.cr,
    619.                       e.node.text,
    620.                       e.x + e.w/2 - get_text_size(e.node.text)[0]/2,
    621.                       e.y + e.h/2 - get_text_size(e.node.text)[1]/2)
    622.             e.cr.set_source_rgba(1, 1, 1, 1.0)
    623.             e.cr.rectangle(e.x, e.y, e.w, e.h)
    624.             e.cr.stroke()
    625.         else:
    626.             pixbuf = gtk.gdk.pixbuf_new_from_file("logo.png")
    627.             pixbuf = pixbuf.scale_simple(e.h, e.h, gtk.gdk.INTERP_BILINEAR)
    628.             draw_pixbuf(e.cr, pixbuf, e.x + e.w/2 - pixbuf.get_width()/2 + e.node.leave * e.h, e.y)
    629.             draw_text(e.cr,
    630.                       e.node.text,
    631.                       e.x + e.w/2 - get_text_size(e.node.text)[1]/2 + pixbuf.get_width() + e.node.leave * e.h,
    632.                       e.y + e.h/2 - get_text_size(e.node.text)[1]/2)
    633.         
    635.     win = gtk.Window(gtk.WINDOW_TOPLEVEL)
    636.     win.set_size_request(300, 300)
    637.     treeview_base = TreeViewBase()
    638.     treeview_base.paint_nodes_event = test_paint_nodes_event
    639.     scroll_win = gtk.ScrolledWindow()
    640.     #
    641.     node1 = treeview_base.nodes.add("小学")
    642.     node2 = treeview_base.nodes.add("初中")
    643.     node3 = treeview_base.nodes.add("高中")
    644.     node4 = treeview_base.nodes.add("大学")
    645.     node5 = treeview_base.nodes.add("社会")
    646.     for i in range(1, 10000):
    647.         treeview_base.nodes.add("test" + str(i))
    648.     print treeview_base.nodes[9999].text
    649.     for i in range(1, 7):
    650.         node1.nodes.add(str(i) + "年级")
    651.         node1.nodes[0].nodes.add("1年级(" + str(i) + ")班")
    652.     node1.nodes[0].nodes[0].nodes.add("小明")
    653.     node1.nodes[0].nodes[0].nodes.add("小王")
    654.     node1.nodes[0].nodes[0].nodes.add("小张")
    655.     node1.nodes[0].nodes[0].nodes.add("小红")
    656.     node1.nodes[0].nodes[0].is_expanded = True
    657.     for i in range(1, 4):
    658.         node2.nodes.add("初" + str(i))
    659.         node3.nodes.add("高" + str(i))
    660.         node4.nodes.add("大" + str(i))
    661.         node4.nodes[0].nodes.add("软件班级ZB4890" + str(i))
    662.     #
    663.     scroll_win.add_with_viewport(treeview_base)
    664.     win.add(scroll_win)
    665.     win.show_all()
    666.     gtk.main()
    Copy the Code
    Reply Favorite View the author
    All Replies
    go2012
    deepin
    2013-04-14 07:54
    #1
    不错,顶楼主,果然是好东西... ...
    Reply View the author
    java2012
    deepin
    2013-04-14 07:55
    #2
    不错,顶楼主,要发扬广大哈,楼主继续努力...
    Reply View the author
    cxbii
    deepin
    2013-04-14 22:54
    #3
    lz好厉害。。。。我顶你。。
    Reply View the author
    vala2012
    deepin
    2013-04-15 02:03
    #4
    lz好厉害。。。。我顶你。。
    哈哈哈，坛主好人一枚
    Reply View the author
    cxbii
    deepin
    2013-04-15 04:56
    #5
    [quote]lz好厉害。。。。我顶你。。
    哈哈哈，坛主好人一枚[/quote]
    :? 好人卡么
    我也要学编程。。
    Reply View the author
    vala2012
    deepin
    2013-04-15 09:29
    #6
    [quote][quote]lz好厉害。。。。我顶你。。
    哈哈哈，坛主好人一枚[/quote]
    :? 好人卡么
    我也要学编程。。[/quote]
    学吧,编程一点都不难, 开源这么多代码, 看看就会拉! 不行照抄一个, 支持你.... ...!!
    难的是搞游戏引擎的人(数学物理要牛).... .. 不是一般人能搞的.. 还有搞协议的...
    Reply View the author