← Back to branch summary

~ubuntu-branches/ubuntu/saucy/mumble-django/saucy-proposed

« back to all changes in this revision

Viewing changes to pyweb/mumble/media/js/TabScrollerMenu.js

  • Committer: Package Import Robot
  • Author(s): Michael Ziegler
  • Date: 2013-05-19 18:06:11 UTC
  • mfrom: (1.2.6)
  • Revision ID: package-import@ubuntu.com-20130519180611-flqpsk20fu2t6hq4
Tags: 2.9-1
* New upstream release.
* Drop DM-Upload-Allowed as it isn't used any longer.
* Update VCS-{SVN,Browser} tags.
* Update Django dependency to 1.5.
* Remove template patch for django-registration 0.8 (applied upstream).
* Remove the hunk that adds MessageMiddleware to settings.py (applied
  upstream).
* Disable the registration app for now (incompatible to Django 1.5).
* Remove dependency to python-simplejson.
* Adapt apache config to staticfiles change.

Show diffs side-by-side

added added

removed removed

Lines of Context:
pyweb/mumble/media/js/TabScrollerMenu.js
1
 
/*!
2
 
 * Ext JS Library 3.2.1
3
 
 * Copyright(c) 2006-2010 Ext JS, Inc.
4
 
 * licensing@extjs.com
5
 
 * http://www.extjs.com/license
6
 
 */
7
 
Ext.ns('Ext.ux');
8
 
/**
9
 
 * @class Ext.ux.TabScrollerMenu
10
 
 * @extends Object 
11
 
 * Plugin (ptype = 'tabscrollermenu') for adding a tab scroller menu to tabs.
12
 
 * @constructor 
13
 
 * @param {Object} config Configuration options
14
 
 * @ptype tabscrollermenu
15
 
 */
16
 
