1 /************************************************************************/
2 /* */
3 /* Document window application independent scrolling functionality. */
4 /* */
5 /************************************************************************/
6
7 # include "appFrameConfig.h"
8
9 # include <stddef.h>
10 # include <stdio.h>
11
12 # include "appFrame.h"
13 # include "appGuiKeys.h"
14 # include "guiWidgetDrawingSurface.h"
15 # include "guiDrawingWidget.h"
16 # include <geoUnits.h>
17
18 # include <appDebugon.h>
19
20 # define WHEEL_STEP 10
21 # define BAR_STEP 20
22
23 /************************************************************************/
24 /* */
25 /* Callbacks for the scrollbars, and the size admin of a document. */
26 /* */
27 /************************************************************************/
28
appDocScrollVertically(EditDocument * ed,int scrolledY)29 static void appDocScrollVertically( EditDocument * ed,
30 int scrolledY )
31 {
32 EditApplication * ea= ed->edApplication;
33 DrawingSurface ds= ed->edDrawingSurface;
34
35 int ox;
36 int oy;
37 int high;
38 int wide;
39
40 DocumentRectangle drClip;
41 DocumentRectangle drScreen;
42
43 drawNoClipping( ds );
44
45 drClip= ed->edFullRect;
46
47 high= ed->edVisibleRect.drY1- ed->edVisibleRect.drY0+ 1;
48 wide= ed->edVisibleRect.drX1- ed->edVisibleRect.drX0+ 1;
49
50 if ( scrolledY > 0 )
51 {
52 if ( high > scrolledY )
53 {
54 DocumentRectangle drSrc;
55
56 drSrc.drX0= 0;
57 drSrc.drX1= wide- 1;
58 drSrc.drY0= scrolledY;
59 drSrc.drY1= high- 1;
60
61 /*
62 drawMoveArea( ds, 0, scrolledY, wide, high- scrolledY, 0, 0 );
63 */
64 drawMoveArea( ds, 0, 0, &drSrc );
65
66 drClip.drY0= ed->edVisibleRect.drY1- scrolledY;
67 drClip.drY1= ed->edVisibleRect.drY1;
68 }
69 else{
70 drClip.drY0= ed->edVisibleRect.drY0;
71 drClip.drY1= ed->edVisibleRect.drY1;
72 }
73 }
74 else{
75 if ( high+ scrolledY > 0 )
76 {
77 DocumentRectangle drSrc;
78
79 drSrc.drX0= 0;
80 drSrc.drX1= wide- 1;
81 drSrc.drY0= 0;
82 drSrc.drY1= high+ scrolledY- 1;
83
84 /*
85 drawMoveArea( ds, 0, 0, wide, high+ scrolledY, 0, -scrolledY );
86 */
87 drawMoveArea( ds, 0, -scrolledY, &drSrc );
88
89 drClip.drY0= ed->edVisibleRect.drY0;
90 drClip.drY1= ed->edVisibleRect.drY0- scrolledY;
91 }
92 else{
93 drClip.drY0= ed->edVisibleRect.drY0;
94 drClip.drY1= ed->edVisibleRect.drY1;
95 }
96 }
97
98 ox= ed->edVisibleRect.drX0;
99 oy= ed->edVisibleRect.drY0;
100
101 drScreen= drClip;
102 geoShiftRectangle( &drScreen, -ox, -oy );
103
104 # if 1
105 drawSetClipRect( ds, &drScreen );
106 (*ea->eaDrawRectangle)( ed, &drClip, ox, oy );
107 drawNoClipping( ds );
108 # else
109 guiExposeDrawingWidgetRectangle( dw->dwWidget, &drScreen );
110 # endif
111
112 if ( ed->edLeftRuler && ea->eaScrollLeftRuler )
113 {
114 (*ea->eaScrollLeftRuler)
115 ( ed->edLeftRuler, ed->edLeftRulerWidget, scrolledY );
116 }
117
118 if ( ed->edRightRuler && ea->eaScrollRightRuler )
119 {
120 (*ea->eaScrollRightRuler)
121 ( ed->edRightRuler, ed->edRightRulerWidget, scrolledY );
122 }
123
124 return;
125 }
126
127 /************************************************************************/
128 /* */
129 /* Scroll horizontally. */
130 /* */
131 /************************************************************************/
132
appDocScrollHorizontally(EditDocument * ed,int scrolledX)133 static void appDocScrollHorizontally( EditDocument * ed,
134 int scrolledX )
135 {
136 EditApplication * ea= ed->edApplication;
137 DrawingSurface ds= ed->edDrawingSurface;
138
139 int ox;
140 int oy;
141 int high;
142 int wide;
143
144 DocumentRectangle drClip;
145 DocumentRectangle drScreen;
146
147 drawNoClipping( ds );
148
149 drClip= ed->edFullRect;
150
151 high= ed->edVisibleRect.drY1- ed->edVisibleRect.drY0+ 1;
152 wide= ed->edVisibleRect.drX1- ed->edVisibleRect.drX0+ 1;
153
154 if ( scrolledX > 0 )
155 {
156 if ( wide > scrolledX )
157 {
158 DocumentRectangle drSrc;
159
160 drSrc.drX0= scrolledX;
161 drSrc.drX1= wide- 1;
162 drSrc.drY0= 0;
163 drSrc.drY1= high- 1;
164
165 drawMoveArea( ds, 0, 0, &drSrc );
166
167 drClip.drX0= ed->edVisibleRect.drX1- scrolledX- 1;
168 drClip.drX1= ed->edVisibleRect.drX1;
169 }
170 else{
171 drClip.drX0= ed->edVisibleRect.drX0;
172 drClip.drX1= ed->edVisibleRect.drX1;
173 }
174 }
175 else{
176 if ( wide+ scrolledX > 0 )
177 {
178 DocumentRectangle drSrc;
179
180 drSrc.drX0= 0;
181 drSrc.drX1= wide+ scrolledX- 1;
182 drSrc.drY0= 0;
183 drSrc.drY1= high- 1;
184
185 drawMoveArea( ds, -scrolledX, 0, &drSrc );
186
187 drClip.drX0= ed->edVisibleRect.drX0;
188 drClip.drX1= ed->edVisibleRect.drX0- scrolledX;
189 }
190 else{
191 drClip.drX0= ed->edVisibleRect.drX0;
192 drClip.drX1= ed->edVisibleRect.drX1;
193 }
194 }
195
196 ox= ed->edVisibleRect.drX0;
197 oy= ed->edVisibleRect.drY0;
198
199 drScreen= drClip;
200 geoShiftRectangle( &drScreen, -ox, -oy );
201
202 # if 1
203 drawSetClipRect( ds, &drScreen );
204 (*ea->eaDrawRectangle)( ed, &drClip, ox, oy );
205 drawNoClipping( ds );
206 # else
207 guiExposeDrawingWidgetRectangle( dw->dwWidget, &drScreen );
208 # endif
209
210 if ( ed->edTopRuler && ea->eaScrollTopRuler )
211 {
212 (*ea->eaScrollTopRuler)
213 ( ed->edTopRuler, ed->edTopRulerWidget, scrolledX );
214 }
215
216 if ( ed->edBottomRuler && ea->eaScrollBottomRuler )
217 {
218 (*ea->eaScrollBottomRuler)
219 ( ed->edBottomRuler, ed->edBottomRulerWidget, scrolledX );
220 }
221
222 return;
223 }
224
appDocScrollToY(EditDocument * ed,int y)225 void appDocScrollToY( EditDocument * ed,
226 int y )
227 {
228 int scrolledY= y- ed->edVisibleRect.drY0;
229
230 if ( scrolledY == 0 )
231 { return; }
232
233 ed->edVisibleRect.drY0 += scrolledY;
234 ed->edVisibleRect.drY1 += scrolledY;
235
236 appDocScrollVertically( ed, scrolledY );
237
238 return;
239 }
240
appDocScrollToX(EditDocument * ed,int x)241 void appDocScrollToX( EditDocument * ed,
242 int x )
243 {
244 int scrolledX= x- ed->edVisibleRect.drX0;
245
246 if ( scrolledX == 0 )
247 { return; }
248
249 ed->edVisibleRect.drX0 += scrolledX;
250 ed->edVisibleRect.drX1 += scrolledX;
251
252 appDocScrollHorizontally( ed, scrolledX );
253
254 return;
255 }
256
APP_SCROLLBAR_CALLBACK_H(appDocVerticalScrollbarCallback,w,voided,e)257 APP_SCROLLBAR_CALLBACK_H( appDocVerticalScrollbarCallback, w, voided, e )
258 {
259 EditDocument * ed= (EditDocument *)voided;
260 int y= appGuiGetScrollbarValueFromCallback( w, e );
261
262 appDocScrollToY( ed, y );
263 }
264
APP_SCROLLBAR_CALLBACK_H(appDocHorizontalScrollbarCallback,w,voided,e)265 APP_SCROLLBAR_CALLBACK_H( appDocHorizontalScrollbarCallback, w, voided, e )
266 {
267 EditDocument * ed= (EditDocument *)voided;
268 int x= appGuiGetScrollbarValueFromCallback( w, e );
269
270 appDocScrollToX( ed, x );
271 }
272
273 /************************************************************************/
274 /* */
275 /* Scroll the selection into view. */
276 /* */
277 /* NOTE: sliderSize is passed to XmScrollBarSetValues() because of a */
278 /* bug in lesstif Release 0.87.0. (Jan 1999). */
279 /* */
280 /************************************************************************/
281
appScrollToRectangle(EditDocument * ed,const DocumentRectangle * dr,int * pScrolledX,int * pScrolledY)282 void appScrollToRectangle( EditDocument * ed,
283 const DocumentRectangle * dr,
284 int * pScrolledX,
285 int * pScrolledY )
286 {
287 int sliderSize;
288
289 int oox= ed->edVisibleRect.drX0;
290 int ooy= ed->edVisibleRect.drY0;
291 int nox;
292 int noy;
293
294 int changed= 0;
295
296 int visWide= ed->edVisibleRect.drX1- ed->edVisibleRect.drX0+ 1;
297 int visHigh= ed->edVisibleRect.drY1- ed->edVisibleRect.drY0+ 1;
298 int fullWide= ed->edFullRect.drX1- ed->edFullRect.drX0+ 1;
299 int fullHigh= ed->edFullRect.drY1- ed->edFullRect.drY0+ 1;
300
301 nox= oox;
302 noy= ooy;
303
304 appGuiGetScrollbarValues( &noy, &sliderSize, ed->edVerticalScrollbar );
305
306 if ( dr->drY0 <= ed->edVisibleRect.drY0 ||
307 dr->drY1 >= ed->edVisibleRect.drY1 )
308 {
309 noy= ( dr->drY0+ dr->drY1 )/ 2- visHigh/ 2;
310
311 if ( noy > fullHigh- visHigh )
312 { noy= fullHigh- visHigh; }
313 if ( noy < 0 )
314 { noy= 0; }
315 }
316
317 if ( noy != ooy )
318 {
319 appGuiSetScrollbarValues( ed->edVerticalScrollbar, noy, sliderSize );
320 changed= 1;
321 }
322
323 appGuiGetScrollbarValues( &nox, &sliderSize, ed->edHorizontalScrollbar );
324 /*
325 if ( nox != ed->edVisibleRect.drX0 )
326 { LLDEB(nox,ed->edVisibleRect.drX0); }
327 */
328
329 if ( dr->drX0 <= ed->edVisibleRect.drX0 ||
330 dr->drX1 >= ed->edVisibleRect.drX1 )
331 {
332 nox= ( dr->drX0+ dr->drX1 )/ 2- visWide/ 2;
333
334 if ( nox > fullWide- visWide )
335 { nox= fullWide- visWide; }
336 if ( nox < 0 )
337 { nox= 0; }
338 }
339
340 if ( nox != oox )
341 {
342 appGuiSetScrollbarValues( ed->edHorizontalScrollbar,
343 nox, sliderSize );
344 changed= 1;
345 }
346
347 {
348 int scrolledX= nox- oox;
349 int scrolledY= noy- ooy;
350
351 ed->edVisibleRect.drX0 += scrolledX;
352 ed->edVisibleRect.drY0 += scrolledY;
353 ed->edVisibleRect.drX1 += scrolledX;
354 ed->edVisibleRect.drY1 += scrolledY;
355
356 if ( scrolledX != 0 )
357 { appDocScrollHorizontally( ed, scrolledX ); }
358 if ( scrolledY != 0 )
359 { appDocScrollVertically( ed, scrolledY ); }
360
361 # ifdef USE_GTK
362 if ( changed )
363 { guiExposeDrawingWidget( ed->edDocumentWidget.dwWidget ); }
364 # endif
365
366 if ( pScrolledX )
367 { *pScrolledX= scrolledX; }
368 if ( pScrolledY )
369 { *pScrolledY= scrolledY; }
370 }
371
372 return;
373 }
374
375 /************************************************************************/
376 /* */
377 /* Prevent the Shell that contains a document from being resized */
378 /* beyond normal limits. */
379 /* */
380 /************************************************************************/
381
appFileAdaptHorizontalRulerRange(EditDocument * ed,int wide)382 static void appFileAdaptHorizontalRulerRange( EditDocument * ed,
383 int wide )
384 {
385 EditApplication * ea= ed->edApplication;
386
387 if ( ed->edTopRuler && ea->eaSetTopRulerRange )
388 {
389 (*ea->eaSetTopRulerRange)( ed->edTopRuler,
390 ed->edTopRulerWidget,
391 ed->edFullRect.drX1,
392 ed->edVisibleRect.drX0,
393 ed->edVisibleRect.drX1 );
394 }
395
396 if ( ed->edBottomRuler && ea->eaSetBottomRulerRange )
397 {
398 (*ea->eaSetBottomRulerRange)( ed->edBottomRuler,
399 ed->edBottomRulerWidget,
400 ed->edFullRect.drX1,
401 ed->edVisibleRect.drX0,
402 ed->edVisibleRect.drX1 );
403 }
404
405 return;
406 }
407
appFileAdaptVerticalRulerRange(EditDocument * ed,int high)408 static void appFileAdaptVerticalRulerRange( EditDocument * ed,
409 int high )
410 {
411 EditApplication * ea= ed->edApplication;
412
413 if ( ed->edLeftRuler && ea->eaSetLeftRulerRange )
414 {
415 (*ea->eaSetLeftRulerRange)( ed->edLeftRuler,
416 ed->edLeftRulerWidget,
417 ed->edFullRect.drY1,
418 ed->edVisibleRect.drY0,
419 ed->edVisibleRect.drY1 );
420 }
421
422 if ( ed->edRightRuler && ea->eaSetRightRulerRange )
423 {
424 (*ea->eaSetRightRulerRange)( ed->edRightRuler,
425 ed->edRightRulerWidget,
426 ed->edFullRect.drY1,
427 ed->edVisibleRect.drY0,
428 ed->edVisibleRect.drY1 );
429 }
430
431 return;
432 }
433
appDocAdaptToWidgetSize(EditDocument * ed,int wide,int high)434 static void appDocAdaptToWidgetSize( EditDocument * ed,
435 int wide,
436 int high )
437 {
438 int changed= 0;
439 int d;
440
441 if ( ed->edVisibleRect.drY1 != ed->edVisibleRect.drY0+ high- 1 )
442 {
443 ed->edVisibleRect.drY1= ed->edVisibleRect.drY0+ high- 1;
444 changed= 1;
445
446 if ( ed->edVisibleRect.drY1 > ed->edFullRect.drY1 )
447 {
448 d= ed->edVisibleRect.drY1- ed->edFullRect.drY1;
449
450 if ( d > ed->edVisibleRect.drY0 )
451 { d= ed->edVisibleRect.drY0; }
452
453 ed->edVisibleRect.drY0 -= d;
454 ed->edVisibleRect.drY1 -= d;
455 }
456
457 appFileAdaptVerticalRulerRange( ed, high );
458
459 guiExposeDrawingWidget( ed->edDocumentWidget.dwWidget );
460 }
461
462 if ( ed->edVisibleRect.drX1 != ed->edVisibleRect.drX0+ wide+ 1 )
463 {
464 ed->edVisibleRect.drX1= ed->edVisibleRect.drX0+ wide+ 1;
465 changed= 1;
466
467 if ( ed->edVisibleRect.drX1 > ed->edFullRect.drX1 )
468 {
469 d= ed->edVisibleRect.drX1- ed->edFullRect.drX1;
470
471 if ( d > ed->edVisibleRect.drX0 )
472 { d= ed->edVisibleRect.drX0; }
473
474 ed->edVisibleRect.drX0 -= d;
475 ed->edVisibleRect.drX1 -= d;
476 }
477
478 appFileAdaptHorizontalRulerRange( ed, wide );
479
480 guiExposeDrawingWidget( ed->edDocumentWidget.dwWidget );
481 }
482
483 if ( changed )
484 { appDocSetScrollbarValues( ed ); }
485
486 return;
487 }
488
appDocumentRulerWidth(EditApplication * ea,EditDocument * ed)489 void appDocumentRulerWidth( EditApplication * ea,
490 EditDocument * ed )
491 {
492 int mult;
493 const double pixPerMM= TWIPS_PER_MM* ea->eaPixelsPerTwip;
494
495 /* 1 */
496 ed->edLeftRulerWidePixels=
497 (int)( ea->eaLeftRulerWidthMM* pixPerMM );
498 ed->edTopRulerHighPixels=
499 (int)( ea->eaTopRulerHeightMM* pixPerMM );
500 ed->edRightRulerWidePixels=
501 (int)( ea->eaRightRulerWidthMM * pixPerMM );
502 ed->edBottomRulerHighPixels=
503 (int)( ea->eaBottomRulerHeightMM* pixPerMM );
504
505 mult= ea->eaLeftRulerWidthMultiple;
506 if ( mult )
507 {
508 ed->edLeftRulerWidePixels=
509 mult* ( ( ed->edLeftRulerWidePixels+ mult- 1 )/ mult );
510 }
511
512 mult= ea->eaTopRulerHeightMultiple;
513 if ( mult )
514 {
515 ed->edTopRulerHighPixels=
516 mult* ( ( ed->edTopRulerHighPixels+ mult- 1 )/ mult );
517 }
518
519 mult= ea->eaRightRulerWidthMultiple;
520 if ( mult )
521 {
522 ed->edRightRulerWidePixels=
523 mult* ( ( ed->edRightRulerWidePixels+ mult- 1 )/ mult );
524 }
525
526 mult= ea->eaBottomRulerHeightMultiple;
527 if ( mult )
528 {
529 ed->edBottomRulerHighPixels=
530 mult* ( ( ed->edBottomRulerHighPixels+ mult- 1 )/ mult );
531 }
532
533 return;
534 }
535
APP_EVENT_HANDLER_H(appDocConfigure,w,voided,event)536 APP_EVENT_HANDLER_H( appDocConfigure, w, voided, event )
537 {
538 EditDocument * ed= (EditDocument *)voided;
539
540 int wide;
541 int high;
542
543 if ( guiDrawGetSizeFromConfigureEvent( &wide, &high, w, event ) )
544 { return; }
545
546 appDocAdaptToWidgetSize( ed, wide, high );
547
548 return;
549 }
550
appMouseWheelDown(EditDocument * ed)551 void appMouseWheelDown( EditDocument * ed )
552 {
553 int ooy= ed->edVisibleRect.drY0;
554 int noy= ed->edVisibleRect.drY0;
555 int scrolledY;
556
557 int sliderSize;
558
559 sliderSize= ed->edVisibleRect.drY1- ed->edVisibleRect.drY0+ 1;
560 noy += ( sliderSize+ WHEEL_STEP- 1 )/ WHEEL_STEP;
561
562 if ( noy > ed->edFullRect.drY1- sliderSize )
563 { noy= ed->edFullRect.drY1- sliderSize; }
564
565 scrolledY= noy- ooy;
566
567 if ( scrolledY == 0 )
568 { return; }
569
570 ed->edVisibleRect.drY0 += scrolledY;
571 ed->edVisibleRect.drY1 += scrolledY;
572
573 appDocScrollVertically( ed, scrolledY );
574
575 appGuiSetScrollbarValues( ed->edVerticalScrollbar, noy, sliderSize );
576 }
577
appMouseWheelUp(EditDocument * ed)578 void appMouseWheelUp( EditDocument * ed )
579 {
580 int ooy= ed->edVisibleRect.drY0;
581 int noy= ed->edVisibleRect.drY0;
582 int scrolledY;
583
584 int sliderSize;
585
586 sliderSize= ed->edVisibleRect.drY1- ed->edVisibleRect.drY0+ 1;
587 noy -= ( sliderSize+ WHEEL_STEP- 1 )/ WHEEL_STEP;
588
589 if ( noy < 0 )
590 { noy= 0; }
591
592 scrolledY= noy- ooy;
593
594 if ( scrolledY == 0 )
595 { return; }
596
597 ed->edVisibleRect.drY0 += scrolledY;
598 ed->edVisibleRect.drY1 += scrolledY;
599
600 appDocScrollVertically( ed, scrolledY );
601
602 appGuiSetScrollbarValues( ed->edVerticalScrollbar, noy, sliderSize );
603 }
604
APP_EVENT_HANDLER_H(appScrollEventHandler,w,voided,scrollEvent)605 APP_EVENT_HANDLER_H( appScrollEventHandler, w, voided, scrollEvent )
606 {
607 EditDocument * ed= (EditDocument *)voided;
608 int direction= SCROLL_DIRECTION_FROM_EVENT( scrollEvent );
609
610 switch( direction )
611 {
612 # ifdef USE_MOTIF
613 case Button1:
614 case Button2:
615 case Button3:
616 break;
617 # endif
618
619 case SCROLL_UP:
620 appMouseWheelUp( ed );
621 break;
622
623 case SCROLL_DOWN:
624 appMouseWheelDown( ed );
625 break;
626
627 default:
628 LDEB(direction);
629 break;
630 }
631
632 return;
633 }
634
635
appDocSetScrollbarValues(EditDocument * ed)636 void appDocSetScrollbarValues( EditDocument * ed )
637 {
638 int sliderSize;
639 int maximum;
640 int minimum;
641 int value;
642
643 sliderSize= ed->edVisibleRect.drY1- ed->edVisibleRect.drY0+ 1;
644 minimum= ed->edFullRect.drY0;
645 value= ed->edVisibleRect.drY0;
646
647 if ( sliderSize >= ed->edFullRect.drY1+ 1 )
648 { maximum= ed->edVisibleRect.drY1+ 1; }
649 else{ maximum= ed->edFullRect.drY1+ 1; }
650
651 if ( value+ sliderSize > maximum )
652 { value= maximum- sliderSize; }
653
654 # ifdef USE_MOTIF
655 XtVaSetValues( ed->edVerticalScrollbar,
656 XmNminimum, minimum,
657 XmNmaximum, maximum,
658 XmNvalue, value,
659 XmNsliderSize, sliderSize,
660 XmNpageIncrement, ( 9* sliderSize+ 9 )/10,
661 XmNincrement, ( sliderSize+ BAR_STEP- 1 )/ BAR_STEP,
662 NULL );
663 # endif
664
665 # ifdef USE_GTK
666 ed->edVerticalAdjustment->lower= minimum;
667 ed->edVerticalAdjustment->upper= maximum;
668 ed->edVerticalAdjustment->value= value;
669 ed->edVerticalAdjustment->page_size= sliderSize;
670 ed->edVerticalAdjustment->page_increment= ( 9* sliderSize+ 9 )/10;
671 ed->edVerticalAdjustment->step_increment=
672 ( sliderSize+ BAR_STEP- 1 )/ BAR_STEP;
673
674 gtk_adjustment_changed( ed->edVerticalAdjustment );
675 # endif
676
677 sliderSize= ed->edVisibleRect.drX1- ed->edVisibleRect.drX0+ 1;
678 minimum= ed->edFullRect.drX0;
679 value= ed->edVisibleRect.drX0;
680
681 if ( sliderSize >= ed->edFullRect.drX1+ 1 )
682 { maximum= ed->edVisibleRect.drX1+ 1; }
683 else{ maximum= ed->edFullRect.drX1+ 1; }
684
685 # ifdef USE_MOTIF
686 XtVaSetValues( ed->edHorizontalScrollbar,
687 XmNminimum, minimum,
688 XmNmaximum, maximum,
689 XmNvalue, value,
690 XmNsliderSize, sliderSize,
691 NULL );
692 # endif
693
694 # ifdef USE_GTK
695 ed->edHorizontalAdjustment->lower= minimum;
696 ed->edHorizontalAdjustment->upper= maximum;
697 ed->edHorizontalAdjustment->value= value;
698 ed->edHorizontalAdjustment->page_size= sliderSize;
699
700 /* Otherwise, the contols at the end are inactive: */
701 ed->edHorizontalAdjustment->page_increment= ( 9* sliderSize+ 9 )/10;
702 ed->edHorizontalAdjustment->step_increment=
703 ( sliderSize+ BAR_STEP- 1 )/ BAR_STEP;
704
705 gtk_adjustment_changed( ed->edHorizontalAdjustment );
706 # endif
707
708 return;
709 }
710
711