← Back to branch summary

~ubuntu-branches/ubuntu/vivid/monodevelop/vivid-proposed

« back to all changes in this revision

Viewing changes to src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/Pages.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2014-10-09 14:09:23 UTC
  • mfrom: (10.3.5)
  • Revision ID: package-import@ubuntu.com-20141009140923-s0d22u5f9kg8jvds
Tags: 5.5.0.227-1
http://bugs.debian.org/754316
* [b2c8331] Imported Upstream version 5.5.0.227 (Closes: #754316)
* [d210995] Delete obsolete patches
* [1b59ae1] Clear patch fizz, via quilt refresh
* [3dd147d] Fix error in configure.in which applies for tarball builds but 
  not git builds when running autoreconf
* [21c2a57] Remove Metacity references for good
* [3331661] Ensure NUnit 2.6.3 is installed
* [fd85c88] Build-depend on NuGet
* [a1ae116] Add WebKit to build dependencies, for Xwt moduleref resolution
* [9b4cf12] Since the GDB addin is integrated now, declare it in 
  debian/control
* [6231562] Correct NUnit links
* [3d2b693] Fix NuGet addin, by copying libs locally
* [74bf9a8] Don't symlink unused Mocks NUnit assembly
* [ade52b2] Ensure IKVM.Reflection is built with default (4.5) profile

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/Pages.cs
 
1
// 
 
2
// Pages.cs
 
3
// 
 
4
// Author:
 
5
//   Matt Ward <ward.matt@gmail.com>
 
6
// 
 
7
// Copyright (C) 2013 Matthew Ward
 
8
// 
 
9
// Permission is hereby granted, free of charge, to any person obtaining
 
10
// a copy of this software and associated documentation files (the
 
11
// "Software"), to deal in the Software without restriction, including
 
12
// without limitation the rights to use, copy, modify, merge, publish,
 
13
// distribute, sublicense, and/or sell copies of the Software, and to
 
14
// permit persons to whom the Software is furnished to do so, subject to
 
15
// the following conditions:
 
16
// 
 
17
// The above copyright notice and this permission notice shall be
 
18
// included in all copies or substantial portions of the Software.
 
19
// 
 
20
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 
21
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 
22
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 
23
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 
24
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 
25
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 
26
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
27
//
 
28
 
 
29
using System;
 
30
using System.Collections.ObjectModel;
 
31
 
 
32
namespace ICSharpCode.PackageManagement
 
33
{
 
34
        public class Pages : ObservableCollection<Page>
 
35
        {
 
36
                public const int DefaultPageSize = 29;
 
37
                public const int DefaultMaximumSelectablePages = 5;
 
38
                
 
39
                int pageSize = DefaultPageSize;
 
40
                int selectedPageNumber = 1;
 
41
                int maximumSelectablePages = DefaultMaximumSelectablePages;
 
42
                int totalItems = 0;
 
43
                int itemsOnSelectedPage = 0;
 
44
                
 
45
                public int TotalItems {
 
46
                        get { return totalItems; }
 
47
                        set {
 
48
                                if (totalItems != value) {
 
49
                                        totalItems = value;
 
50
                                        UpdatePages();
 
51
                                }
 
52
                        }
 
53
                }
 
54
                
 
55
                public int SelectedPageNumber {
 
56
                        get { return selectedPageNumber; }
 
57
                        set {
 
58
                                if (selectedPageNumber != value) {
 
59
                                        selectedPageNumber = value;
 
60
                                        UpdatePages();
 
61
                                }
 
62
                        }
 
63
                }
 
64
                
 
65
                public int MaximumSelectablePages {
 
66
                        get { return maximumSelectablePages; }
 
67
                        set {
 
68
                                if (maximumSelectablePages != value) {
 
69
                                        maximumSelectablePages = value;
 
70
                                        UpdatePages();
 
71
                                }
 
72
                        }
 
73
                }
 
74
                
 
75
                public int ItemsBeforeFirstPage {
 
76
                        get {
 
77
                                return (selectedPageNumber - 1) * pageSize;
 
78
                        }
 
79
                }
 
80
 
 
81
                public bool IsPaged {
 
82
                        get { return totalItems > pageSize; }
 
83
                }
 
84
                
 
85
                public bool HasPreviousPage {
 
86
                        get { return IsPaged && !IsFirstPageSelected; }
 
87
                }
 
88
                
 
89
                bool IsFirstPageSelected {
 
90
                        get { return selectedPageNumber == 1; }
 
91
                }
 
92
                
 
93
                public bool HasNextPage {
 
94
                        get { return IsPaged && !IsLastPageSelected; }
 
95
                }
 
96
                
 
97
                bool IsLastPageSelected {
 
98
                        get { return selectedPageNumber == TotalPages; }
 
99
                }
 
100
                
 
101
                public int TotalPages {
 
102
                        get { return (totalItems + pageSize - 1) / pageSize; }
 
103
                }
 
104
                
 
105
                public int PageSize {
 
106
                        get { return pageSize; }
 
107
                        set {
 
108
                                if (pageSize != value) {
 
109
                                        pageSize = value;
 
110
                                        UpdatePages();
 
111
                                }
 
112
                        }
 
113
                }
 
114
                
 
115
                void UpdatePages()
 
116
                {
 
117
                        Clear();
 
118
                        
 
119
                        int startPage = GetStartPage();
 
120
                        for (int pageNumber = startPage; pageNumber <= TotalPages; ++pageNumber) {
 
121
                                if (Count >= maximumSelectablePages) {
 
122
                                        break;
 
123
                                }
 
124
                                Page page = CreatePage(pageNumber);
 
125
                                Add(page);
 
126
                        }
 
127
                }
 
128
                
 
129
                int GetStartPage()
 
130
                {
 
131
                        // Less pages than can be selected?
 
132
                        int totalPages = TotalPages;
 
133
                        if (totalPages <= maximumSelectablePages) {
 
134
                                return 1;
 
135
                        }
 
136
                        
 
137
                        // First choice for start page.
 
138
                        int startPage = selectedPageNumber - (maximumSelectablePages / 2);
 
139
                        if (startPage <= 0) {
 
140
                                return 1;
 
141
                        }
 
142
                        
 
143
                        // Do we have enough pages?
 
144
                        int totalPagesBasedOnStartPage = totalPages - startPage + 1;
 
145
                        if (totalPagesBasedOnStartPage >= maximumSelectablePages) {
 
146
                                return startPage;
 
147
                        }
 
148
                        
 
149
                        // Ensure we have enough pages.
 
150
                        startPage -= maximumSelectablePages - totalPagesBasedOnStartPage;
 
151
                        if (startPage > 0) {
 
152
                                return startPage;
 
153
                        }
 
154
                        return 1;
 
155
                }
 
156
                
 
157
                Page CreatePage(int pageNumber)
 
158
                {
 
159
                        var page = new Page();
 
160
                        page.Number = pageNumber;
 
161
                        page.IsSelected = IsSelectedPage(pageNumber);
 
162
                        return page;
 
163
                }
 
164
                
 
165
                bool IsSelectedPage(int pageNumber)
 
166
                {
 
167
                        return pageNumber == selectedPageNumber;
 
168
                }
 
169
                
 
170
                public int TotalItemsOnSelectedPage {
 
171
                        get { return itemsOnSelectedPage; }
 
172
                        set {
 
173
                                itemsOnSelectedPage = value;
 
174
                                if (itemsOnSelectedPage < pageSize) {
 
175
                                        TotalItems = (selectedPageNumber - 1) * pageSize + itemsOnSelectedPage;
 
176
                                }
 
177
                        }
 
178
                }
 
179
        }
 
180
}