← Back to branch summary

~ubuntu-branches/ubuntu/trusty/blender/trusty

« back to all changes in this revision

Viewing changes to intern/ghost/test/multitest/ScrollBar.c

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2013-03-06 12:08:47 UTC
  • mfrom: (1.5.1) (14.1.8 experimental)
  • Revision ID: package-import@ubuntu.com-20130306120847-frjfaryb2zrotwcg
Tags: 2.66a-1ubuntu1
https://launchpad.net/bugs/1076930
https://launchpad.net/bugs/1089256
https://launchpad.net/bugs/1052743
https://launchpad.net/bugs/999024
* Resynchronize with Debian (LP: #1076930, #1089256, #1052743, #999024,
  #1122888, #1147084)
* debian/control:
  - Lower build-depends on libavcodec-dev since we're not
    doing the libav9 transition in Ubuntu yet

Show diffs side-by-side

added added

removed removed

Lines of Context:
intern/ghost/test/multitest/ScrollBar.c
35
35
#include "ScrollBar.h"
36
36
 
37
37
struct _ScrollBar {
38
 
        int             rect[2][2];
39
 
        float   thumbpos, thumbpct;
 
38
        int rect[2][2];
 
39
        float thumbpos, thumbpct;
40
40
        
41
 
        int             inset;
42
 
        int             minthumb;
 
41
        int inset;
 
42
        int minthumb;
43
43
 
44
 
        int             scrolling;
45
 
        float   scrolloffs;
 
44
        int scrolling;
 
45
        float scrolloffs;
46
46
};
47
47
 
48
 
static int scrollbar_get_thumbH(ScrollBar *sb) {
49
 
        int scrollable_h= rect_height(sb->rect) - 2*sb->inset;
 
48
static int scrollbar_get_thumbH(ScrollBar *sb)
 
49
{
 
50
        int scrollable_h = rect_height(sb->rect) - 2 * sb->inset;
50
51
        
51
 
        return clamp_i(sb->thumbpct*scrollable_h, sb->minthumb, scrollable_h);
 
52
        return clamp_i(sb->thumbpct * scrollable_h, sb->minthumb, scrollable_h);
52
53
}
53
 
static int scrollbar_get_thumbableH(ScrollBar *sb) {
54
 
        int scrollable_h= rect_height(sb->rect) - 2*sb->inset;
55
 
        int thumb_h= scrollbar_get_thumbH(sb);
 
54
 
 
55
static int scrollbar_get_thumbableH(ScrollBar *sb)
 
56
{
 
57
        int scrollable_h = rect_height(sb->rect) - 2 * sb->inset;
 
58
        int thumb_h = scrollbar_get_thumbH(sb);
56
59
        
57
60
        return scrollable_h - thumb_h;
58
61
}
59
62
 
60
 
static float scrollbar_co_to_pos(ScrollBar *sb, int yco) {
61
 
        int thumb_h= scrollbar_get_thumbH(sb);
62
 
        int thumbable_h= scrollbar_get_thumbableH(sb);
63
 
        int thumbable_y= (sb->rect[0][1]+sb->inset) + thumb_h/2;
 
63
static float scrollbar_co_to_pos(ScrollBar *sb, int yco)
 
64
{
 
65
        int thumb_h = scrollbar_get_thumbH(sb);
 
66
        int thumbable_h = scrollbar_get_thumbableH(sb);
 
67
        int thumbable_y = (sb->rect[0][1] + sb->inset) + thumb_h / 2;
64
68
 
65
 
        return (float) (yco-thumbable_y)/thumbable_h;
 
69
        return (float) (yco - thumbable_y) / thumbable_h;
66
70
}
67
71
 
68
72
/**/
69
73
 
70
 
ScrollBar *scrollbar_new(int inset, int minthumb) {
71
 
        ScrollBar *sb= MEM_callocN(sizeof(*sb), "scrollbar_new");
72
 
        sb->inset= inset;
73
 
        sb->minthumb= minthumb;
 
74
ScrollBar *scrollbar_new(int inset, int minthumb)
 
75
{
 
76
        ScrollBar *sb = MEM_callocN(sizeof(*sb), "scrollbar_new");
 
77
        sb->inset = inset;
 
78
        sb->minthumb = minthumb;
74
79
        
75
80
        return sb;
76
81
}
77
82
 
78
 
void scrollbar_get_thumb(ScrollBar *sb, int thumb_r[2][2]) {
79
 
        int thumb_h= scrollbar_get_thumbH(sb);
80
 
        int thumbable_h= scrollbar_get_thumbableH(sb);
81
 
 
82
 
        thumb_r[0][0]= sb->rect[0][0]+sb->inset;
83
 
        thumb_r[1][0]= sb->rect[1][0]-sb->inset;
84
 
 
85
 
        thumb_r[0][1]= sb->rect[0][1]+sb->inset + sb->thumbpos*thumbable_h;
86
 
        thumb_r[1][1]= thumb_r[0][1] + thumb_h;
 
83
void scrollbar_get_thumb(ScrollBar *sb, int thumb_r[2][2])
 
84
{
 
85
        int thumb_h = scrollbar_get_thumbH(sb);
 
86
        int thumbable_h = scrollbar_get_thumbableH(sb);
 
87
 
 
88
        thumb_r[0][0] = sb->rect[0][0] + sb->inset;
 
89
        thumb_r[1][0] = sb->rect[1][0] - sb->inset;
 
90
 
 
91
        thumb_r[0][1] = sb->rect[0][1] + sb->inset + sb->thumbpos * thumbable_h;
 
92
        thumb_r[1][1] = thumb_r[0][1] + thumb_h;
87
93
}
88
94
 
89
 
int scrollbar_is_scrolling(ScrollBar *sb) {
 
95
int scrollbar_is_scrolling(ScrollBar *sb)
 
96
{
90
97
        return sb->scrolling;
91
98
}
92
 
int scrollbar_contains_pt(ScrollBar *sb, int pt[2]) {
 
99
int scrollbar_contains_pt(ScrollBar *sb, int pt[2])
 
100
{
93
101
        return rect_contains_pt(sb->rect, pt);
94
102
}
95
103
 
96
 
void scrollbar_start_scrolling(ScrollBar *sb, int yco) {
97
 
        int thumb_h_2= scrollbar_get_thumbH(sb)/2;
98
 
        int thumbable_h= scrollbar_get_thumbableH(sb);
99
 
        float npos= scrollbar_co_to_pos(sb, yco);
 
104
void scrollbar_start_scrolling(ScrollBar *sb, int yco)
 
105
{
 
106
        int thumb_h_2 = scrollbar_get_thumbH(sb) / 2;
 
107
        int thumbable_h = scrollbar_get_thumbableH(sb);
 
108
        float npos = scrollbar_co_to_pos(sb, yco);
100
109
 
101
 
        sb->scrolloffs= sb->thumbpos - npos;
102
 
        if (fabs(sb->scrolloffs) >= (float) thumb_h_2/thumbable_h) {
103
 
                sb->scrolloffs= 0.0;
 
110
        sb->scrolloffs = sb->thumbpos - npos;
 
111
        if (fabs(sb->scrolloffs) >= (float) thumb_h_2 / thumbable_h) {
 
112
                sb->scrolloffs = 0.0;
104
113
        }
105
114
 
106
 
        sb->scrolling= 1;
107
 
        sb->thumbpos= clamp_f(npos + sb->scrolloffs, 0.0, 1.0);
108
 
}
109
 
void scrollbar_keep_scrolling(ScrollBar *sb, int yco) {
110
 
        float npos= scrollbar_co_to_pos(sb, yco);
111
 
 
112
 
        sb->thumbpos= clamp_f(npos + sb->scrolloffs, 0.0, 1.0);
113
 
}
114
 
void scrollbar_stop_scrolling(ScrollBar *sb) {
115
 
        sb->scrolling= 0;
116
 
        sb->scrolloffs= 0.0;
117
 
}
118
 
 
119
 
void scrollbar_set_thumbpct(ScrollBar *sb, float pct) {
120
 
        sb->thumbpct= pct;
121
 
}
122
 
void scrollbar_set_thumbpos(ScrollBar *sb, float pos) {
123
 
        sb->thumbpos= clamp_f(pos, 0.0, 1.0);
124
 
}
125
 
void scrollbar_set_rect(ScrollBar *sb, int rect[2][2]) {
 
115
        sb->scrolling = 1;
 
116
        sb->thumbpos = clamp_f(npos + sb->scrolloffs, 0.0, 1.0);
 
117
}
 
118
void scrollbar_keep_scrolling(ScrollBar *sb, int yco)
 
119
{
 
120
        float npos = scrollbar_co_to_pos(sb, yco);
 
121
 
 
122
        sb->thumbpos = clamp_f(npos + sb->scrolloffs, 0.0, 1.0);
 
123
}
 
124
void scrollbar_stop_scrolling(ScrollBar *sb)
 
125
{
 
126
        sb->scrolling = 0;
 
127
        sb->scrolloffs = 0.0;
 
128
}
 
129
 
 
130
void scrollbar_set_thumbpct(ScrollBar *sb, float pct)
 
131
{
 
132
        sb->thumbpct = pct;
 
133
}
 
134
void scrollbar_set_thumbpos(ScrollBar *sb, float pos)
 
135
{
 
136
        sb->thumbpos = clamp_f(pos, 0.0, 1.0);
 
137
}
 
138
void scrollbar_set_rect(ScrollBar *sb, int rect[2][2])
 
139
{
126
140
        rect_copy(sb->rect, rect);
127
141
}
128
142
 
129
 
float scrollbar_get_thumbpct(ScrollBar *sb) {
 
143
float scrollbar_get_thumbpct(ScrollBar *sb)
 
144
{
130
145
        return sb->thumbpct;
131
146
}
132
 
float scrollbar_get_thumbpos(ScrollBar *sb) {
 
147
float scrollbar_get_thumbpos(ScrollBar *sb)
 
148
{
133
149
        return sb->thumbpos;
134
150
}
135
 
void scrollbar_get_rect(ScrollBar *sb, int rect_r[2][2]) {
 
151
void scrollbar_get_rect(ScrollBar *sb, int rect_r[2][2])
 
152
{
136
153
        rect_copy(rect_r, sb->rect);
137
154
}
138
155
 
139
 
void scrollbar_free(ScrollBar *sb) {
 
156
void scrollbar_free(ScrollBar *sb)
 
157
{
140
158
        MEM_freeN(sb);
141
159
}