~and471/slickpanel/trunk

« back to all changes in this revision

Viewing changes to panel/items/indicatorlist.vala

  • Committer: Andrew Higginson
  • Date: 2014-12-29 17:48:31 UTC
  • Revision ID: at.higginson@gmail.com-20141229174831-bukedaw8kny4aq8t
updating

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/* Copyright 2010 Andrew Higginson
2
 
 *
3
 
 * This program is free software; you can redistribute it and/or modify
4
 
 * it under the terms of the GNU General Public License as published by
5
 
 * the Free Software Foundation; either version 2 of the License, or
6
 
 * (at your option) any later version.
7
 
*/
8
 
 
9
 
namespace SlickPanel {
10
 
 
11
 
public class IndicatorItem : Gtk.MenuItem {
12
 
 
13
 
    public Indicator.Object object;
14
 
    public unowned Indicator.ObjectEntry entry;
15
 
 
16
 
    public IndicatorItem(Indicator.Object object, Indicator.ObjectEntry entry) {
17
 
        this.object = object;
18
 
        this.entry = entry;
19
 
        
20
 
        var hbox = new Gtk.HBox (false, 6);
21
 
        if (entry.image != null && entry.image is Gtk.Image) {
22
 
            hbox.pack_start(entry.image, false, false);
23
 
        }
24
 
        if (entry.label != null && entry.label is Gtk.Label) {
25
 
            hbox.pack_end(entry.label, true, true);
26
 
        }
27
 
        if (entry.menu != null && entry.menu is Gtk.Menu) {
28
 
            this.set_submenu(entry.menu);
29
 
        }
30
 
        this.add(hbox);
31
 
        
32
 
        this.scroll_event.connect(this.on_scroll_event);
33
 
    }
34
 
    
35
 
    private bool on_scroll_event(Gdk.EventScroll event) {
36
 
        Signal.emit_by_name(this.object, Indicator.OBJECT_SIGNAL_ENTRY_SCROLLED, this.entry, 1, (Indicator.ScrollDirection) event.direction);
37
 
    
38
 
        return false;
39
 
    }
40
 
}
41
 
 
42
 
public class IndicatorList : Item {
43
 
 
44
 
    private File[] indicator_files;
45
 
    private Gee.TreeMap<string, Object> indicator_objects;
46
 
    public signal void loaded();
47
 
 
48
 
    public IndicatorList() {
49
 
        this.type_ = Settings.ItemType.INDICATOR_BAR;
50
 
        this.widget = new Gtk.MenuBar();
51
 
        
52
 
        this.indicator_objects = new Gee.TreeMap<string, Object>(
53
 
            (a, b) => {
54
 
                var order_a = IndicatorOrder.from_name((string) a);
55
 
                var order_b = IndicatorOrder.from_name((string) b);
56
 
                
57
 
                if (order_a > order_b) {
58
 
                    return -1;
59
 
                }
60
 
                if (order_a == order_b) {
61
 
                    return 0;
62
 
                }
63
 
                if (order_a < order_b) {
64
 
                    return 1;
65
 
                }
66
 
                assert_not_reached();
67
 
            });
68
 
        this.loaded.connect(this.on_loaded);
69
 
        Thread.create<void*>(get_indicator_files, false);
70
 
    }
71
 
    
72
 
    public override void set_orientation(Gtk.Orientation orientation) {
73
 
        if (orientation == Gtk.Orientation.HORIZONTAL) {
74
 
            (this.widget as Gtk.MenuBar).set_pack_direction(Gtk.PackDirection.LTR);
75
 
        } else {
76
 
            (this.widget as Gtk.MenuBar).set_pack_direction(Gtk.PackDirection.TTB);
77
 
        }
78
 
    }
79
 
    
80
 
    public override void set_settings(Settings.Item item_settings) {
81
 
        //do something
82
 
    }
83
 
 
84
 
    /* Private Functions */
85
 
    
86
 
    private void* get_indicator_files() {
87
 
        var indicator_directory = File.new_for_path(Config.INDICATORS_DIR);
88
 
        this.indicator_files = Paths.enumerate_directory(indicator_directory, 
89
 
            (file_name) => {
90
 
                var is_library_file = file_name.has_suffix(Module.SUFFIX);
91
 
                var is_not_appmenu = file_name != "libappmenu.so";
92
 
        
93
 
                return (is_library_file && is_not_appmenu);
94
 
            });
95
 
        this.loaded();
96
 
        return null;
97
 
    }
98
 
    
99
 