Ext.ux.TabScrollerMenu =  Ext.extend(Object, {
17
 
    /**
18
 
     * @cfg {Number} pageSize How many items to allow per submenu.
19
 
     */
20
 
        pageSize       : 10,
21
 
    /**
22
 
     * @cfg {Number} maxText How long should the title of each {@link Ext.menu.Item} be.
23
 
     */
24
 
        maxText        : 15,
25
 
    /**
26
 
     * @cfg {String} menuPrefixText Text to prefix the submenus.
27
 
     */    
28
 
        menuPrefixText : 'Items',
29
 
        constructor    : function(config) {
30
 
                config = config || {};
31
 
                Ext.apply(this, config);
32
 
        },
33
 
    //private
34
 
        init : function(tabPanel) {
35
 
                Ext.apply(tabPanel, this.parentOverrides);
36
 
                
37
 
                tabPanel.tabScrollerMenu = this;
38
 
                var thisRef = this;
39
 
                
40
 
                tabPanel.on({
41
 
                        render : {
42
 
                                scope  : tabPanel,
43
 
                                single : true,
44
 
                                fn     : function() { 
45
 
                                        var newFn = tabPanel.createScrollers.createSequence(thisRef.createPanelsMenu, this);
46
 
                                        tabPanel.createScrollers = newFn;
47
 
                                }
48
 
                        }
49
 
                });
50
 
        },
51
 
        // private && sequeneced
52
 
        createPanelsMenu : function() {
53
 
                var h = this.stripWrap.dom.offsetHeight;
54
 
                
55
 
                //move the right menu item to the left 18px
56
 
                var rtScrBtn = this.header.dom.firstChild;
57
 
                Ext.fly(rtScrBtn).applyStyles({
58
 
                        right : '18px'
59
 
                });
60
 
                
61
 
                var stripWrap = Ext.get(this.strip.dom.parentNode);
62
 
                stripWrap.applyStyles({
63
 
                         'margin-right' : '36px'
64
 
                });
65
 
                
66
 
                // Add the new righthand menu
67
 
                var scrollMenu = this.header.insertFirst({
68
 
                        cls:'x-tab-tabmenu-right'
69
 
                });
70
 
                scrollMenu.setHeight(h);
71
 
                scrollMenu.addClassOnOver('x-tab-tabmenu-over');
72
 
                scrollMenu.on('click', this.showTabsMenu, this);        
73
 
                
74
 
                this.scrollLeft.show = this.scrollLeft.show.createSequence(function() {
75
 
                        scrollMenu.show();                                                                                                                                               
76
 
                });
77
 
                
78
 
                this.scrollLeft.hide = this.scrollLeft.hide.createSequence(function() {
79
 
                        scrollMenu.hide();                                                              
80
 
                });
81
 
                
82
 
        },
83
 
    /**
84
 
     * Returns an the current page size (this.pageSize);
85
 
     * @return {Number} this.pageSize The current page size.
86
 
     */
87
 
        getPageSize : function() {
88
 
                return this.pageSize;
89
 
        },
90
 
    /**
91
 
     * Sets the number of menu items per submenu "page size".
92
 
     * @param {Number} pageSize The page size
93
 
     */
94
 
    setPageSize : function(pageSize) {
95
 
                this.pageSize = pageSize;
96
 
        },
97
 
    /**
98
 
     * Returns the current maxText length;
99
 
     * @return {Number} this.maxText The current max text length.
100
 
     */
101
 
    getMaxText : function() {
102
 
                return this.maxText;
103
 
        },
104
 
    /**
105
 
     * Sets the maximum text size for each menu item.
106
 
     * @param {Number} t The max text per each menu item.
107
 
     */
108
 
    setMaxText : function(t) {
109
 
                this.maxText = t;
110
 
        },
111
 
    /**
112
 
     * Returns the current menu prefix text String.;
113
 
     * @return {String} this.menuPrefixText The current menu prefix text.
114
 
     */
115
 
        getMenuPrefixText : function() {
116
 
                return this.menuPrefixText;
117
 
        },
118
 
    /**
119
 
     * Sets the menu prefix text String.
120
 
     * @param {String} t The menu prefix text.
121
 
     */    
122
 
        setMenuPrefixText : function(t) {
123
 
                this.menuPrefixText = t;
124
 
        },
125
 
        // private && applied to the tab panel itself.
126
 
        parentOverrides : {
127
 
                // all execute within the scope of the tab panel
128
 
                // private      
129
 
                showTabsMenu : function(e) {            
130
 
                        if  (this.tabsMenu) {
131
 
                                this.tabsMenu.destroy();
132
 
                this.un('destroy', this.tabsMenu.destroy, this.tabsMenu);
133
 
                this.tabsMenu = null;
134
 
                        }
135
 
            this.tabsMenu =  new Ext.menu.Menu();
136
 
            this.on('destroy', this.tabsMenu.destroy, this.tabsMenu);
137
 
 
138
 
            this.generateTabMenuItems();
139
 
 
140
 
            var target = Ext.get(e.getTarget());
141
 
                        var xy     = target.getXY();
142
 
//
143
 
                        //Y param + 24 pixels
144
 
                        xy[1] += 24;
145
 
                        
146
 
                        this.tabsMenu.showAt(xy);
147
 
                },
148
 
                // private      
149
 
                generateTabMenuItems : function() {
150
 
                        var curActive  = this.getActiveTab();
151
 
                        var totalItems = this.items.getCount();
152
 
                        var pageSize   = this.tabScrollerMenu.getPageSize();
153
 
                        
154
 
                        
155
 
                        if (totalItems > pageSize)  {
156
 
                                var numSubMenus = Math.floor(totalItems / pageSize);
157
 
                                var remainder   = totalItems % pageSize;
158
 
                                
159
 
                                // Loop through all of the items and create submenus in chunks of 10
160
 
                                for (var i = 0 ; i < numSubMenus; i++) {
161
 
                                        var curPage = (i + 1) * pageSize;
162
 
                                        var menuItems = [];
163
 
                                        
164
 
                                        
165
 
                                        for (var x = 0; x < pageSize; x++) {                            
166
 
                                                index = x + curPage - pageSize;
167
 
                                                var item = this.items.get(index);
168
 
                                                menuItems.push(this.autoGenMenuItem(item));
169
 
                                        }
170
 
                                        
171
 
                                        this.tabsMenu.add({
172
 
                                                text : this.tabScrollerMenu.getMenuPrefixText() + ' '  + (curPage - pageSize + 1) + ' - ' + curPage,
173
 
                                                menu : menuItems
174
 
                                        });
175
 
                                        
176
 
                                }
177
 
                                // remaining items
178
 
                                if (remainder > 0) {
179
 
                                        var start = numSubMenus * pageSize;
180
 
                                        menuItems = [];
181
 
                                        for (var i = start ; i < totalItems; i ++ ) {                                   
182
 
                                                var item = this.items.get(i);
183
 
                                                menuItems.push(this.autoGenMenuItem(item));
184
 
                                        }
185
 
                                        
186
 
                                        this.tabsMenu.add({
187
 
                                                text : this.tabScrollerMenu.menuPrefixText  + ' ' + (start + 1) + ' - ' + (start + menuItems.length),
188
 
                                                menu : menuItems
189
 
                                        });
190
 
 
191
 
                                }
192
 
                        }
193
 
                        else {
194
 
                                this.items.each(function(item) {
195
 
                                        if (item.id != curActive.id && !item.hidden) {
196
 
                        this.tabsMenu.add(this.autoGenMenuItem(item));
197
 
                                        }
198
 
                                }, this);
199
 
                        }
200
 
                },
201
 
                // private
202
 
                autoGenMenuItem : function(item) {
203
 
                        var maxText = this.tabScrollerMenu.getMaxText();
204
 
                        var text    = Ext.util.Format.ellipsis(item.title, maxText);
205
 
                        
206
 
                        return {
207
 
                                text      : text,
208
 
                                handler   : this.showTabFromMenu,
209
 
                                scope     : this,
210
 
                                disabled  : item.disabled,
211
 
                                tabToShow : item,
212
 
                                iconCls   : item.iconCls
213
 
                        }
214
 
                
215
 
                },
216
 
                // private
217
 
                showTabFromMenu : function(menuItem) {
218
 
                        this.setActiveTab(menuItem.tabToShow);
219
 
                }       
220
 
        }       
221
 
});
222
 
 
223
 
Ext.reg('tabscrollermenu', Ext.ux.TabScrollerMenu);