Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(259)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: fpdfsdk/src/pdfwindow/PWL_ScrollBar.cpp

Issue 453133004: clang-format all code (Closed) Base URL: https://pdfium.googlesource.com/pdfium.git@master
Patch Set: Created 6 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« core/src/fdrm/crypto/fx_crypt_aes.cpp ('K') | « fpdfsdk/src/pdfwindow/PWL_Note.cpp ('k') | fpdfsdk/src/pdfwindow/PWL_Signature.cpp » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2014 PDFium Authors. All rights reserved. 1 // Copyright 2014 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com 5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6 6
7 #include "../../include/pdfwindow/PDFWindow.h" 7 #include "../../include/pdfwindow/PDFWindow.h"
8 #include "../../include/pdfwindow/PWL_Wnd.h" 8 #include "../../include/pdfwindow/PWL_Wnd.h"
9 #include "../../include/pdfwindow/PWL_ScrollBar.h" 9 #include "../../include/pdfwindow/PWL_ScrollBar.h"
10 #include "../../include/pdfwindow/PWL_Utils.h" 10 #include "../../include/pdfwindow/PWL_Utils.h"
11 11
12 #define IsFloatZero(f) ((f) < 0.0001 && (f) > -0.0001) 12 #define IsFloatZero(f) ((f) < 0.0001 && (f) > -0.0001)
13 #define IsFloatBigger(fa,fb) ((fa) > (fb) && !IsFloat Zero((fa) - (fb))) 13 #define IsFloatBigger(fa, fb) ((fa) > (fb) && !IsFloatZero((fa) - (fb)))
14 #define IsFloatSmaller(fa,fb) ((fa) < (fb) && !IsFloat Zero((fa) - (fb))) 14 #define IsFloatSmaller(fa, fb) ((fa) < (fb) && !IsFloatZero((fa) - (fb)))
15 #define IsFloatEqual(fa,fb) IsFloatZero((fa) -(fb)) 15 #define IsFloatEqual(fa, fb) IsFloatZero((fa) - (fb))
16 16
17 17 /* ------------------------------- PWL_FLOATRANGE
18 /* ------------------------------- PWL_FLOATRANGE ------------------------------ - */ 18 * ------------------------------- */
19 19
20 PWL_FLOATRANGE::PWL_FLOATRANGE() 20 PWL_FLOATRANGE::PWL_FLOATRANGE() {
21 { 21 Default();
22 Default(); 22 }
23 } 23
24 24 PWL_FLOATRANGE::PWL_FLOATRANGE(FX_FLOAT min, FX_FLOAT max) {
25 PWL_FLOATRANGE::PWL_FLOATRANGE(FX_FLOAT min,FX_FLOAT max) 25 Set(min, max);
26 { 26 }
27 Set(min,max); 27
28 } 28 void PWL_FLOATRANGE::Default() {
29 29 fMin = 0;
30 void PWL_FLOATRANGE::Default() 30 fMax = 0;
31 { 31 }
32 fMin = 0; 32
33 fMax = 0; 33 void PWL_FLOATRANGE::Set(FX_FLOAT min, FX_FLOAT max) {
34 } 34 if (min > max) {
35 35 fMin = max;
36 void PWL_FLOATRANGE::Set(FX_FLOAT min,FX_FLOAT max) 36 fMax = min;
37 { 37 } else {
38 if (min > max) 38 fMin = min;
39 { 39 fMax = max;
40 fMin = max; 40 }
41 fMax = min; 41 }
42 } 42
43 else 43 FX_BOOL PWL_FLOATRANGE::In(FX_FLOAT x) const {
44 { 44 return (IsFloatBigger(x, fMin) || IsFloatEqual(x, fMin)) &&
45 fMin = min; 45 (IsFloatSmaller(x, fMax) || IsFloatEqual(x, fMax));
46 fMax = max; 46 }
47 } 47
48 } 48 FX_FLOAT PWL_FLOATRANGE::GetWidth() const {
49 49 return fMax - fMin;
50 FX_BOOL PWL_FLOATRANGE::In(FX_FLOAT x) const 50 }
51 { 51
52 return (IsFloatBigger(x,fMin) || IsFloatEqual(x, fMin)) && 52 /* ------------------------------- PWL_SCROLL_PRIVATEDATA
53 (IsFloatSmaller(x, fMax) || IsFloatEqual(x, fMax)); 53 * ------------------------------- */
54 } 54
55 55 PWL_SCROLL_PRIVATEDATA::PWL_SCROLL_PRIVATEDATA() {
56 FX_FLOAT PWL_FLOATRANGE::GetWidth() const 56 Default();
57 { 57 }
58 return fMax - fMin; 58
59 } 59 void PWL_SCROLL_PRIVATEDATA::Default() {
60 60 ScrollRange.Default();
61 /* ------------------------------- PWL_SCROLL_PRIVATEDATA ---------------------- --------- */ 61 fScrollPos = ScrollRange.fMin;
62 62 fClientWidth = 0;
63 PWL_SCROLL_PRIVATEDATA::PWL_SCROLL_PRIVATEDATA() 63 fBigStep = 10;
64 { 64 fSmallStep = 1;
65 Default(); 65 }
66 } 66
67 67 void PWL_SCROLL_PRIVATEDATA::SetScrollRange(FX_FLOAT min, FX_FLOAT max) {
68 void PWL_SCROLL_PRIVATEDATA::Default() 68 ScrollRange.Set(min, max);
69 { 69
70 ScrollRange.Default(); 70 if (IsFloatSmaller(fScrollPos, ScrollRange.fMin))
71 fScrollPos = ScrollRange.fMin; 71 fScrollPos = ScrollRange.fMin;
72 fClientWidth = 0; 72 if (IsFloatBigger(fScrollPos, ScrollRange.fMax))
73 fBigStep = 10; 73 fScrollPos = ScrollRange.fMax;
74 fSmallStep = 1; 74 }
75 } 75
76 76 void PWL_SCROLL_PRIVATEDATA::SetClientWidth(FX_FLOAT width) {
77 void PWL_SCROLL_PRIVATEDATA::SetScrollRange(FX_FLOAT min,FX_FLOAT max) 77 fClientWidth = width;
78 { 78 }
79 ScrollRange.Set(min,max); 79
80 80 void PWL_SCROLL_PRIVATEDATA::SetSmallStep(FX_FLOAT step) {
81 if (IsFloatSmaller(fScrollPos, ScrollRange.fMin)) 81 fSmallStep = step;
82 fScrollPos = ScrollRange.fMin; 82 }
83 if (IsFloatBigger(fScrollPos, ScrollRange.fMax)) 83
84 fScrollPos = ScrollRange.fMax; 84 void PWL_SCROLL_PRIVATEDATA::SetBigStep(FX_FLOAT step) {
85 } 85 fBigStep = step;
86 86 }
87 void PWL_SCROLL_PRIVATEDATA::SetClientWidth(FX_FLOAT width) 87
88 { 88 FX_BOOL PWL_SCROLL_PRIVATEDATA::SetPos(FX_FLOAT pos) {
89 fClientWidth = width; 89 if (ScrollRange.In(pos)) {
90 } 90 fScrollPos = pos;
91 91 return TRUE;
92 void PWL_SCROLL_PRIVATEDATA::SetSmallStep(FX_FLOAT step) 92 }
93 { 93 return FALSE;
94 fSmallStep = step; 94 }
95 } 95
96 96 void PWL_SCROLL_PRIVATEDATA::AddSmall() {
97 void PWL_SCROLL_PRIVATEDATA::SetBigStep(FX_FLOAT step) 97 if (!SetPos(fScrollPos + fSmallStep))
98 { 98 SetPos(ScrollRange.fMax);
99 fBigStep = step; 99 }
100 } 100
101 101 void PWL_SCROLL_PRIVATEDATA::SubSmall() {
102 FX_BOOL PWL_SCROLL_PRIVATEDATA::SetPos(FX_FLOAT pos) 102 if (!SetPos(fScrollPos - fSmallStep))
103 { 103 SetPos(ScrollRange.fMin);
104 if (ScrollRange.In(pos)) 104 }
105 { 105
106 fScrollPos = pos; 106 void PWL_SCROLL_PRIVATEDATA::AddBig() {
107 return TRUE; 107 if (!SetPos(fScrollPos + fBigStep))
108 } 108 SetPos(ScrollRange.fMax);
109 return FALSE; 109 }
110 } 110
111 111 void PWL_SCROLL_PRIVATEDATA::SubBig() {
112 void PWL_SCROLL_PRIVATEDATA::AddSmall() 112 if (!SetPos(fScrollPos - fBigStep))
113 { 113 SetPos(ScrollRange.fMin);
114 if (!SetPos(fScrollPos + fSmallStep)) 114 }
115 SetPos(ScrollRange.fMax); 115
116 } 116 /* ------------------------------- CPWL_SBButton -------------------------------
117 117 */
118 void PWL_SCROLL_PRIVATEDATA::SubSmall() 118
119 { 119 CPWL_SBButton::CPWL_SBButton(PWL_SCROLLBAR_TYPE eScrollBarType,
120 if (!SetPos(fScrollPos - fSmallStep)) 120 PWL_SBBUTTON_TYPE eButtonType) {
121 SetPos(ScrollRange.fMin); 121 m_eScrollBarType = eScrollBarType;
122 } 122 m_eSBButtonType = eButtonType;
123 123
124 void PWL_SCROLL_PRIVATEDATA::AddBig() 124 m_bMouseDown = FALSE;
125 { 125 }
126 if (!SetPos(fScrollPos + fBigStep)) 126
127 SetPos(ScrollRange.fMax); 127 CPWL_SBButton::~CPWL_SBButton() {
128 } 128 }
129 129
130 void PWL_SCROLL_PRIVATEDATA::SubBig() 130 CFX_ByteString CPWL_SBButton::GetClassName() const {
131 { 131 return "CPWL_SBButton";
132 if (!SetPos(fScrollPos - fBigStep)) 132 }
133 SetPos(ScrollRange.fMin); 133
134 } 134 void CPWL_SBButton::OnCreate(PWL_CREATEPARAM& cp) {
135 135 cp.eCursorType = FXCT_ARROW;
136 /* ------------------------------- CPWL_SBButton ------------------------------- */ 136 }
137 137
138 CPWL_SBButton::CPWL_SBButton(PWL_SCROLLBAR_TYPE eScrollBarType,PWL_SBBUTTON_TYPE eButtonType) 138 void CPWL_SBButton::GetThisAppearanceStream(CFX_ByteTextBuf& sAppStream) {
139 { 139 CPWL_Wnd::GetThisAppearanceStream(sAppStream);
140 m_eScrollBarType = eScrollBarType; 140
141 m_eSBButtonType = eButtonType; 141 if (!IsVisible())
142 142 return;
143 m_bMouseDown = FALSE; 143
144 } 144 CFX_ByteTextBuf sButton;
145 145
146 CPWL_SBButton::~CPWL_SBButton() 146 CPDF_Rect rectWnd = GetWindowRect();
147 { 147
148 148 if (rectWnd.IsEmpty())
149 } 149 return;
150 150
151 CFX_ByteString CPWL_SBButton::GetClassName() const 151 sAppStream << "q\n";
152 { 152
153 return "CPWL_SBButton"; 153 CPDF_Point ptCenter = this->GetCenterPoint();
154 } 154
155 155 switch (this->m_eScrollBarType) {
156 void CPWL_SBButton::OnCreate(PWL_CREATEPARAM & cp) 156 case SBT_HSCROLL:
157 { 157 switch (this->m_eSBButtonType) {
158 cp.eCursorType = FXCT_ARROW; 158 case PSBT_MIN: {
159 } 159 CPDF_Point pt1(ptCenter.x - PWL_TRIANGLE_HALFLEN * 0.5f, ptCenter.y);
160 160 CPDF_Point pt2(ptCenter.x + PWL_TRIANGLE_HALFLEN * 0.5f,
161 void CPWL_SBButton::GetThisAppearanceStream(CFX_ByteTextBuf & sAppStream) 161 ptCenter.y + PWL_TRIANGLE_HALFLEN);
162 { 162 CPDF_Point pt3(ptCenter.x + PWL_TRIANGLE_HALFLEN * 0.5f,
163 CPWL_Wnd::GetThisAppearanceStream(sAppStream); 163 ptCenter.y - PWL_TRIANGLE_HALFLEN);
164 164
165 if (!IsVisible()) return; 165 if (rectWnd.right - rectWnd.left > PWL_TRIANGLE_HALFLEN * 2 &&
166 166 rectWnd.top - rectWnd.bottom > PWL_TRIANGLE_HALFLEN) {
167 CFX_ByteTextBuf sButton; 167 sButton << "0 g\n";
168 168 sButton << pt1.x << " " << pt1.y << " m\n";
169 CPDF_Rect rectWnd = GetWindowRect(); 169 sButton << pt2.x << " " << pt2.y << " l\n";
170 170 sButton << pt3.x << " " << pt3.y << " l\n";
171 if (rectWnd.IsEmpty()) return; 171 sButton << pt1.x << " " << pt1.y << " l f\n";
172 172
173 sAppStream << "q\n"; 173 sAppStream << sButton;
174 174 }
175 CPDF_Point ptCenter = this->GetCenterPoint(); 175 } break;
176 176 case PSBT_MAX: {
177 switch (this->m_eScrollBarType) 177 CPDF_Point pt1(ptCenter.x + PWL_TRIANGLE_HALFLEN * 0.5f, ptCenter.y);
178 { 178 CPDF_Point pt2(ptCenter.x - PWL_TRIANGLE_HALFLEN * 0.5f,
179 case SBT_HSCROLL: 179 ptCenter.y + PWL_TRIANGLE_HALFLEN);
180 switch (this->m_eSBButtonType) 180 CPDF_Point pt3(ptCenter.x - PWL_TRIANGLE_HALFLEN * 0.5f,
181 { 181 ptCenter.y - PWL_TRIANGLE_HALFLEN);
182 case PSBT_MIN: 182
183 { 183 if (rectWnd.right - rectWnd.left > PWL_TRIANGLE_HALFLEN * 2 &&
184 CPDF_Point pt1(ptCenter.x - PWL_ TRIANGLE_HALFLEN * 0.5f,ptCenter.y); 184 rectWnd.top - rectWnd.bottom > PWL_TRIANGLE_HALFLEN) {
185 CPDF_Point pt2(ptCenter.x + PWL_ TRIANGLE_HALFLEN * 0.5f,ptCenter.y + PWL_TRIANGLE_HALFLEN); 185 sButton << "0 g\n";
186 CPDF_Point pt3(ptCenter.x + PWL_ TRIANGLE_HALFLEN * 0.5f,ptCenter.y - PWL_TRIANGLE_HALFLEN); 186 sButton << pt1.x << " " << pt1.y << " m\n";
187 187 sButton << pt2.x << " " << pt2.y << " l\n";
188 if (rectWnd.right - rectWnd.left > PWL_TRIANGLE_HALFLEN * 2 && 188 sButton << pt3.x << " " << pt3.y << " l\n";
189 rectWnd.top - rectWnd.bo ttom > PWL_TRIANGLE_HALFLEN ) 189 sButton << pt1.x << " " << pt1.y << " l f\n";
190 { 190
191 sButton << "0 g\n"; 191 sAppStream << sButton;
192 sButton << pt1.x << " " << pt1.y << " m\n"; 192 }
193 sButton << pt2.x << " " << pt2.y << " l\n"; 193 } break;
194 sButton << pt3.x << " " << pt3.y << " l\n"; 194 default:
195 sButton << pt1.x << " " << pt1.y << " l f\n"; 195 break;
196 196 }
197 sAppStream << sButton; 197 break;
198 } 198 case SBT_VSCROLL:
199 } 199 switch (this->m_eSBButtonType) {
200 break; 200 case PSBT_MIN: {
201 case PSBT_MAX: 201 CPDF_Point pt1(ptCenter.x - PWL_TRIANGLE_HALFLEN,
202 { 202 ptCenter.y - PWL_TRIANGLE_HALFLEN * 0.5f);
203 CPDF_Point pt1(ptCenter.x + PWL_ TRIANGLE_HALFLEN * 0.5f,ptCenter.y); 203 CPDF_Point pt2(ptCenter.x + PWL_TRIANGLE_HALFLEN,
204 CPDF_Point pt2(ptCenter.x - PWL_ TRIANGLE_HALFLEN * 0.5f,ptCenter.y + PWL_TRIANGLE_HALFLEN); 204 ptCenter.y - PWL_TRIANGLE_HALFLEN * 0.5f);
205 CPDF_Point pt3(ptCenter.x - PWL_ TRIANGLE_HALFLEN * 0.5f,ptCenter.y - PWL_TRIANGLE_HALFLEN); 205 CPDF_Point pt3(ptCenter.x, ptCenter.y + PWL_TRIANGLE_HALFLEN * 0.5f);
206 206
207 if (rectWnd.right - rectWnd.left > PWL_TRIANGLE_HALFLEN * 2 && 207 if (rectWnd.right - rectWnd.left > PWL_TRIANGLE_HALFLEN * 2 &&
208 rectWnd.top - rectWnd.bo ttom > PWL_TRIANGLE_HALFLEN ) 208 rectWnd.top - rectWnd.bottom > PWL_TRIANGLE_HALFLEN) {
209 { 209 sButton << "0 g\n";
210 sButton << "0 g\n"; 210 sButton << pt1.x << " " << pt1.y << " m\n";
211 sButton << pt1.x << " " << pt1.y << " m\n"; 211 sButton << pt2.x << " " << pt2.y << " l\n";
212 sButton << pt2.x << " " << pt2.y << " l\n"; 212 sButton << pt3.x << " " << pt3.y << " l\n";
213 sButton << pt3.x << " " << pt3.y << " l\n"; 213 sButton << pt1.x << " " << pt1.y << " l f\n";
214 sButton << pt1.x << " " << pt1.y << " l f\n"; 214
215 215 sAppStream << sButton;
216 sAppStream << sButton; 216 }
217 } 217 } break;
218 } 218 case PSBT_MAX: {
219 break; 219 CPDF_Point pt1(ptCenter.x - PWL_TRIANGLE_HALFLEN,
220 default: 220 ptCenter.y + PWL_TRIANGLE_HALFLEN * 0.5f);
221 break; 221 CPDF_Point pt2(ptCenter.x + PWL_TRIANGLE_HALFLEN,
222 } 222 ptCenter.y + PWL_TRIANGLE_HALFLEN * 0.5f);
223 break; 223 CPDF_Point pt3(ptCenter.x, ptCenter.y - PWL_TRIANGLE_HALFLEN * 0.5f);
224 case SBT_VSCROLL: 224
225 switch(this->m_eSBButtonType) 225 if (rectWnd.right - rectWnd.left > PWL_TRIANGLE_HALFLEN * 2 &&
226 { 226 rectWnd.top - rectWnd.bottom > PWL_TRIANGLE_HALFLEN) {
227 case PSBT_MIN: 227 sButton << "0 g\n";
228 { 228 sButton << pt1.x << " " << pt1.y << " m\n";
229 CPDF_Point pt1(ptCenter.x - PWL_ TRIANGLE_HALFLEN,ptCenter.y - PWL_TRIANGLE_HALFLEN * 0.5f); 229 sButton << pt2.x << " " << pt2.y << " l\n";
230 CPDF_Point pt2(ptCenter.x + PWL_ TRIANGLE_HALFLEN,ptCenter.y - PWL_TRIANGLE_HALFLEN * 0.5f); 230 sButton << pt3.x << " " << pt3.y << " l\n";
231 CPDF_Point pt3(ptCenter.x,ptCent er.y + PWL_TRIANGLE_HALFLEN * 0.5f); 231 sButton << pt1.x << " " << pt1.y << " l f\n";
232 232
233 if (rectWnd.right - rectWnd.left > PWL_TRIANGLE_HALFLEN * 2 && 233 sAppStream << sButton;
234 rectWnd.top - rectWnd.bo ttom > PWL_TRIANGLE_HALFLEN ) 234 }
235 { 235 } break;
236 sButton << "0 g\n"; 236 default:
237 sButton << pt1.x << " " << pt1.y << " m\n"; 237 break;
238 sButton << pt2.x << " " << pt2.y << " l\n"; 238 }
239 sButton << pt3.x << " " << pt3.y << " l\n"; 239 break;
240 sButton << pt1.x << " " << pt1.y << " l f\n"; 240 default:
241 241 break;
242 sAppStream << sButton; 242 }
243 } 243
244 } 244 sAppStream << "Q\n";
245 break; 245 }
246 case PSBT_MAX: 246
247 { 247 void CPWL_SBButton::DrawThisAppearance(CFX_RenderDevice* pDevice,
248 CPDF_Point pt1(ptCenter.x - PWL_ TRIANGLE_HALFLEN,ptCenter.y + PWL_TRIANGLE_HALFLEN * 0.5f); 248 CPDF_Matrix* pUser2Device) {
249 CPDF_Point pt2(ptCenter.x + PWL_ TRIANGLE_HALFLEN,ptCenter.y + PWL_TRIANGLE_HALFLEN * 0.5f); 249 if (!IsVisible())
250 CPDF_Point pt3(ptCenter.x,ptCent er.y - PWL_TRIANGLE_HALFLEN * 0.5f); 250 return;
251 251
252 if (rectWnd.right - rectWnd.left > PWL_TRIANGLE_HALFLEN * 2 && 252 CPDF_Rect rectWnd = GetWindowRect();
253 rectWnd.top - rectWnd.bo ttom > PWL_TRIANGLE_HALFLEN ) 253 if (rectWnd.IsEmpty())
254 { 254 return;
255 sButton << "0 g\n"; 255
256 sButton << pt1.x << " " << pt1.y << " m\n"; 256 CPDF_Point ptCenter = this->GetCenterPoint();
257 sButton << pt2.x << " " << pt2.y << " l\n"; 257 FX_INT32 nTransparancy = this->GetTransparency();
258 sButton << pt3.x << " " << pt3.y << " l\n"; 258
259 sButton << pt1.x << " " << pt1.y << " l f\n"; 259 switch (this->m_eScrollBarType) {
260 260 case SBT_HSCROLL:
261 sAppStream << sButton; 261 CPWL_Wnd::DrawThisAppearance(pDevice, pUser2Device);
262 } 262 switch (this->m_eSBButtonType) {
263 } 263 case PSBT_MIN: {
264 break; 264 CPDF_Point pt1(ptCenter.x - PWL_TRIANGLE_HALFLEN * 0.5f, ptCenter.y);
265 default: 265 CPDF_Point pt2(ptCenter.x + PWL_TRIANGLE_HALFLEN * 0.5f,
266 break; 266 ptCenter.y + PWL_TRIANGLE_HALFLEN);
267 } 267 CPDF_Point pt3(ptCenter.x + PWL_TRIANGLE_HALFLEN * 0.5f,
268 break; 268 ptCenter.y - PWL_TRIANGLE_HALFLEN);
269 default: 269
270 break; 270 if (rectWnd.right - rectWnd.left > PWL_TRIANGLE_HALFLEN * 2 &&
271 } 271 rectWnd.top - rectWnd.bottom > PWL_TRIANGLE_HALFLEN) {
272 272 CFX_PathData path;
273 sAppStream << "Q\n"; 273
274 } 274 path.SetPointCount(4);
275 275 path.SetPoint(0, pt1.x, pt1.y, FXPT_MOVETO);
276 void CPWL_SBButton::DrawThisAppearance(CFX_RenderDevice* pDevice, CPDF_Matrix* p User2Device) 276 path.SetPoint(1, pt2.x, pt2.y, FXPT_LINETO);
277 { 277 path.SetPoint(2, pt3.x, pt3.y, FXPT_LINETO);
278 if (!IsVisible()) return; 278 path.SetPoint(3, pt1.x, pt1.y, FXPT_LINETO);
279 279
280 CPDF_Rect rectWnd = GetWindowRect(); 280 pDevice->DrawPath(&path,
281 if (rectWnd.IsEmpty()) return; 281 pUser2Device,
282 282 NULL,
283 CPDF_Point ptCenter = this->GetCenterPoint(); 283 CPWL_Utils::PWLColorToFXColor(
284 FX_INT32 nTransparancy = this->GetTransparency(); 284 PWL_DEFAULT_BLACKCOLOR, nTransparancy),
285 285 0,
286 switch (this->m_eScrollBarType) 286 FXFILL_ALTERNATE);
287 { 287 }
288 case SBT_HSCROLL: 288 } break;
289 CPWL_Wnd::DrawThisAppearance(pDevice,pUser2Device); 289 case PSBT_MAX: {
290 switch (this->m_eSBButtonType) 290 CPDF_Point pt1(ptCenter.x + PWL_TRIANGLE_HALFLEN * 0.5f, ptCenter.y);
291 { 291 CPDF_Point pt2(ptCenter.x - PWL_TRIANGLE_HALFLEN * 0.5f,
292 case PSBT_MIN: 292 ptCenter.y + PWL_TRIANGLE_HALFLEN);
293 { 293 CPDF_Point pt3(ptCenter.x - PWL_TRIANGLE_HALFLEN * 0.5f,
294 CPDF_Point pt1(ptCenter.x - PWL_TRIANGLE_HALFLEN * 0.5f,ptCenter.y); 294 ptCenter.y - PWL_TRIANGLE_HALFLEN);
295 CPDF_Point pt2(ptCenter.x + PWL_TRIANGLE_HALFLEN * 0.5f,ptCenter.y + PWL_TRIANGLE_HALFLEN); 295
296 CPDF_Point pt3(ptCenter.x + PWL_TRIANGLE_HALFLEN * 0.5f,ptCenter.y - PWL_TRIANGLE_HALFLEN); 296 if (rectWnd.right - rectWnd.left > PWL_TRIANGLE_HALFLEN * 2 &&
297 297 rectWnd.top - rectWnd.bottom > PWL_TRIANGLE_HALFLEN) {
298 if (rectWnd.right - rectWnd.left > PWL_TRIANGLE_ HALFLEN * 2 && 298 CFX_PathData path;
299 rectWnd.top - rectWnd.bottom > PWL_TRIAN GLE_HALFLEN ) 299
300 { 300 path.SetPointCount(4);
301 CFX_PathData path; 301 path.SetPoint(0, pt1.x, pt1.y, FXPT_MOVETO);
302 302 path.SetPoint(1, pt2.x, pt2.y, FXPT_LINETO);
303 path.SetPointCount(4); 303 path.SetPoint(2, pt3.x, pt3.y, FXPT_LINETO);
304 path.SetPoint(0, pt1.x, pt1.y, FXPT_MOVE TO); 304 path.SetPoint(3, pt1.x, pt1.y, FXPT_LINETO);
305 path.SetPoint(1, pt2.x, pt2.y, FXPT_LINE TO); 305
306 path.SetPoint(2, pt3.x, pt3.y, FXPT_LINE TO); 306 pDevice->DrawPath(&path,
307 path.SetPoint(3, pt1.x, pt1.y, FXPT_LINE TO); 307 pUser2Device,
308 308 NULL,
309 pDevice->DrawPath(&path, pUser2Device, N ULL, 309 CPWL_Utils::PWLColorToFXColor(
310 CPWL_Utils::PWLColorToFXColor(PW L_DEFAULT_BLACKCOLOR,nTransparancy), 310 PWL_DEFAULT_BLACKCOLOR, nTransparancy),
311 0, FXFILL_ALTERNATE); 311 0,
312 } 312 FXFILL_ALTERNATE);
313 } 313 }
314 break; 314 } break;
315 case PSBT_MAX: 315 default:
316 { 316 break;
317 CPDF_Point pt1(ptCenter.x + PWL_TRIANGLE_HALFLEN * 0.5f,ptCenter.y); 317 }
318 CPDF_Point pt2(ptCenter.x - PWL_TRIANGLE_HALFLEN * 0.5f,ptCenter.y + PWL_TRIANGLE_HALFLEN); 318 break;
319 CPDF_Point pt3(ptCenter.x - PWL_TRIANGLE_HALFLEN * 0.5f,ptCenter.y - PWL_TRIANGLE_HALFLEN); 319 case SBT_VSCROLL:
320 320 switch (this->m_eSBButtonType) {
321 if (rectWnd.right - rectWnd.left > PWL_TRIANGLE_ HALFLEN * 2 && 321 case PSBT_MIN: {
322 rectWnd.top - rectWnd.bottom > PWL_TRIAN GLE_HALFLEN ) 322 // draw border
323 { 323 CPDF_Rect rcDraw = rectWnd;
324 CFX_PathData path; 324 CPWL_Utils::DrawStrokeRect(pDevice,
325 325 pUser2Device,
326 path.SetPointCount(4); 326 rcDraw,
327 path.SetPoint(0, pt1.x, pt1.y, FXPT_MOVE TO); 327 ArgbEncode(nTransparancy, 100, 100, 100),
328 path.SetPoint(1, pt2.x, pt2.y, FXPT_LINE TO); 328 0.0f);
329 path.SetPoint(2, pt3.x, pt3.y, FXPT_LINE TO); 329
330 path.SetPoint(3, pt1.x, pt1.y, FXPT_LINE TO); 330 // draw inner border
331 331 rcDraw = CPWL_Utils::DeflateRect(rectWnd, 0.5f);
332 pDevice->DrawPath(&path, pUser2Device, N ULL, 332 CPWL_Utils::DrawStrokeRect(pDevice,
333 CPWL_Utils::PWLColorToFXColor(PW L_DEFAULT_BLACKCOLOR,nTransparancy), 333 pUser2Device,
334 0, FXFILL_ALTERNATE); 334 rcDraw,
335 } 335 ArgbEncode(nTransparancy, 255, 255, 255),
336 } 336 1.0f);
337 break; 337
338 default: 338 // draw background
339 break; 339
340 } 340 rcDraw = CPWL_Utils::DeflateRect(rectWnd, 1.0f);
341 break; 341
342 case SBT_VSCROLL: 342 if (this->IsEnabled())
343 switch(this->m_eSBButtonType) 343 CPWL_Utils::DrawShadow(pDevice,
344 { 344 pUser2Device,
345 case PSBT_MIN: 345 TRUE,
346 { 346 FALSE,
347 //draw border 347 rcDraw,
348 CPDF_Rect rcDraw = rectWnd; 348 nTransparancy,
349 CPWL_Utils::DrawStrokeRect(pDevice, pUser2Device , rcDraw, 349 80,
350 ArgbEncode(nTransparancy,100,100,100),0. 0f); 350 220);
351 351 else
352 //draw inner border 352 CPWL_Utils::DrawFillRect(
353 rcDraw = CPWL_Utils::DeflateRect(rectWnd,0.5f); 353 pDevice, pUser2Device, rcDraw, ArgbEncode(255, 255, 255, 255));
354 CPWL_Utils::DrawStrokeRect(pDevice, pUser2Device , rcDraw, 354
355 ArgbEncode(nTransparancy,255,255,255),1. 0f); 355 // draw arrow
356 356
357 //draw background 357 if (rectWnd.top - rectWnd.bottom > 6.0f) {
358 358 FX_FLOAT fX = rectWnd.left + 1.5f;
359 rcDraw = CPWL_Utils::DeflateRect(rectWnd,1.0f); 359 FX_FLOAT fY = rectWnd.bottom;
360 360 CPDF_Point pts[7] = { CPDF_Point(fX + 2.5f, fY + 4.0f),
361 if (this->IsEnabled()) 361 CPDF_Point(fX + 2.5f, fY + 3.0f),
362 CPWL_Utils::DrawShadow(pDevice, pUser2De vice, TRUE, FALSE, rcDraw, nTransparancy, 80, 220); 362 CPDF_Point(fX + 4.5f, fY + 5.0f),
363 else 363 CPDF_Point(fX + 6.5f, fY + 3.0f),
364 CPWL_Utils::DrawFillRect(pDevice, pUser2 Device, rcDraw, ArgbEncode(255,255,255,255)); 364 CPDF_Point(fX + 6.5f, fY + 4.0f),
365 365 CPDF_Point(fX + 4.5f, fY + 6.0f),
366 //draw arrow 366 CPDF_Point(fX + 2.5f, fY + 4.0f) };
367 367
368 if (rectWnd.top - rectWnd.bottom > 6.0f ) 368 if (this->IsEnabled())
369 { 369 CPWL_Utils::DrawFillArea(
370 FX_FLOAT fX = rectWnd.left + 1.5f; 370 pDevice,
371 FX_FLOAT fY = rectWnd.bottom; 371 pUser2Device,
372 CPDF_Point pts[7] = { 372 pts,
373 CPDF_Point(fX+2. 5f, fY+4.0f), 373 7,
374 CPDF_Point(fX+2. 5f, fY+3.0f), 374 ArgbEncode(nTransparancy, 255, 255, 255));
375 CPDF_Point(fX+4. 5f, fY+5.0f), 375 else
376 CPDF_Point(fX+6. 5f, fY+3.0f), 376 CPWL_Utils::DrawFillArea(pDevice,
377 CPDF_Point(fX+6. 5f, fY+4.0f), 377 pUser2Device,
378 CPDF_Point(fX+4. 5f, fY+6.0f), 378 pts,
379 CPDF_Point(fX+2. 5f, fY+4.0f)}; 379 7,
380 380 CPWL_Utils::PWLColorToFXColor(
381 381 PWL_DEFAULT_HEAVYGRAYCOLOR, 255));
382 if (this->IsEnabled()) 382 }
383 CPWL_Utils::DrawFillArea(pDevice , pUser2Device, pts, 7, ArgbEncode(nTransparancy,255,255,255)); 383 } break;
384 else 384 case PSBT_MAX: {
385 CPWL_Utils::DrawFillArea(pDevice , pUser2Device, pts, 7, 385 // draw border
386 CPWL_Utils::PWLColorToFX Color(PWL_DEFAULT_HEAVYGRAYCOLOR,255)); 386 CPDF_Rect rcDraw = rectWnd;
387 } 387 CPWL_Utils::DrawStrokeRect(pDevice,
388 } 388 pUser2Device,
389 break; 389 rcDraw,
390 case PSBT_MAX: 390 ArgbEncode(nTransparancy, 100, 100, 100),
391 { 391 0.0f);
392 //draw border 392
393 CPDF_Rect rcDraw = rectWnd; 393 // draw inner border
394 CPWL_Utils::DrawStrokeRect(pDevice, pUser2Device , rcDraw, 394 rcDraw = CPWL_Utils::DeflateRect(rectWnd, 0.5f);
395 ArgbEncode(nTransparancy,100,100,100),0. 0f); 395 CPWL_Utils::DrawStrokeRect(pDevice,
396 396 pUser2Device,
397 //draw inner border 397 rcDraw,
398 rcDraw = CPWL_Utils::DeflateRect(rectWnd,0.5f); 398 ArgbEncode(nTransparancy, 255, 255, 255),
399 CPWL_Utils::DrawStrokeRect(pDevice, pUser2Device , rcDraw, 399 1.0f);
400 ArgbEncode(nTransparancy,255,255,255),1. 0f); 400
401 401 // draw background
402 //draw background 402 rcDraw = CPWL_Utils::DeflateRect(rectWnd, 1.0f);
403 rcDraw = CPWL_Utils::DeflateRect(rectWnd,1.0f); 403 if (this->IsEnabled())
404 if (this->IsEnabled()) 404 CPWL_Utils::DrawShadow(pDevice,
405 CPWL_Utils::DrawShadow(pDevice, pUser2De vice, TRUE, FALSE, rcDraw, nTransparancy, 80, 220); 405 pUser2Device,
406 else 406 TRUE,
407 CPWL_Utils::DrawFillRect(pDevice, pUser2 Device, rcDraw, ArgbEncode(255,255,255,255)); 407 FALSE,
408 408 rcDraw,
409 //draw arrow 409 nTransparancy,
410 410 80,
411 if (rectWnd.top - rectWnd.bottom > 6.0f ) 411 220);
412 { 412 else
413 FX_FLOAT fX = rectWnd.left + 1.5f; 413 CPWL_Utils::DrawFillRect(
414 FX_FLOAT fY = rectWnd.bottom; 414 pDevice, pUser2Device, rcDraw, ArgbEncode(255, 255, 255, 255));
415 415
416 CPDF_Point pts[7] = { 416 // draw arrow
417 CPDF_Point(fX+2. 5f, fY+5.0f), 417
418 CPDF_Point(fX+2. 5f, fY+6.0f), 418 if (rectWnd.top - rectWnd.bottom > 6.0f) {
419 CPDF_Point(fX+4. 5f, fY+4.0f), 419 FX_FLOAT fX = rectWnd.left + 1.5f;
420 CPDF_Point(fX+6. 5f, fY+6.0f), 420 FX_FLOAT fY = rectWnd.bottom;
421 CPDF_Point(fX+6. 5f, fY+5.0f), 421
422 CPDF_Point(fX+4. 5f, fY+3.0f), 422 CPDF_Point pts[7] = { CPDF_Point(fX + 2.5f, fY + 5.0f),
423 CPDF_Point(fX+2. 5f, fY+5.0f)}; 423 CPDF_Point(fX + 2.5f, fY + 6.0f),
424 424 CPDF_Point(fX + 4.5f, fY + 4.0f),
425 425 CPDF_Point(fX + 6.5f, fY + 6.0f),
426 if (this->IsEnabled()) 426 CPDF_Point(fX + 6.5f, fY + 5.0f),
427 CPWL_Utils::DrawFillArea(pDevice , pUser2Device, pts, 7, ArgbEncode(nTransparancy,255,255,255)); 427 CPDF_Point(fX + 4.5f, fY + 3.0f),
428 else 428 CPDF_Point(fX + 2.5f, fY + 5.0f) };
429 CPWL_Utils::DrawFillArea(pDevice , pUser2Device, pts, 7, 429
430 CPWL_Utils::PWLColorToFX Color(PWL_DEFAULT_HEAVYGRAYCOLOR,255)); 430 if (this->IsEnabled())
431 } 431 CPWL_Utils::DrawFillArea(
432 } 432 pDevice,
433 break; 433 pUser2Device,
434 case PSBT_POS: 434 pts,
435 { 435 7,
436 //CPWL_Wnd::DrawThisAppearance(pDevice,pUser2Dev ice); 436 ArgbEncode(nTransparancy, 255, 255, 255));
437 437 else
438 //draw border 438 CPWL_Utils::DrawFillArea(pDevice,
439 CPDF_Rect rcDraw = rectWnd; 439 pUser2Device,
440 CPWL_Utils::DrawStrokeRect(pDevice, pUser2Device , rcDraw, 440 pts,
441 ArgbEncode(nTransparancy,100,100,100),0. 0f); 441 7,
442 442 CPWL_Utils::PWLColorToFXColor(
443 //draw inner border 443 PWL_DEFAULT_HEAVYGRAYCOLOR, 255));
444 rcDraw = CPWL_Utils::DeflateRect(rectWnd,0.5f); 444 }
445 CPWL_Utils::DrawStrokeRect(pDevice, pUser2Device , rcDraw, 445 } break;
446 ArgbEncode(nTransparancy,255,255,255),1. 0f); 446 case PSBT_POS: {
447 447 // CPWL_Wnd::DrawThisAppearance(pDevice,pUser2Device);
448 if (this->IsEnabled()) 448
449 { 449 // draw border
450 //draw shadow effect 450 CPDF_Rect rcDraw = rectWnd;
451 451 CPWL_Utils::DrawStrokeRect(pDevice,
452 CPDF_Point ptTop = CPDF_Point(rectWnd.le ft,rectWnd.top-1.0f); 452 pUser2Device,
453 CPDF_Point ptBottom = CPDF_Point(rectWnd .left,rectWnd.bottom+1.0f); 453 rcDraw,
454 454 ArgbEncode(nTransparancy, 100, 100, 100),
455 ptTop.x += 1.5f; 455 0.0f);
456 ptBottom.x += 1.5f; 456
457 457 // draw inner border
458 CPWL_Utils::DrawStrokeLine(pDevice, pUse r2Device, ptTop, ptBottom, 458 rcDraw = CPWL_Utils::DeflateRect(rectWnd, 0.5f);
459 ArgbEncode(nTransparancy,210,210 ,210),1.0f); 459 CPWL_Utils::DrawStrokeRect(pDevice,
460 460 pUser2Device,
461 ptTop.x += 1.0f; 461 rcDraw,
462 ptBottom.x += 1.0f; 462 ArgbEncode(nTransparancy, 255, 255, 255),
463 463 1.0f);
464 CPWL_Utils::DrawStrokeLine(pDevice, pUse r2Device, ptTop, ptBottom, 464
465 ArgbEncode(nTransparancy,220,220 ,220),1.0f); 465 if (this->IsEnabled()) {
466 466 // draw shadow effect
467 ptTop.x += 1.0f; 467
468 ptBottom.x += 1.0f; 468 CPDF_Point ptTop = CPDF_Point(rectWnd.left, rectWnd.top - 1.0f);
469 469 CPDF_Point ptBottom =
470 CPWL_Utils::DrawStrokeLine(pDevice, pUse r2Device, ptTop, ptBottom, 470 CPDF_Point(rectWnd.left, rectWnd.bottom + 1.0f);
471 ArgbEncode(nTransparancy,240,240 ,240),1.0f); 471
472 472 ptTop.x += 1.5f;
473 ptTop.x += 1.0f; 473 ptBottom.x += 1.5f;
474 ptBottom.x += 1.0f; 474
475 475 CPWL_Utils::DrawStrokeLine(pDevice,
476 CPWL_Utils::DrawStrokeLine(pDevice, pUse r2Device, ptTop, ptBottom, 476 pUser2Device,
477 ArgbEncode(nTransparancy,240,240 ,240),1.0f); 477 ptTop,
478 478 ptBottom,
479 ptTop.x += 1.0f; 479 ArgbEncode(nTransparancy, 210, 210, 210),
480 ptBottom.x += 1.0f; 480 1.0f);
481 481
482 CPWL_Utils::DrawStrokeLine(pDevice, pUse r2Device, ptTop, ptBottom, 482 ptTop.x += 1.0f;
483 ArgbEncode(nTransparancy,210,210 ,210),1.0f); 483 ptBottom.x += 1.0f;
484 484
485 ptTop.x += 1.0f; 485 CPWL_Utils::DrawStrokeLine(pDevice,
486 ptBottom.x += 1.0f; 486 pUser2Device,
487 487 ptTop,
488 CPWL_Utils::DrawStrokeLine(pDevice, pUse r2Device, ptTop, ptBottom, 488 ptBottom,
489 ArgbEncode(nTransparancy,180,180 ,180),1.0f); 489 ArgbEncode(nTransparancy, 220, 220, 220),
490 490 1.0f);
491 ptTop.x += 1.0f; 491
492 ptBottom.x += 1.0f; 492 ptTop.x += 1.0f;
493 493 ptBottom.x += 1.0f;
494 CPWL_Utils::DrawStrokeLine(pDevice, pUse r2Device, ptTop, ptBottom, 494
495 ArgbEncode(nTransparancy,150,150 ,150),1.0f); 495 CPWL_Utils::DrawStrokeLine(pDevice,
496 496 pUser2Device,
497 ptTop.x += 1.0f; 497 ptTop,
498 ptBottom.x += 1.0f; 498 ptBottom,
499 499 ArgbEncode(nTransparancy, 240, 240, 240),
500 CPWL_Utils::DrawStrokeLine(pDevice, pUse r2Device, ptTop, ptBottom, 500 1.0f);
501 ArgbEncode(nTransparancy,150,150 ,150),1.0f); 501
502 502 ptTop.x += 1.0f;
503 ptTop.x += 1.0f; 503 ptBottom.x += 1.0f;
504 ptBottom.x += 1.0f; 504
505 505 CPWL_Utils::DrawStrokeLine(pDevice,
506 CPWL_Utils::DrawStrokeLine(pDevice, pUse r2Device, ptTop, ptBottom, 506 pUser2Device,
507 ArgbEncode(nTransparancy,180,180 ,180),1.0f); 507 ptTop,
508 508 ptBottom,
509 ptTop.x += 1.0f; 509 ArgbEncode(nTransparancy, 240, 240, 240),
510 ptBottom.x += 1.0f; 510 1.0f);
511 511
512 CPWL_Utils::DrawStrokeLine(pDevice, pUse r2Device, ptTop, ptBottom, 512 ptTop.x += 1.0f;
513 ArgbEncode(nTransparancy,210,210 ,210),1.0f); 513 ptBottom.x += 1.0f;
514 } 514
515 else 515 CPWL_Utils::DrawStrokeLine(pDevice,
516 { 516 pUser2Device,
517 CPWL_Utils::DrawFillRect(pDevice, pUser2 Device, rcDraw, ArgbEncode(255,255,255,255)); 517 ptTop,
518 } 518 ptBottom,
519 519 ArgbEncode(nTransparancy, 210, 210, 210),
520 //draw friction 520 1.0f);
521 521
522 if (rectWnd.Height() > 8.0f) 522 ptTop.x += 1.0f;
523 { 523 ptBottom.x += 1.0f;
524 FX_COLORREF crStroke = ArgbEncode(nTrans parancy,120,120,120); 524
525 if (!this->IsEnabled()) 525 CPWL_Utils::DrawStrokeLine(pDevice,
526 crStroke = CPWL_Utils::PWLColorT oFXColor(PWL_DEFAULT_HEAVYGRAYCOLOR,255); 526 pUser2Device,
527 527 ptTop,
528 FX_FLOAT nFrictionWidth = 5.0f; 528 ptBottom,
529 FX_FLOAT nFrictionHeight = 5.5f; 529 ArgbEncode(nTransparancy, 180, 180, 180),
530 530 1.0f);
531 CPDF_Point ptLeft = CPDF_Point(ptCenter. x - nFrictionWidth / 2.0f, ptCenter.y - nFrictionHeight / 2.0f + 0.5f); 531
532 CPDF_Point ptRight = CPDF_Point(ptCenter .x + nFrictionWidth / 2.0f, ptCenter.y - nFrictionHeight / 2.0f + 0.5f); 532 ptTop.x += 1.0f;
533 533 ptBottom.x += 1.0f;
534 CPWL_Utils::DrawStrokeLine(pDevice, pUse r2Device, ptLeft, ptRight, 534
535 crStroke,1.0f); 535 CPWL_Utils::DrawStrokeLine(pDevice,
536 536 pUser2Device,
537 ptLeft.y += 2.0f; 537 ptTop,
538 ptRight.y += 2.0f; 538 ptBottom,
539 539 ArgbEncode(nTransparancy, 150, 150, 150),
540 CPWL_Utils::DrawStrokeLine(pDevice, pUse r2Device, ptLeft, ptRight, 540 1.0f);
541 crStroke,1.0f); 541
542 542 ptTop.x += 1.0f;
543 ptLeft.y += 2.0f; 543 ptBottom.x += 1.0f;
544 ptRight.y += 2.0f; 544
545 545 CPWL_Utils::DrawStrokeLine(pDevice,
546 CPWL_Utils::DrawStrokeLine(pDevice, pUse r2Device, ptLeft, ptRight, 546 pUser2Device,
547 crStroke,1.0f); 547 ptTop,
548 548 ptBottom,
549 /* 549 ArgbEncode(nTransparancy, 150, 150, 150),
550 ptLeft.y += 1.5f; 550 1.0f);
551 ptRight.y += 1.5f; 551
552 552 ptTop.x += 1.0f;
553 CPWL_Utils::DrawStrokeLine(pDevice, pUse r2Device, ptLeft, ptRight, 553 ptBottom.x += 1.0f;
554 ArgbEncode(nTransparancy,150,150 ,150),1.0f); 554
555 */ 555 CPWL_Utils::DrawStrokeLine(pDevice,
556 } 556 pUser2Device,
557 } 557 ptTop,
558 break; 558 ptBottom,
559 default: 559 ArgbEncode(nTransparancy, 180, 180, 180),
560 break; 560 1.0f);
561 } 561
562 break; 562 ptTop.x += 1.0f;
563 default: 563 ptBottom.x += 1.0f;
564 break; 564
565 } 565 CPWL_Utils::DrawStrokeLine(pDevice,
566 } 566 pUser2Device,
567 567 ptTop,
568 FX_BOOL CPWL_SBButton::OnLButtonDown(const CPDF_Point & point, FX_DWORD nFlag) 568 ptBottom,
569 { 569 ArgbEncode(nTransparancy, 210, 210, 210),
570 CPWL_Wnd::OnLButtonDown(point,nFlag); 570 1.0f);
571 571 } else {
572 if (CPWL_Wnd * pParent = GetParentWindow()) 572 CPWL_Utils::DrawFillRect(
573 pParent->OnNotify(this,PNM_LBUTTONDOWN,0,(FX_INTPTR)&point); 573 pDevice, pUser2Device, rcDraw, ArgbEncode(255, 255, 255, 255));
574 574 }
575 m_bMouseDown = TRUE; 575
576 SetCapture(); 576 // draw friction
577 577
578 return TRUE; 578 if (rectWnd.Height() > 8.0f) {
579 } 579 FX_COLORREF crStroke = ArgbEncode(nTransparancy, 120, 120, 120);
580 580 if (!this->IsEnabled())
581 FX_BOOL CPWL_SBButton::OnLButtonUp(const CPDF_Point & point, FX_DWORD nFlag) 581 crStroke = CPWL_Utils::PWLColorToFXColor(
582 { 582 PWL_DEFAULT_HEAVYGRAYCOLOR, 255);
583 CPWL_Wnd::OnLButtonUp(point,nFlag); 583
584 584 FX_FLOAT nFrictionWidth = 5.0f;
585 if (CPWL_Wnd * pParent = GetParentWindow()) 585 FX_FLOAT nFrictionHeight = 5.5f;
586 pParent->OnNotify(this,PNM_LBUTTONUP,0,(FX_INTPTR)&point); 586
587 587 CPDF_Point ptLeft =
588 m_bMouseDown = FALSE; 588 CPDF_Point(ptCenter.x - nFrictionWidth / 2.0f,
589 ReleaseCapture(); 589 ptCenter.y - nFrictionHeight / 2.0f + 0.5f);
590 590 CPDF_Point ptRight =
591 return TRUE; 591 CPDF_Point(ptCenter.x + nFrictionWidth / 2.0f,
592 } 592 ptCenter.y - nFrictionHeight / 2.0f + 0.5f);
593 593
594 FX_BOOL CPWL_SBButton::OnMouseMove(const CPDF_Point & point, FX_DWORD nFlag) 594 CPWL_Utils::DrawStrokeLine(
595 { 595 pDevice, pUser2Device, ptLeft, ptRight, crStroke, 1.0f);
596 CPWL_Wnd::OnMouseMove(point,nFlag); 596
597 597 ptLeft.y += 2.0f;
598 if (CPWL_Wnd * pParent = GetParentWindow()) 598 ptRight.y += 2.0f;
599 { 599
600 pParent->OnNotify(this,PNM_MOUSEMOVE,0,(FX_INTPTR)&point); 600 CPWL_Utils::DrawStrokeLine(
601 601 pDevice, pUser2Device, ptLeft, ptRight, crStroke, 1.0f);
602 /* 602
603 if (m_bMouseDown && (m_eSBButtonType == PSBT_MIN || m_eSBButtonT ype == PSBT_MAX)) 603 ptLeft.y += 2.0f;
604 { 604 ptRight.y += 2.0f;
605 if (!pParent->OnNotify(this,PNM_LBUTTONDOWN,nFlags,(FX_I NTPTR)&point)) 605
606 return FALSE; 606 CPWL_Utils::DrawStrokeLine(
607 } 607 pDevice, pUser2Device, ptLeft, ptRight, crStroke, 1.0f);
608 */ 608
609 } 609 /*
610 610 ptLeft.y += 1.5f;
611 return TRUE; 611 ptRight.y += 1.5f;
612 } 612
613 613 CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, ptLeft, ptRight,
614 /* ------------------------------- CPWL_ScrollBar ------------------------------ ---- */ 614 ArgbEncode(nTransparancy,150,150,150),1.0f);
615 615 */
616 CPWL_ScrollBar::CPWL_ScrollBar(PWL_SCROLLBAR_TYPE sbType): 616 }
617 m_sbType(sbType), 617 } break;
618 m_pMinButton(NULL), 618 default:
619 m_pMaxButton(NULL), 619 break;
620 m_pPosButton(NULL), 620 }
621 m_bMouseDown(FALSE), 621 break;
622 m_bMinOrMax(FALSE), 622 default:
623 m_bNotifyForever(TRUE) 623 break;
624 { 624 }
625 } 625 }
626 626
627 CPWL_ScrollBar::~CPWL_ScrollBar() 627 FX_BOOL CPWL_SBButton::OnLButtonDown(const CPDF_Point& point, FX_DWORD nFlag) {
628 { 628 CPWL_Wnd::OnLButtonDown(point, nFlag);
629 } 629
630 630 if (CPWL_Wnd* pParent = GetParentWindow())
631 CFX_ByteString CPWL_ScrollBar::GetClassName() const 631 pParent->OnNotify(this, PNM_LBUTTONDOWN, 0, (FX_INTPTR)&point);
632 { 632
633 return "CPWL_ScrollBar"; 633 m_bMouseDown = TRUE;
634 } 634 SetCapture();
635 635
636 void CPWL_ScrollBar::OnCreate(PWL_CREATEPARAM & cp) 636 return TRUE;
637 { 637 }
638 cp.eCursorType = FXCT_ARROW; 638
639 } 639 FX_BOOL CPWL_SBButton::OnLButtonUp(const CPDF_Point& point, FX_DWORD nFlag) {
640 640 CPWL_Wnd::OnLButtonUp(point, nFlag);
641 void CPWL_ScrollBar::RePosChildWnd() 641
642 { 642 if (CPWL_Wnd* pParent = GetParentWindow())
643 CPDF_Rect rcClient = this->GetClientRect(); 643 pParent->OnNotify(this, PNM_LBUTTONUP, 0, (FX_INTPTR)&point);
644 644
645 /* 645 m_bMouseDown = FALSE;
646 switch(m_sbType) 646 ReleaseCapture();
647 { 647
648 case SBT_HSCROLL: 648 return TRUE;
649 if (rcClient.right - rcClient.left < PWL_SCROLLBAR_WIDTH || 649 }
650 rcClient.top - rcClient.bottom < PWL_SCROLLBAR_W IDTH) 650
651 { 651 FX_BOOL CPWL_SBButton::OnMouseMove(const CPDF_Point& point, FX_DWORD nFlag) {
652 SetVisible(FALSE); 652 CPWL_Wnd::OnMouseMove(point, nFlag);
653 } 653
654 break; 654 if (CPWL_Wnd* pParent = GetParentWindow()) {
655 case SBT_VSCROLL: 655 pParent->OnNotify(this, PNM_MOUSEMOVE, 0, (FX_INTPTR)&point);
656 if (rcClient.right - rcClient.left < PWL_SCROLLBAR_WIDTH || 656
657 rcClient.top - rcClient.bottom < PWL_SCROLLBAR_W IDTH) 657 /*
658 { 658 if (m_bMouseDown && (m_eSBButtonType == PSBT_MIN || m_eSBButtonType ==
659 SetVisible(FALSE); 659 PSBT_MAX))
660 } 660 {
661 break; 661 if
662 } 662 (!pParent->OnNotify(this,PNM_LBUTTONDOWN,nFlags,(FX_INTPTR)&point))
663 */ 663 return FALSE;
664 CPDF_Rect rcMinButton,rcMaxButton; 664 }
665 665 */
666 FX_FLOAT fBWidth = 0; 666 }
667 667
668 switch (m_sbType) 668 return TRUE;
669 { 669 }
670 case SBT_HSCROLL: 670
671 if (rcClient.right - rcClient.left > PWL_SCROLLBAR_BUTTON_WIDTH * 2 + PWL_SCROLLBAR_POSBUTTON_MINWIDTH + 2) 671 /* ------------------------------- CPWL_ScrollBar
672 { 672 * ---------------------------------- */
673 rcMinButton = CPDF_Rect(rcClient.left,rcClient.bottom, 673
674 rcClient.left + PWL_SCROLLBAR_BUTTON_WIDTH,rcCli ent.top); 674 CPWL_ScrollBar::CPWL_ScrollBar(PWL_SCROLLBAR_TYPE sbType)
675 rcMaxButton = CPDF_Rect(rcClient.right - PWL_SCROLLBAR_B UTTON_WIDTH,rcClient.bottom, 675 : m_sbType(sbType),
676 rcClient.right,rcClient.top); 676 m_pMinButton(NULL),
677 } 677 m_pMaxButton(NULL),
678 else 678 m_pPosButton(NULL),
679 { 679 m_bMouseDown(FALSE),
680 fBWidth = (rcClient.right - rcClient.left - PWL_SCROLLBA R_POSBUTTON_MINWIDTH - 2) / 2; 680 m_bMinOrMax(FALSE),
681 681 m_bNotifyForever(TRUE) {
682 if (fBWidth > 0) 682 }
683 { 683
684 rcMinButton = CPDF_Rect(rcClient.left,rcClient.b ottom, 684 CPWL_ScrollBar::~CPWL_ScrollBar() {
685 rcClient.left + fBWidth,rcClient.top); 685 }
686 rcMaxButton = CPDF_Rect(rcClient.right - fBWidth ,rcClient.bottom, 686
687 rcClient.right,rcClient.top); 687 CFX_ByteString CPWL_ScrollBar::GetClassName() const {
688 } 688 return "CPWL_ScrollBar";
689 else SetVisible(FALSE); 689 }
690 } 690
691 break; 691 void CPWL_ScrollBar::OnCreate(PWL_CREATEPARAM& cp) {
692 case SBT_VSCROLL: 692 cp.eCursorType = FXCT_ARROW;
693 if (IsFloatBigger(rcClient.top - rcClient.bottom, PWL_SCROLLBAR_ BUTTON_WIDTH * 2 + PWL_SCROLLBAR_POSBUTTON_MINWIDTH + 2)) 693 }
694 { 694
695 rcMinButton = CPDF_Rect(rcClient.left,rcClient.top - PWL _SCROLLBAR_BUTTON_WIDTH, 695 void CPWL_ScrollBar::RePosChildWnd() {
696 rcClient.right,rcClient.top); 696 CPDF_Rect rcClient = this->GetClientRect();
697 rcMaxButton = CPDF_Rect(rcClient.left,rcClient.bottom, 697
698 rcClient.right,rcClient.bottom + PWL_SCROLLBAR_B UTTON_WIDTH); 698 /*
699 } 699 switch(m_sbType)
700 else 700 {
701 { 701 case SBT_HSCROLL:
702 fBWidth = (rcClient.top - rcClient.bottom - PWL_SCROLLBA R_POSBUTTON_MINWIDTH - 2) / 2; 702 if (rcClient.right - rcClient.left <
703 703 PWL_SCROLLBAR_WIDTH ||
704 if (IsFloatBigger(fBWidth, 0)) 704 rcClient.top - rcClient.bottom <
705 { 705 PWL_SCROLLBAR_WIDTH)
706 rcMinButton = CPDF_Rect(rcClient.left,rcClient.t op - fBWidth, 706 {
707 rcClient.right,rcClient.top); 707 SetVisible(FALSE);
708 rcMaxButton = CPDF_Rect(rcClient.left,rcClient.b ottom, 708 }
709 rcClient.right,rcClient.bottom + fBWidth ); 709 break;
710 } 710 case SBT_VSCROLL:
711 else SetVisible(FALSE); 711 if (rcClient.right - rcClient.left <
712 } 712 PWL_SCROLLBAR_WIDTH ||
713 break; 713 rcClient.top - rcClient.bottom <
714 } 714 PWL_SCROLLBAR_WIDTH)
715 715 {
716 // if (IsVisible()) 716 SetVisible(FALSE);
717 { 717 }
718 if (m_pMinButton) 718 break;
719 m_pMinButton->Move(rcMinButton,TRUE,FALSE); 719 }
720 720 */
721 if (m_pMaxButton) 721 CPDF_Rect rcMinButton, rcMaxButton;
722 m_pMaxButton->Move(rcMaxButton,TRUE,FALSE); 722
723 723 FX_FLOAT fBWidth = 0;
724 MovePosButton(FALSE); 724
725 } 725 switch (m_sbType) {
726 } 726 case SBT_HSCROLL:
727 727 if (rcClient.right - rcClient.left >
728 void CPWL_ScrollBar::GetThisAppearanceStream(CFX_ByteTextBuf & sAppStream) 728 PWL_SCROLLBAR_BUTTON_WIDTH * 2 + PWL_SCROLLBAR_POSBUTTON_MINWIDTH +
729 { 729 2) {
730 CPDF_Rect rectWnd = GetWindowRect(); 730 rcMinButton = CPDF_Rect(rcClient.left,
731 731 rcClient.bottom,
732 if (IsVisible() && !rectWnd.IsEmpty()) 732 rcClient.left + PWL_SCROLLBAR_BUTTON_WIDTH,
733 { 733 rcClient.top);
734 CFX_ByteTextBuf sButton; 734 rcMaxButton = CPDF_Rect(rcClient.right - PWL_SCROLLBAR_BUTTON_WIDTH,
735 735 rcClient.bottom,
736 sButton << "q\n"; 736 rcClient.right,
737 sButton << "0 w\n" << CPWL_Utils::GetColorAppStream(GetBackgroun dColor(),TRUE); 737 rcClient.top);
738 sButton << rectWnd.left << " " << rectWnd.bottom << " " 738 } else {
739 << rectWnd.right - rectWnd.left << " " << rectWn d.top - rectWnd.bottom << " re b Q\n"; 739 fBWidth = (rcClient.right - rcClient.left -
740 740 PWL_SCROLLBAR_POSBUTTON_MINWIDTH - 2) /
741 sAppStream << sButton; 741 2;
742 } 742
743 } 743 if (fBWidth > 0) {
744 744 rcMinButton = CPDF_Rect(rcClient.left,
745 void CPWL_ScrollBar::DrawThisAppearance(CFX_RenderDevice* pDevice, CPDF_Matrix* pUser2Device) 745 rcClient.bottom,
746 { 746 rcClient.left + fBWidth,
747 // CPWL_Wnd::DrawThisAppearance(pDevice,pUser2Device); 747 rcClient.top);
748 CPDF_Rect rectWnd = GetWindowRect(); 748 rcMaxButton = CPDF_Rect(rcClient.right - fBWidth,
749 749 rcClient.bottom,
750 if (IsVisible() && !rectWnd.IsEmpty()) 750 rcClient.right,
751 { 751 rcClient.top);
752 CPWL_Utils::DrawFillRect(pDevice, pUser2Device, rectWnd, this->G etBackgroundColor(), GetTransparency()); 752 } else
753 753 SetVisible(FALSE);
754 CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, 754 }
755 CPDF_Point(rectWnd.left+2.0f,rectWnd.top-2.0f), CPDF_Poi nt(rectWnd.left+2.0f,rectWnd.bottom+2.0f), 755 break;
756 ArgbEncode(this->GetTransparency(),100,100,100),1.0f); 756 case SBT_VSCROLL:
757 757 if (IsFloatBigger(rcClient.top - rcClient.bottom,
758 CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, 758 PWL_SCROLLBAR_BUTTON_WIDTH * 2 +
759 CPDF_Point(rectWnd.right-2.0f,rectWnd.top-2.0f), CPDF_Po int(rectWnd.right-2.0f,rectWnd.bottom+2.0f), 759 PWL_SCROLLBAR_POSBUTTON_MINWIDTH + 2)) {
760 ArgbEncode(this->GetTransparency(),100,100,100),1.0f); 760 rcMinButton = CPDF_Rect(rcClient.left,
761 } 761 rcClient.top - PWL_SCROLLBAR_BUTTON_WIDTH,
762 } 762 rcClient.right,
763 763 rcClient.top);
764 FX_BOOL CPWL_ScrollBar::OnLButtonDown(const CPDF_Point & point, FX_DWORD nFlag) 764 rcMaxButton = CPDF_Rect(rcClient.left,
765 { 765 rcClient.bottom,
766 CPWL_Wnd::OnLButtonDown(point,nFlag); 766 rcClient.right,
767 767 rcClient.bottom + PWL_SCROLLBAR_BUTTON_WIDTH);
768 //SetFocus(); 768 } else {
769 769 fBWidth = (rcClient.top - rcClient.bottom -
770 if (HasFlag(PWS_AUTOTRANSPARENT)) 770 PWL_SCROLLBAR_POSBUTTON_MINWIDTH - 2) /
771 { 771 2;
772 if (GetTransparency() != 255) 772
773 { 773 if (IsFloatBigger(fBWidth, 0)) {
774 SetTransparency(255); 774 rcMinButton = CPDF_Rect(rcClient.left,
775 InvalidateRect(); 775 rcClient.top - fBWidth,
776 } 776 rcClient.right,
777 } 777 rcClient.top);
778 778 rcMaxButton = CPDF_Rect(rcClient.left,
779 CPDF_Rect rcMinArea,rcMaxArea; 779 rcClient.bottom,
780 780 rcClient.right,
781 if (m_pPosButton && m_pPosButton->IsVisible()) 781 rcClient.bottom + fBWidth);
782 { 782 } else
783 CPDF_Rect rcClient = this->GetClientRect(); 783 SetVisible(FALSE);
784 CPDF_Rect rcPosButton = m_pPosButton->GetWindowRect(); 784 }
785 785 break;
786 switch (m_sbType) 786 }
787 { 787
788 case SBT_HSCROLL: 788 // if (IsVisible())
789 rcMinArea = CPDF_Rect(rcClient.left + PWL_SCROLLBAR_BUTT ON_WIDTH,rcClient.bottom, 789 {
790 rcPosButton.left,rcClien t.top); 790 if (m_pMinButton)
791 rcMaxArea = CPDF_Rect(rcPosButton.right,rcClient.bottom, 791 m_pMinButton->Move(rcMinButton, TRUE, FALSE);
792 rcClient.right - PWL_SCR OLLBAR_BUTTON_WIDTH,rcClient.top); 792
793 793 if (m_pMaxButton)
794 break; 794 m_pMaxButton->Move(rcMaxButton, TRUE, FALSE);
795 case SBT_VSCROLL: 795
796 rcMinArea = CPDF_Rect(rcClient.left,rcPosButton.top, 796 MovePosButton(FALSE);
797 rcClient.right,rcClient. top - PWL_SCROLLBAR_BUTTON_WIDTH); 797 }
798 rcMaxArea = CPDF_Rect(rcClient.left,rcClient.bottom + PW L_SCROLLBAR_BUTTON_WIDTH, 798 }
799 rcClient.right,rcPosButt on.bottom); 799
800 break; 800 void CPWL_ScrollBar::GetThisAppearanceStream(CFX_ByteTextBuf& sAppStream) {
801 } 801 CPDF_Rect rectWnd = GetWindowRect();
802 802
803 rcMinArea.Normalize(); 803 if (IsVisible() && !rectWnd.IsEmpty()) {
804 rcMaxArea.Normalize(); 804 CFX_ByteTextBuf sButton;
805 805
806 if (rcMinArea.Contains(point.x,point.y)) 806 sButton << "q\n";
807 { 807 sButton << "0 w\n"
808 m_sData.SubBig(); 808 << CPWL_Utils::GetColorAppStream(GetBackgroundColor(), TRUE);
809 MovePosButton(TRUE); 809 sButton << rectWnd.left << " " << rectWnd.bottom << " "
810 NotifyScrollWindow(); 810 << rectWnd.right - rectWnd.left << " "
811 } 811 << rectWnd.top - rectWnd.bottom << " re b Q\n";
812 812
813 if (rcMaxArea.Contains(point.x,point.y)) 813 sAppStream << sButton;
814 { 814 }
815 m_sData.AddBig(); 815 }
816 MovePosButton(TRUE); 816
817 NotifyScrollWindow(); 817 void CPWL_ScrollBar::DrawThisAppearance(CFX_RenderDevice* pDevice,
818 } 818 CPDF_Matrix* pUser2Device) {
819 } 819 // CPWL_Wnd::DrawThisAppearance(pDevice,pUser2Device);
820 820 CPDF_Rect rectWnd = GetWindowRect();
821 return TRUE; 821
822 } 822 if (IsVisible() && !rectWnd.IsEmpty()) {
823 823 CPWL_Utils::DrawFillRect(pDevice,
824 FX_BOOL CPWL_ScrollBar::OnLButtonUp(const CPDF_Point & point, FX_DWORD nFlag) 824 pUser2Device,
825 { 825 rectWnd,
826 CPWL_Wnd::OnLButtonUp(point,nFlag); 826 this->GetBackgroundColor(),
827 827 GetTransparency());
828 if (HasFlag(PWS_AUTOTRANSPARENT)) 828
829 { 829 CPWL_Utils::DrawStrokeLine(
830 if (GetTransparency() != PWL_SCROLLBAR_TRANSPARANCY) 830 pDevice,
831 { 831 pUser2Device,
832 SetTransparency(PWL_SCROLLBAR_TRANSPARANCY); 832 CPDF_Point(rectWnd.left + 2.0f, rectWnd.top - 2.0f),
833 InvalidateRect(); 833 CPDF_Point(rectWnd.left + 2.0f, rectWnd.bottom + 2.0f),
834 } 834 ArgbEncode(this->GetTransparency(), 100, 100, 100),
835 } 835 1.0f);
836 836
837 EndTimer(); 837 CPWL_Utils::DrawStrokeLine(
838 m_bMouseDown = FALSE; 838 pDevice,
839 839 pUser2Device,
840 return TRUE; 840 CPDF_Point(rectWnd.right - 2.0f, rectWnd.top - 2.0f),
841 } 841 CPDF_Point(rectWnd.right - 2.0f, rectWnd.bottom + 2.0f),
842 842 ArgbEncode(this->GetTransparency(), 100, 100, 100),
843 void CPWL_ScrollBar::OnNotify(CPWL_Wnd* pWnd, FX_DWORD msg, FX_INTPTR wParam, FX _INTPTR lParam) 843 1.0f);
844 { 844 }
845 CPWL_Wnd::OnNotify(pWnd,msg,wParam,lParam); 845 }
846 846
847 switch (msg) 847 FX_BOOL CPWL_ScrollBar::OnLButtonDown(const CPDF_Point& point, FX_DWORD nFlag) {
848 { 848 CPWL_Wnd::OnLButtonDown(point, nFlag);
849 case PNM_LBUTTONDOWN: 849
850 if (pWnd == m_pMinButton) 850 // SetFocus();
851 { 851
852 OnMinButtonLBDown(*(CPDF_Point*)lParam); 852 if (HasFlag(PWS_AUTOTRANSPARENT)) {
853 } 853 if (GetTransparency() != 255) {
854 854 SetTransparency(255);
855 if (pWnd == m_pMaxButton) 855 InvalidateRect();
856 { 856 }
857 OnMaxButtonLBDown(*(CPDF_Point*)lParam); 857 }
858 } 858
859 859 CPDF_Rect rcMinArea, rcMaxArea;
860 if (pWnd == m_pPosButton) 860
861 { 861 if (m_pPosButton && m_pPosButton->IsVisible()) {
862 OnPosButtonLBDown(*(CPDF_Point*)lParam); 862 CPDF_Rect rcClient = this->GetClientRect();
863 } 863 CPDF_Rect rcPosButton = m_pPosButton->GetWindowRect();
864 break; 864
865 case PNM_LBUTTONUP: 865 switch (m_sbType) {
866 if (pWnd == m_pMinButton) 866 case SBT_HSCROLL:
867 { 867 rcMinArea = CPDF_Rect(rcClient.left + PWL_SCROLLBAR_BUTTON_WIDTH,
868 OnMinButtonLBUp(*(CPDF_Point*)lParam); 868 rcClient.bottom,
869 } 869 rcPosButton.left,
870 870 rcClient.top);
871 if (pWnd == m_pMaxButton) 871 rcMaxArea = CPDF_Rect(rcPosButton.right,
872 { 872 rcClient.bottom,
873 OnMaxButtonLBUp(*(CPDF_Point*)lParam); 873 rcClient.right - PWL_SCROLLBAR_BUTTON_WIDTH,
874 } 874 rcClient.top);
875 875
876 if (pWnd == m_pPosButton) 876 break;
877 { 877 case SBT_VSCROLL:
878 OnPosButtonLBUp(*(CPDF_Point*)lParam); 878 rcMinArea = CPDF_Rect(rcClient.left,
879 } 879 rcPosButton.top,
880 break; 880 rcClient.right,
881 case PNM_MOUSEMOVE: 881 rcClient.top - PWL_SCROLLBAR_BUTTON_WIDTH);
882 if (pWnd == m_pMinButton) 882 rcMaxArea = CPDF_Rect(rcClient.left,
883 { 883 rcClient.bottom + PWL_SCROLLBAR_BUTTON_WIDTH,
884 OnMinButtonMouseMove(*(CPDF_Point*)lParam); 884 rcClient.right,
885 } 885 rcPosButton.bottom);
886 886 break;
887 if (pWnd == m_pMaxButton) 887 }
888 { 888
889 OnMaxButtonMouseMove(*(CPDF_Point*)lParam); 889 rcMinArea.Normalize();
890 } 890 rcMaxArea.Normalize();
891 891
892 if (pWnd == m_pPosButton) 892 if (rcMinArea.Contains(point.x, point.y)) {
893 { 893 m_sData.SubBig();
894 OnPosButtonMouseMove(*(CPDF_Point*)lParam); 894 MovePosButton(TRUE);
895 } 895 NotifyScrollWindow();
896 break; 896 }
897 case PNM_SETSCROLLINFO: 897
898 { 898 if (rcMaxArea.Contains(point.x, point.y)) {
899 if (PWL_SCROLL_INFO * pInfo = (PWL_SCROLL_INFO*)lParam) 899 m_sData.AddBig();
900 { 900 MovePosButton(TRUE);
901 if (FXSYS_memcmp(&m_OriginInfo, pInfo, sizeof(PW L_SCROLL_INFO)) != 0) 901 NotifyScrollWindow();
902 { 902 }
903 m_OriginInfo = *pInfo; 903 }
904 FX_FLOAT fMax = pInfo->fContentMax - pIn fo->fContentMin - pInfo->fPlateWidth; 904
905 fMax = fMax > 0.0f ? fMax : 0.0f; 905 return TRUE;
906 this->SetScrollRange(0,fMax, pInfo->fPla teWidth); 906 }
907 this->SetScrollStep(pInfo->fBigStep,pInf o->fSmallStep); 907
908 } 908 FX_BOOL CPWL_ScrollBar::OnLButtonUp(const CPDF_Point& point, FX_DWORD nFlag) {
909 } 909 CPWL_Wnd::OnLButtonUp(point, nFlag);
910 } 910
911 break; 911 if (HasFlag(PWS_AUTOTRANSPARENT)) {
912 case PNM_SETSCROLLPOS: 912 if (GetTransparency() != PWL_SCROLLBAR_TRANSPARANCY) {
913 { 913 SetTransparency(PWL_SCROLLBAR_TRANSPARANCY);
914 FX_FLOAT fPos = *(FX_FLOAT*)lParam; 914 InvalidateRect();
915 switch (this->m_sbType) 915 }
916 { 916 }
917 case SBT_HSCROLL: 917
918 fPos = fPos - m_OriginInfo.fContentMin; 918 EndTimer();
919 break; 919 m_bMouseDown = FALSE;
920 case SBT_VSCROLL: 920
921 fPos = m_OriginInfo.fContentMax - fPos; 921 return TRUE;
922 break; 922 }
923 } 923
924 this->SetScrollPos(fPos); 924 void CPWL_ScrollBar::OnNotify(CPWL_Wnd* pWnd,
925 } 925 FX_DWORD msg,
926 break; 926 FX_INTPTR wParam,
927 } 927 FX_INTPTR lParam) {
928 } 928 CPWL_Wnd::OnNotify(pWnd, msg, wParam, lParam);
929 929
930 void CPWL_ScrollBar::CreateButtons(const PWL_CREATEPARAM & cp) 930 switch (msg) {
931 { 931 case PNM_LBUTTONDOWN:
932 PWL_CREATEPARAM scp = cp; 932 if (pWnd == m_pMinButton) {
933 scp.pParentWnd = this; 933 OnMinButtonLBDown(*(CPDF_Point*)lParam);
934 scp.dwBorderWidth = 2; 934 }
935 scp.nBorderStyle = PBS_BEVELED; 935
936 936 if (pWnd == m_pMaxButton) {
937 scp.dwFlags = PWS_VISIBLE | PWS_CHILD | PWS_BORDER | PWS_BACKGROUND | PW S_NOREFRESHCLIP; 937 OnMaxButtonLBDown(*(CPDF_Point*)lParam);
938 938 }
939 if (!m_pMinButton) 939
940 { 940 if (pWnd == m_pPosButton) {
941 m_pMinButton = new CPWL_SBButton(m_sbType,PSBT_MIN); 941 OnPosButtonLBDown(*(CPDF_Point*)lParam);
942 m_pMinButton->Create(scp); 942 }
943 } 943 break;
944 944 case PNM_LBUTTONUP:
945 if (!m_pMaxButton) 945 if (pWnd == m_pMinButton) {
946 { 946 OnMinButtonLBUp(*(CPDF_Point*)lParam);
947 m_pMaxButton = new CPWL_SBButton(m_sbType,PSBT_MAX); 947 }
948 m_pMaxButton->Create(scp); 948
949 } 949 if (pWnd == m_pMaxButton) {
950 950 OnMaxButtonLBUp(*(CPDF_Point*)lParam);
951 if (!m_pPosButton) 951 }
952 { 952
953 m_pPosButton = new CPWL_SBButton(m_sbType,PSBT_POS); 953 if (pWnd == m_pPosButton) {
954 m_pPosButton->SetVisible(FALSE); 954 OnPosButtonLBUp(*(CPDF_Point*)lParam);
955 m_pPosButton->Create(scp); 955 }
956 } 956 break;
957 } 957 case PNM_MOUSEMOVE:
958 958 if (pWnd == m_pMinButton) {
959 FX_FLOAT CPWL_ScrollBar::GetScrollBarWidth() const 959 OnMinButtonMouseMove(*(CPDF_Point*)lParam);
960 { 960 }
961 if (!IsVisible()) return 0; 961
962 962 if (pWnd == m_pMaxButton) {
963 return PWL_SCROLLBAR_WIDTH; 963 OnMaxButtonMouseMove(*(CPDF_Point*)lParam);
964 } 964 }
965 965
966 void CPWL_ScrollBar::SetScrollRange(FX_FLOAT fMin,FX_FLOAT fMax,FX_FLOAT fClient Width) 966 if (pWnd == m_pPosButton) {
967 { 967 OnPosButtonMouseMove(*(CPDF_Point*)lParam);
968 if (m_pPosButton) 968 }
969 { 969 break;
970 m_sData.SetScrollRange(fMin,fMax); 970 case PNM_SETSCROLLINFO: {
971 m_sData.SetClientWidth(fClientWidth); 971 if (PWL_SCROLL_INFO* pInfo = (PWL_SCROLL_INFO*)lParam) {
972 972 if (FXSYS_memcmp(&m_OriginInfo, pInfo, sizeof(PWL_SCROLL_INFO)) != 0) {
973 if (IsFloatSmaller(m_sData.ScrollRange.GetWidth(), 0.0f)) 973 m_OriginInfo = *pInfo;
974 { 974 FX_FLOAT fMax =
975 m_pPosButton->SetVisible(FALSE); 975 pInfo->fContentMax - pInfo->fContentMin - pInfo->fPlateWidth;
976 } 976 fMax = fMax > 0.0f ? fMax : 0.0f;
977 else 977 this->SetScrollRange(0, fMax, pInfo->fPlateWidth);
978 { 978 this->SetScrollStep(pInfo->fBigStep, pInfo->fSmallStep);
979 m_pPosButton->SetVisible(TRUE); 979 }
980 MovePosButton(TRUE); 980 }
981 } 981 } break;
982 } 982 case PNM_SETSCROLLPOS: {
983 } 983 FX_FLOAT fPos = *(FX_FLOAT*)lParam;
984 984 switch (this->m_sbType) {
985 void CPWL_ScrollBar::SetScrollPos(FX_FLOAT fPos) 985 case SBT_HSCROLL:
986 { 986 fPos = fPos - m_OriginInfo.fContentMin;
987 FX_FLOAT fOldPos = m_sData.fScrollPos; 987 break;
988 988 case SBT_VSCROLL:
989 m_sData.SetPos(fPos); 989 fPos = m_OriginInfo.fContentMax - fPos;
990 990 break;
991 if (!IsFloatEqual(m_sData.fScrollPos, fOldPos)) 991 }
992 MovePosButton(TRUE); 992 this->SetScrollPos(fPos);
993 } 993 } break;
994 994 }
995 void CPWL_ScrollBar::SetScrollStep(FX_FLOAT fBigStep,FX_FLOAT fSmallStep) 995 }
996 { 996
997 m_sData.SetBigStep(fBigStep); 997 void CPWL_ScrollBar::CreateButtons(const PWL_CREATEPARAM& cp) {
998 m_sData.SetSmallStep(fSmallStep); 998 PWL_CREATEPARAM scp = cp;
999 } 999 scp.pParentWnd = this;
1000 1000 scp.dwBorderWidth = 2;
1001 void CPWL_ScrollBar::MovePosButton(FX_BOOL bRefresh) 1001 scp.nBorderStyle = PBS_BEVELED;
1002 { 1002
1003 ASSERT (m_pPosButton != NULL); 1003 scp.dwFlags =
1004 ASSERT (m_pMinButton != NULL); 1004 PWS_VISIBLE | PWS_CHILD | PWS_BORDER | PWS_BACKGROUND | PWS_NOREFRESHCLIP;
1005 ASSERT (m_pMaxButton != NULL); 1005
1006 1006 if (!m_pMinButton) {
1007 if (m_pPosButton->IsVisible()) 1007 m_pMinButton = new CPWL_SBButton(m_sbType, PSBT_MIN);
1008 { 1008 m_pMinButton->Create(scp);
1009 1009 }
1010 1010
1011 1011 if (!m_pMaxButton) {
1012 1012 m_pMaxButton = new CPWL_SBButton(m_sbType, PSBT_MAX);
1013 CPDF_Rect rcClient; 1013 m_pMaxButton->Create(scp);
1014 CPDF_Rect rcPosArea,rcPosButton; 1014 }
1015 1015
1016 rcClient = this->GetClientRect(); 1016 if (!m_pPosButton) {
1017 rcPosArea = GetScrollArea(); 1017 m_pPosButton = new CPWL_SBButton(m_sbType, PSBT_POS);
1018 1018 m_pPosButton->SetVisible(FALSE);
1019 FX_FLOAT fLeft,fRight,fTop,fBottom; 1019 m_pPosButton->Create(scp);
1020 1020 }
1021 switch (m_sbType) 1021 }
1022 { 1022
1023 case SBT_HSCROLL: 1023 FX_FLOAT CPWL_ScrollBar::GetScrollBarWidth() const {
1024 fLeft = TrueToFace(m_sData.fScrollPos); 1024 if (!IsVisible())
1025 fRight = TrueToFace(m_sData.fScrollPos + m_sData.fClient Width); 1025 return 0;
1026 1026
1027 if (fRight - fLeft < PWL_SCROLLBAR_POSBUTTON_MINWIDTH) 1027 return PWL_SCROLLBAR_WIDTH;
1028 fRight = fLeft + PWL_SCROLLBAR_POSBUTTON_MINWIDT H; 1028 }
1029 1029
1030 if (fRight > rcPosArea.right) 1030 void CPWL_ScrollBar::SetScrollRange(FX_FLOAT fMin,
1031 { 1031 FX_FLOAT fMax,
1032 fRight = rcPosArea.right; 1032 FX_FLOAT fClientWidth) {
1033 fLeft = fRight - PWL_SCROLLBAR_POSBUTTON_MINWIDT H; 1033 if (m_pPosButton) {
1034 } 1034 m_sData.SetScrollRange(fMin, fMax);
1035 1035 m_sData.SetClientWidth(fClientWidth);
1036 rcPosButton = CPDF_Rect(fLeft , 1036
1037 rcPosArea.bottom , 1037 if (IsFloatSmaller(m_sData.ScrollRange.GetWidth(), 0.0f)) {
1038 fRight , 1038 m_pPosButton->SetVisible(FALSE);
1039 rcPosArea.top); 1039 } else {
1040 1040 m_pPosButton->SetVisible(TRUE);
1041 break; 1041 MovePosButton(TRUE);
1042 case SBT_VSCROLL: 1042 }
1043 fBottom = TrueToFace(m_sData.fScrollPos + m_sData.fClien tWidth); 1043 }
1044 fTop = TrueToFace(m_sData.fScrollPos); 1044 }
1045 1045
1046 if (IsFloatSmaller(fTop - fBottom, PWL_SCROLLBAR_POSBUTT ON_MINWIDTH)) 1046 void CPWL_ScrollBar::SetScrollPos(FX_FLOAT fPos) {
1047 fBottom = fTop - PWL_SCROLLBAR_POSBUTTON_MINWIDT H; 1047 FX_FLOAT fOldPos = m_sData.fScrollPos;
1048 1048
1049 if (IsFloatSmaller(fBottom, rcPosArea.bottom)) 1049 m_sData.SetPos(fPos);
1050 { 1050
1051 fBottom = rcPosArea.bottom; 1051 if (!IsFloatEqual(m_sData.fScrollPos, fOldPos))
1052 fTop = fBottom + PWL_SCROLLBAR_POSBUTTON_MINWIDT H; 1052 MovePosButton(TRUE);
1053 } 1053 }
1054 1054
1055 rcPosButton = CPDF_Rect(rcPosArea.left, 1055 void CPWL_ScrollBar::SetScrollStep(FX_FLOAT fBigStep, FX_FLOAT fSmallStep) {
1056 fBottom, 1056 m_sData.SetBigStep(fBigStep);
1057 rcPosArea.right, 1057 m_sData.SetSmallStep(fSmallStep);
1058 fTop); 1058 }
1059 1059
1060 break; 1060 void CPWL_ScrollBar::MovePosButton(FX_BOOL bRefresh) {
1061 } 1061 ASSERT(m_pPosButton != NULL);
1062 1062 ASSERT(m_pMinButton != NULL);
1063 m_pPosButton->Move(rcPosButton,TRUE,bRefresh); 1063 ASSERT(m_pMaxButton != NULL);
1064 } 1064
1065 } 1065 if (m_pPosButton->IsVisible()) {
1066 1066 CPDF_Rect rcClient;
1067 void CPWL_ScrollBar::OnMinButtonLBDown(const CPDF_Point & point) 1067 CPDF_Rect rcPosArea, rcPosButton;
1068 { 1068
1069 m_sData.SubSmall(); 1069 rcClient = this->GetClientRect();
1070 MovePosButton(TRUE); 1070 rcPosArea = GetScrollArea();
1071 NotifyScrollWindow(); 1071
1072 1072 FX_FLOAT fLeft, fRight, fTop, fBottom;
1073 m_bMinOrMax = TRUE; 1073
1074 1074 switch (m_sbType) {
1075 EndTimer(); 1075 case SBT_HSCROLL:
1076 BeginTimer(100); 1076 fLeft = TrueToFace(m_sData.fScrollPos);
1077 } 1077 fRight = TrueToFace(m_sData.fScrollPos + m_sData.fClientWidth);
1078 1078
1079 void CPWL_ScrollBar::OnMinButtonLBUp(const CPDF_Point & point) 1079 if (fRight - fLeft < PWL_SCROLLBAR_POSBUTTON_MINWIDTH)
1080 { 1080 fRight = fLeft + PWL_SCROLLBAR_POSBUTTON_MINWIDTH;
1081 } 1081
1082 1082 if (fRight > rcPosArea.right) {
1083 void CPWL_ScrollBar::OnMinButtonMouseMove(const CPDF_Point & point) 1083 fRight = rcPosArea.right;
1084 { 1084 fLeft = fRight - PWL_SCROLLBAR_POSBUTTON_MINWIDTH;
1085 } 1085 }
1086 1086
1087 void CPWL_ScrollBar::OnMaxButtonLBDown(const CPDF_Point & point) 1087 rcPosButton = CPDF_Rect(fLeft, rcPosArea.bottom, fRight, rcPosArea.top);
1088 { 1088
1089 m_sData.AddSmall(); 1089 break;
1090 MovePosButton(TRUE); 1090 case SBT_VSCROLL:
1091 NotifyScrollWindow(); 1091 fBottom = TrueToFace(m_sData.fScrollPos + m_sData.fClientWidth);
1092 1092 fTop = TrueToFace(m_sData.fScrollPos);
1093 m_bMinOrMax = FALSE; 1093
1094 1094 if (IsFloatSmaller(fTop - fBottom, PWL_SCROLLBAR_POSBUTTON_MINWIDTH))
1095 EndTimer(); 1095 fBottom = fTop - PWL_SCROLLBAR_POSBUTTON_MINWIDTH;
1096 BeginTimer(100); 1096
1097 } 1097 if (IsFloatSmaller(fBottom, rcPosArea.bottom)) {
1098 1098 fBottom = rcPosArea.bottom;
1099 void CPWL_ScrollBar::OnMaxButtonLBUp(const CPDF_Point & point) 1099 fTop = fBottom + PWL_SCROLLBAR_POSBUTTON_MINWIDTH;
1100 { 1100 }
1101 } 1101
1102 1102 rcPosButton = CPDF_Rect(rcPosArea.left, fBottom, rcPosArea.right, fTop);
1103 void CPWL_ScrollBar::OnMaxButtonMouseMove(const CPDF_Point & point) 1103
1104 { 1104 break;
1105 } 1105 }
1106 1106
1107 void CPWL_ScrollBar::OnPosButtonLBDown(const CPDF_Point & point) 1107 m_pPosButton->Move(rcPosButton, TRUE, bRefresh);
1108 { 1108 }
1109 m_bMouseDown = TRUE; 1109 }
1110 1110
1111 if (m_pPosButton) 1111 void CPWL_ScrollBar::OnMinButtonLBDown(const CPDF_Point& point) {
1112 { 1112 m_sData.SubSmall();
1113 CPDF_Rect rcPosButton = m_pPosButton->GetWindowRect(); 1113 MovePosButton(TRUE);
1114 1114 NotifyScrollWindow();
1115 switch(m_sbType) 1115
1116 { 1116 m_bMinOrMax = TRUE;
1117 case SBT_HSCROLL: 1117
1118 m_nOldPos = point.x; 1118 EndTimer();
1119 m_fOldPosButton = rcPosButton.left; 1119 BeginTimer(100);
1120 break; 1120 }
1121 case SBT_VSCROLL: 1121
1122 m_nOldPos = point.y; 1122 void CPWL_ScrollBar::OnMinButtonLBUp(const CPDF_Point& point) {
1123 m_fOldPosButton = rcPosButton.top; 1123 }
1124 break; 1124
1125 } 1125 void CPWL_ScrollBar::OnMinButtonMouseMove(const CPDF_Point& point) {
1126 } 1126 }
1127 } 1127
1128 1128 void CPWL_ScrollBar::OnMaxButtonLBDown(const CPDF_Point& point) {
1129 void CPWL_ScrollBar::OnPosButtonLBUp(const CPDF_Point & point) 1129 m_sData.AddSmall();
1130 { 1130 MovePosButton(TRUE);
1131 if (m_bMouseDown) 1131 NotifyScrollWindow();
1132 { 1132
1133 if (!m_bNotifyForever) 1133 m_bMinOrMax = FALSE;
1134 NotifyScrollWindow(); 1134
1135 } 1135 EndTimer();
1136 m_bMouseDown = FALSE; 1136 BeginTimer(100);
1137 } 1137 }
1138 1138
1139 void CPWL_ScrollBar::OnPosButtonMouseMove(const CPDF_Point & point) 1139 void CPWL_ScrollBar::OnMaxButtonLBUp(const CPDF_Point& point) {
1140 { 1140 }
1141 FX_FLOAT fOldScrollPos = m_sData.fScrollPos; 1141
1142 1142 void CPWL_ScrollBar::OnMaxButtonMouseMove(const CPDF_Point& point) {
1143 FX_FLOAT fNewPos = 0; 1143 }
1144 1144
1145 switch (m_sbType) 1145 void CPWL_ScrollBar::OnPosButtonLBDown(const CPDF_Point& point) {
1146 { 1146 m_bMouseDown = TRUE;
1147 case SBT_HSCROLL: 1147
1148 if (FXSYS_fabs(point.x - m_nOldPos) < 1) return; 1148 if (m_pPosButton) {
1149 fNewPos = FaceToTrue(m_fOldPosButton + point.x - m_nOldPos); 1149 CPDF_Rect rcPosButton = m_pPosButton->GetWindowRect();
1150 break; 1150
1151 case SBT_VSCROLL: 1151 switch (m_sbType) {
1152 if (FXSYS_fabs(point.y - m_nOldPos) < 1) return; 1152 case SBT_HSCROLL:
1153 fNewPos = FaceToTrue(m_fOldPosButton + point.y - m_nOldPos); 1153 m_nOldPos = point.x;
1154 break; 1154 m_fOldPosButton = rcPosButton.left;
1155 } 1155 break;
1156 1156 case SBT_VSCROLL:
1157 if (m_bMouseDown) 1157 m_nOldPos = point.y;
1158 { 1158 m_fOldPosButton = rcPosButton.top;
1159 switch (m_sbType) 1159 break;
1160 { 1160 }
1161 case SBT_HSCROLL: 1161 }
1162 1162 }
1163 if (IsFloatSmaller(fNewPos, m_sData.ScrollRange.fMin)) 1163
1164 { 1164 void CPWL_ScrollBar::OnPosButtonLBUp(const CPDF_Point& point) {
1165 fNewPos = m_sData.ScrollRange.fMin; 1165 if (m_bMouseDown) {
1166 } 1166 if (!m_bNotifyForever)
1167 1167 NotifyScrollWindow();
1168 if (IsFloatBigger(fNewPos, m_sData.ScrollRange.fMax)) 1168 }
1169 { 1169 m_bMouseDown = FALSE;
1170 fNewPos = m_sData.ScrollRange.fMax; 1170 }
1171 } 1171
1172 1172 void CPWL_ScrollBar::OnPosButtonMouseMove(const CPDF_Point& point) {
1173 m_sData.SetPos(fNewPos); 1173 FX_FLOAT fOldScrollPos = m_sData.fScrollPos;
1174 1174
1175 break; 1175 FX_FLOAT fNewPos = 0;
1176 case SBT_VSCROLL: 1176
1177 1177 switch (m_sbType) {
1178 if (IsFloatSmaller(fNewPos, m_sData.ScrollRange.fMin)) 1178 case SBT_HSCROLL:
1179 { 1179 if (FXSYS_fabs(point.x - m_nOldPos) < 1)
1180 fNewPos = m_sData.ScrollRange.fMin; 1180 return;
1181 } 1181 fNewPos = FaceToTrue(m_fOldPosButton + point.x - m_nOldPos);
1182 1182 break;
1183 if (IsFloatBigger(fNewPos, m_sData.ScrollRange.fMax)) 1183 case SBT_VSCROLL:
1184 { 1184 if (FXSYS_fabs(point.y - m_nOldPos) < 1)
1185 fNewPos = m_sData.ScrollRange.fMax; 1185 return;
1186 } 1186 fNewPos = FaceToTrue(m_fOldPosButton + point.y - m_nOldPos);
1187 1187 break;
1188 m_sData.SetPos(fNewPos); 1188 }
1189 1189
1190 break; 1190 if (m_bMouseDown) {
1191 } 1191 switch (m_sbType) {
1192 1192 case SBT_HSCROLL:
1193 if (!IsFloatEqual(fOldScrollPos, m_sData.fScrollPos)) 1193
1194 { 1194 if (IsFloatSmaller(fNewPos, m_sData.ScrollRange.fMin)) {
1195 MovePosButton(TRUE); 1195 fNewPos = m_sData.ScrollRange.fMin;
1196 1196 }
1197 if (m_bNotifyForever) 1197
1198 NotifyScrollWindow(); 1198 if (IsFloatBigger(fNewPos, m_sData.ScrollRange.fMax)) {
1199 } 1199 fNewPos = m_sData.ScrollRange.fMax;
1200 } 1200 }
1201 } 1201
1202 1202 m_sData.SetPos(fNewPos);
1203 void CPWL_ScrollBar::NotifyScrollWindow() 1203
1204 { 1204 break;
1205 if (CPWL_Wnd * pParent = this->GetParentWindow()) 1205 case SBT_VSCROLL:
1206 { 1206
1207 FX_FLOAT fPos; 1207 if (IsFloatSmaller(fNewPos, m_sData.ScrollRange.fMin)) {
1208 switch (this->m_sbType) 1208 fNewPos = m_sData.ScrollRange.fMin;
1209 { 1209 }
1210 case SBT_HSCROLL: 1210
1211 fPos = m_OriginInfo.fContentMin + m_sData.fScrollPos; 1211 if (IsFloatBigger(fNewPos, m_sData.ScrollRange.fMax)) {
1212 break; 1212 fNewPos = m_sData.ScrollRange.fMax;
1213 case SBT_VSCROLL: 1213 }
1214 fPos = m_OriginInfo.fContentMax - m_sData.fScrollPos; 1214
1215 break; 1215 m_sData.SetPos(fNewPos);
1216 } 1216
1217 pParent->OnNotify(this,PNM_SCROLLWINDOW,(FX_INTPTR)m_sbType,(FX_ INTPTR)&fPos); 1217 break;
1218 } 1218 }
1219 } 1219
1220 1220 if (!IsFloatEqual(fOldScrollPos, m_sData.fScrollPos)) {
1221 CPDF_Rect CPWL_ScrollBar::GetScrollArea() const 1221 MovePosButton(TRUE);
1222 { 1222
1223 CPDF_Rect rcClient = GetClientRect(); 1223 if (m_bNotifyForever)
1224 CPDF_Rect rcArea; 1224 NotifyScrollWindow();
1225 1225 }
1226 if (!m_pMinButton || !m_pMaxButton)return rcClient; 1226 }
1227 1227 }
1228 CPDF_Rect rcMin = m_pMinButton->GetWindowRect(); 1228
1229 CPDF_Rect rcMax = m_pMaxButton->GetWindowRect(); 1229 void CPWL_ScrollBar::NotifyScrollWindow() {
1230 1230 if (CPWL_Wnd* pParent = this->GetParentWindow()) {
1231 FX_FLOAT fMinWidth = rcMin.right - rcMin.left; 1231 FX_FLOAT fPos;
1232 FX_FLOAT fMinHeight = rcMin.top - rcMin.bottom; 1232 switch (this->m_sbType) {
1233 FX_FLOAT fMaxWidth = rcMax.right - rcMax.left; 1233 case SBT_HSCROLL:
1234 FX_FLOAT fMaxHeight = rcMax.top - rcMax.bottom; 1234 fPos = m_OriginInfo.fContentMin + m_sData.fScrollPos;
1235 1235 break;
1236 switch(m_sbType) 1236 case SBT_VSCROLL:
1237 { 1237 fPos = m_OriginInfo.fContentMax - m_sData.fScrollPos;
1238 case SBT_HSCROLL: 1238 break;
1239 if (rcClient.right - rcClient.left > fMinWidth + fMaxWidth + 2) 1239 }
1240 { 1240 pParent->OnNotify(
1241 rcArea = CPDF_Rect(rcClient.left + fMinWidth + 1,rcClien t.bottom, 1241 this, PNM_SCROLLWINDOW, (FX_INTPTR)m_sbType, (FX_INTPTR)&fPos);
1242 rcClient.right - fMaxWidth - 1,r cClient.top); 1242 }
1243 } 1243 }
1244 else 1244
1245 { 1245 CPDF_Rect CPWL_ScrollBar::GetScrollArea() const {
1246 rcArea = CPDF_Rect(rcClient.left + fMinWidth + 1,rcClien t.bottom, 1246 CPDF_Rect rcClient = GetClientRect();
1247 rcClient.left + fMinWidth + 1,rc Client.top); 1247 CPDF_Rect rcArea;
1248 } 1248
1249 break; 1249 if (!m_pMinButton || !m_pMaxButton)
1250 case SBT_VSCROLL: 1250 return rcClient;
1251 if (rcClient.top - rcClient.bottom > fMinHeight + fMaxHeight + 2 ) 1251
1252 { 1252 CPDF_Rect rcMin = m_pMinButton->GetWindowRect();
1253 rcArea = CPDF_Rect(rcClient.left,rcClient.bottom + fMinH eight + 1, 1253 CPDF_Rect rcMax = m_pMaxButton->GetWindowRect();
1254 rcClient.right,rcClient.top - fM axHeight - 1); 1254
1255 } 1255 FX_FLOAT fMinWidth = rcMin.right - rcMin.left;
1256 else 1256 FX_FLOAT fMinHeight = rcMin.top - rcMin.bottom;
1257 { 1257 FX_FLOAT fMaxWidth = rcMax.right - rcMax.left;
1258 rcArea = CPDF_Rect(rcClient.left,rcClient.bottom + fMinH eight + 1, 1258 FX_FLOAT fMaxHeight = rcMax.top - rcMax.bottom;
1259 rcClient.right,rcClient.bottom + fMinHeight + 1); 1259
1260 } 1260 switch (m_sbType) {
1261 break; 1261 case SBT_HSCROLL:
1262 } 1262 if (rcClient.right - rcClient.left > fMinWidth + fMaxWidth + 2) {
1263 1263 rcArea = CPDF_Rect(rcClient.left + fMinWidth + 1,
1264 rcArea.Normalize(); 1264 rcClient.bottom,
1265 1265 rcClient.right - fMaxWidth - 1,
1266 return rcArea; 1266 rcClient.top);
1267 } 1267 } else {
1268 1268 rcArea = CPDF_Rect(rcClient.left + fMinWidth + 1,
1269 FX_FLOAT CPWL_ScrollBar::TrueToFace(FX_FLOAT fTrue) 1269 rcClient.bottom,
1270 { 1270 rcClient.left + fMinWidth + 1,
1271 CPDF_Rect rcPosArea; 1271 rcClient.top);
1272 rcPosArea = GetScrollArea(); 1272 }
1273 1273 break;
1274 FX_FLOAT fFactWidth = m_sData.ScrollRange.GetWidth() + m_sData.fClientWi dth; 1274 case SBT_VSCROLL:
1275 fFactWidth = fFactWidth == 0 ? 1 : fFactWidth; 1275 if (rcClient.top - rcClient.bottom > fMinHeight + fMaxHeight + 2) {
1276 1276 rcArea = CPDF_Rect(rcClient.left,
1277 FX_FLOAT fFace = 0; 1277 rcClient.bottom + fMinHeight + 1,
1278 1278 rcClient.right,
1279 switch(m_sbType) 1279 rcClient.top - fMaxHeight - 1);
1280 { 1280 } else {
1281 case SBT_HSCROLL: 1281 rcArea = CPDF_Rect(rcClient.left,
1282 fFace = rcPosArea.left + fTrue * (rcPosArea.right - rcPosArea.le ft) / fFactWidth; 1282 rcClient.bottom + fMinHeight + 1,
1283 break; 1283 rcClient.right,
1284 case SBT_VSCROLL: 1284 rcClient.bottom + fMinHeight + 1);
1285 fFace = rcPosArea.top - fTrue * (rcPosArea.top - rcPosArea.botto m) / fFactWidth; 1285 }
1286 break; 1286 break;
1287 } 1287 }
1288 1288
1289 return fFace; 1289 rcArea.Normalize();
1290 } 1290
1291 1291 return rcArea;
1292 FX_FLOAT CPWL_ScrollBar::FaceToTrue(FX_FLOAT fFace) 1292 }
1293 { 1293
1294 CPDF_Rect rcPosArea; 1294 FX_FLOAT CPWL_ScrollBar::TrueToFace(FX_FLOAT fTrue) {
1295 rcPosArea = GetScrollArea(); 1295 CPDF_Rect rcPosArea;
1296 1296 rcPosArea = GetScrollArea();
1297 FX_FLOAT fFactWidth = m_sData.ScrollRange.GetWidth() + m_sData.fClientWi dth; 1297
1298 fFactWidth = fFactWidth == 0 ? 1 : fFactWidth; 1298 FX_FLOAT fFactWidth = m_sData.ScrollRange.GetWidth() + m_sData.fClientWidth;
1299 1299 fFactWidth = fFactWidth == 0 ? 1 : fFactWidth;
1300 FX_FLOAT fTrue = 0; 1300
1301 1301 FX_FLOAT fFace = 0;
1302 switch(m_sbType) 1302
1303 { 1303 switch (m_sbType) {
1304 case SBT_HSCROLL: 1304 case SBT_HSCROLL:
1305 fTrue = (fFace - rcPosArea.left) * fFactWidth / (rcPosArea.righ t - rcPosArea.left); 1305 fFace = rcPosArea.left +
1306 break; 1306 fTrue * (rcPosArea.right - rcPosArea.left) / fFactWidth;
1307 case SBT_VSCROLL: 1307 break;
1308 fTrue = (rcPosArea.top - fFace) * fFactWidth / (rcPosArea.top - rcPosArea.bottom); 1308 case SBT_VSCROLL:
1309 break; 1309 fFace = rcPosArea.top -
1310 } 1310 fTrue * (rcPosArea.top - rcPosArea.bottom) / fFactWidth;
1311 1311 break;
1312 return fTrue; 1312 }
1313 } 1313
1314 1314 return fFace;
1315 void CPWL_ScrollBar::CreateChildWnd(const PWL_CREATEPARAM & cp) 1315 }
1316 { 1316
1317 CreateButtons(cp); 1317 FX_FLOAT CPWL_ScrollBar::FaceToTrue(FX_FLOAT fFace) {
1318 } 1318 CPDF_Rect rcPosArea;
1319 1319 rcPosArea = GetScrollArea();
1320 void CPWL_ScrollBar::TimerProc() 1320
1321 { 1321 FX_FLOAT fFactWidth = m_sData.ScrollRange.GetWidth() + m_sData.fClientWidth;
1322 PWL_SCROLL_PRIVATEDATA sTemp = m_sData; 1322 fFactWidth = fFactWidth == 0 ? 1 : fFactWidth;
1323 1323
1324 if (m_bMinOrMax)m_sData.SubSmall(); 1324 FX_FLOAT fTrue = 0;
1325 else m_sData.AddSmall(); 1325
1326 1326 switch (m_sbType) {
1327 if (FXSYS_memcmp(&m_sData, &sTemp, sizeof(PWL_SCROLL_PRIVATEDATA)) != 0) 1327 case SBT_HSCROLL:
1328 { 1328 fTrue = (fFace - rcPosArea.left) * fFactWidth /
1329 MovePosButton(TRUE); 1329 (rcPosArea.right - rcPosArea.left);
1330 NotifyScrollWindow(); 1330 break;
1331 } 1331 case SBT_VSCROLL:
1332 fTrue = (rcPosArea.top - fFace) * fFactWidth /
1333 (rcPosArea.top - rcPosArea.bottom);
1334 break;
1335 }
1336
1337 return fTrue;
1338 }
1339
1340 void CPWL_ScrollBar::CreateChildWnd(const PWL_CREATEPARAM& cp) {
1341 CreateButtons(cp);
1342 }
1343
1344 void CPWL_ScrollBar::TimerProc() {
1345 PWL_SCROLL_PRIVATEDATA sTemp = m_sData;
1346
1347 if (m_bMinOrMax)
1348 m_sData.SubSmall();
1349 else
1350 m_sData.AddSmall();
1351
1352 if (FXSYS_memcmp(&m_sData, &sTemp, sizeof(PWL_SCROLL_PRIVATEDATA)) != 0) {
1353 MovePosButton(TRUE);
1354 NotifyScrollWindow();
1355 }
1332 } 1356 }
1333 1357
1334 /* 1358 /*
1335 void CPWL_ScrollBar::OnSetFocus() 1359 void CPWL_ScrollBar::OnSetFocus()
1336 { 1360 {
1337 » if (GetTransparency() != 255) 1361 if (GetTransparency() != 255)
1338 » { 1362 {
1339 » » SetTransparency(255); 1363 SetTransparency(255);
1340 » » InvalidateRect(); 1364 InvalidateRect();
1341 » } 1365 }
1342 } 1366 }
1343 1367
1344 void CPWL_ScrollBar::OnKillFocus() 1368 void CPWL_ScrollBar::OnKillFocus()
1345 { 1369 {
1346 » if (GetTransparency() != PWL_SCROLLBAR_TRANSPARANCY) 1370 if (GetTransparency() != PWL_SCROLLBAR_TRANSPARANCY)
1347 » { 1371 {
1348 » » SetTransparency(PWL_SCROLLBAR_TRANSPARANCY); 1372 SetTransparency(PWL_SCROLLBAR_TRANSPARANCY);
1349 » » InvalidateRect(); 1373 InvalidateRect();
1350 » } 1374 }
1351 } 1375 }
1352 */ 1376 */
1353
OLDNEW
« core/src/fdrm/crypto/fx_crypt_aes.cpp ('K') | « fpdfsdk/src/pdfwindow/PWL_Note.cpp ('k') | fpdfsdk/src/pdfwindow/PWL_Signature.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698