    private void create_indicator_menus(File[] indicator_files) {
100
 
        foreach (var indicator_file in indicator_files) {
101
 
            var indicator_object = new Indicator.Object.from_file(indicator_file.get_path());
102
 
            indicator_object.set_data("file-name", indicator_file.get_basename());
103
 
            indicator_object.entry_added.connect(this.on_indicator_object_entry_added);
104
 
            indicator_object.entry_removed.connect(this.on_indicator_object_entry_removed);
105
 
            indicator_object.ref();
106
 
            this.indicator_objects.set(indicator_file.get_basename(), indicator_object);
107
 
        }
108
 
        
109
 
        foreach (var indicator_object in this.indicator_objects.values) {
110
 
            unowned GLib.List<unowned Indicator.ObjectEntry> entries = 
111
 
                ((Indicator.Object) indicator_object).get_entries();
112
 
            
113
 
            foreach (var entry in entries) {
114
 
                this.create_indicator_menuitem(
115
 
                    indicator_object as Indicator.Object, entry);
116
 
            }
117
 
        }
118
 
    }
119
 
    
120
 
    private void create_indicator_menuitem(Indicator.Object object, 
121
 
        Indicator.ObjectEntry entry, int? position = null) 
122
 
    {
123
 
        var item = new IndicatorItem(object, entry);
124
 
        
125
 
        if (position != null) {
126
 
            (this.widget as Gtk.MenuBar).insert(item, position);
127
 
        } else {
128
 
            (this.widget as Gtk.MenuBar).prepend(item);
129
 
        }
130
 
        item.show_all();
131
 
    }
132
 
    
133
 
    private IndicatorItem? get_item_for_entry(Indicator.ObjectEntry entry) {
134
 
        foreach (var widget in (this.widget as Gtk.MenuBar).get_children()) {
135
 
            var item = widget as IndicatorItem;
136
 
            if (item.entry == entry) {
137
 
                return item;
138
 
            }
139
 
        }
140
 
        return null;
141
 
    }
142
 
    
143
 
    /* Callbacks */
144
 
 
145
 
    private void on_loaded() {
146
 
        this.create_indicator_menus(this.indicator_files);
147
 
    }
148
 
    
149
 
    private void on_indicator_object_entry_added(Indicator.Object object, 
150
 
        Indicator.ObjectEntry entry) {
151
 
        
152
 
        var order = IndicatorOrder.from_name(object.get_data("file-name"));
153
 
        IndicatorOrder closest_order = IndicatorOrder.NO_ORDER;
154
 
        int? position = null;
155
 
        
156
 
        foreach (var widget in (this.widget as Gtk.MenuBar).get_children()) {
157
 
            var item = widget as IndicatorItem;
158
 
            var item_order = IndicatorOrder.from_name(item.object.get_data("file-name"));
159
 
            
160
 
            bool distance_is_less = Utils.Math.mod(item_order - order)
161
 
                < Utils.Math.mod(closest_order - order);
162
 
            bool distance_is_not_zero = item_order - order != 0;
163
 
            
164
 
            if (distance_is_less && distance_is_not_zero) {
165
 
                closest_order = item_order;
166
 
                position = (this.widget as Gtk.MenuBar).get_children().index(widget) + 1;
167
 
            }
168
 
 
169
 
        }
170
 
        
171
 
        this.create_indicator_menuitem(object, entry, position);
172
 
    }
173
 
    
174
 
    private void on_indicator_object_entry_removed(Indicator.Object object, 
175
 
        Indicator.ObjectEntry entry)
176
 
    {
177
 
        var item = this.get_item_for_entry(entry);
178
 
        if (item != null) {
179
 
            (this.widget as Gtk.MenuBar).remove(item);
180
 
        }
181
 
    }
182
 
 
183
 
    /* Public Functions */
184
 
    public override bool set_xml_property(string name, string value) {
185
 
        bool handled = base.set_xml_property(name, value);
186
 
        if (handled) {
187
 
            return true;
188
 
        }
189
 
        switch (name) {
190
 
            case "ellipsis":
191
 
                return true;
192
 
            default:
193
 
                return false;
194
 
        }
195
 
    }
196
 
}
197
 
}