Mercurial > hg > xemacs-beta

comparison lwlib/xlwgauge.c @ 5118:e0db3c197671 ben-lisp-object

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
merge up to latest default branch, doesn't compile yet
author Ben Wing <ben@xemacs.org>
date Sat, 26 Dec 2009 21:18:49 -0600
parents 5460287a3327
children 8b63e21b0436
comparison
equal deleted inserted replaced
5117:3742ea8250b5 5118:e0db3c197671
51 #include <ctype.h> 51 #include <ctype.h>
52 #include <X11/IntrinsicP.h> 52 #include <X11/IntrinsicP.h>
53 #include <X11/Xatom.h> 53 #include <X11/Xatom.h>
54 #include <X11/StringDefs.h> 54 #include <X11/StringDefs.h>
55 #include ATHENA_XawInit_h_ 55 #include ATHENA_XawInit_h_
56 #include "xt-wrappers.h"
56 #include "xlwgaugeP.h" 57 #include "xlwgaugeP.h"
57 #include "../src/xmu.h"
58 #ifdef HAVE_XMU
59 #include <X11/Xmu/Atoms.h> 58 #include <X11/Xmu/Atoms.h>
60 #include <X11/Xmu/Drawing.h> 59 #include <X11/Xmu/Drawing.h>
60 #include <X11/Xmu/Misc.h>
61 #include <X11/Xmu/StdSel.h> 61 #include <X11/Xmu/StdSel.h>
62 #endif
63 62
64 63
65 /**************************************************************** 64 /****************************************************************
66 * 65 *
67 * Gauge resources 66 * Gauge resources
75 <Btn2Up>: paste()\n\ 74 <Btn2Up>: paste()\n\
76 <Key>F2: paste(CLIPBOARD)" ; 75 <Key>F2: paste(CLIPBOARD)" ;
77 76
78 77
79 78
80 #define offset(field) XtOffsetOf(GaugeRec, field) 79 #define offset(field) XtOffsetOf(GaugeRec, gauge.field)
80 #define res(name,_class,intrepr,type,member,extrepr,value) \
81 Xt_RESOURCE (name, _class, intrepr, type, offset(member), extrepr, value)
81 static XtResource resources[] = { 82 static XtResource resources[] = {
82 {XtNvalue, XtCValue, XtRInt, sizeof(int), 83 res (XtNvalue, XtCValue, XtRInt, int, value, XtRImmediate, 0),
83 offset(gauge.value), XtRImmediate, (XtPointer)0}, 84 res (XtNminValue, XtCMinValue, XtRInt, int, v0, XtRImmediate, 0),
84 {XtNminValue, XtCMinValue, XtRInt, sizeof(int), 85 res (XtNmaxValue, XtCMaxValue, XtRInt, int, v1, XtRImmediate, 100),
85 offset(gauge.v0), XtRImmediate, (XtPointer)0}, 86 res (XtNntics, XtCNTics, XtRInt, int, ntics, XtRImmediate, 0),
86 {XtNmaxValue, XtCMaxValue, XtRInt, sizeof(int), 87 res (XtNnlabels, XtCNLabels, XtRInt, int, nlabels, XtRImmediate, 0),
87 offset(gauge.v1), XtRImmediate, (XtPointer)100}, 88 res (XtNlabels, XtCLabels, XtRStringArray, String *, labels,
88 {XtNntics, XtCNTics, XtRInt, sizeof(int), 89 XtRStringArray, NULL),
89 offset(gauge.ntics), XtRImmediate, (XtPointer) 0}, 90 res (XtNautoScaleUp, XtCAutoScaleUp, XtRBoolean, Boolean, autoScaleUp,
90 {XtNnlabels, XtCNLabels, XtRInt, sizeof(int), 91 XtRImmediate, FALSE),
91 offset(gauge.nlabels), XtRImmediate, (XtPointer) 0}, 92 res (XtNautoScaleDown, XtCAutoScaleDown, XtRBoolean, Boolean,
92 {XtNlabels, XtCLabels, XtRStringArray, sizeof(String *), 93 autoScaleDown, XtRImmediate, FALSE),
93 offset(gauge.labels), XtRStringArray, NULL}, 94 res (XtNorientation, XtCOrientation, XtROrientation, XtOrientation,
94 {XtNautoScaleUp, XtCAutoScaleUp, XtRBoolean, sizeof(Boolean), 95 orientation, XtRImmediate, XtorientHorizontal),
95 offset(gauge.autoScaleUp), XtRImmediate, FALSE}, 96 res (XtNupdate, XtCInterval, XtRInt, int, update, XtRImmediate, 0),
96 {XtNautoScaleDown, XtCAutoScaleDown, XtRBoolean, sizeof(Boolean), 97 res (XtNgetValue, XtCCallback, XtRCallback, XtPointer, getValue,
97 offset(gauge.autoScaleDown), XtRImmediate, FALSE}, 98 XtRImmediate, NULL),
98 {XtNorientation, XtCOrientation, XtROrientation, sizeof(XtOrientation),
99 offset(gauge.orientation), XtRImmediate, (XtPointer)XtorientHorizontal},
100 {XtNupdate, XtCInterval, XtRInt, sizeof(int),
101 offset(gauge.update), XtRImmediate, (XtPointer)0},
102 {XtNgetValue, XtCCallback, XtRCallback, sizeof(XtPointer),
103 offset(gauge.getValue), XtRImmediate, (XtPointer)NULL},
104 }; 99 };
105 #undef offset 100 #undef offset
106 101 #undef res
107 102
108 103
109 /* member functions */ 104 /* member functions */
110 105
111 static void GaugeClassInit (void); 106 static void GaugeClassInit (void);
130 static void AutoScale (GaugeWidget); 125 static void AutoScale (GaugeWidget);
131 static void EnableUpdate (GaugeWidget); 126 static void EnableUpdate (GaugeWidget);
132 static void DisableUpdate (GaugeWidget); 127 static void DisableUpdate (GaugeWidget);
133 128
134 static void GaugeGetValue (XtPointer, XtIntervalId *); 129 static void GaugeGetValue (XtPointer, XtIntervalId *);
135 static void GaugeMercury (Display *, Window, GC, GaugeWidget, Cardinal, Cardinal); 130 static void GaugeMercury (Display *, Window, GC, GaugeWidget, int, int);
136 131
137 static Boolean GaugeConvert (Widget, Atom *, Atom *, Atom *, 132 static Boolean GaugeConvert (Widget, Atom *, Atom *, Atom *,
138 XtPointer *, unsigned long *, int *); 133 XtPointer *, unsigned long *, int *);
139 static void GaugeLoseSel (Widget, Atom *); 134 static void GaugeLoseSel (Widget, Atom *);
140 static void GaugeDoneSel (Widget, Atom *, Atom *); 135 static void GaugeDoneSel (Widget, Atom *, Atom *);
144 static GC Get_GC (GaugeWidget, Pixel); 139 static GC Get_GC (GaugeWidget, Pixel);
145 140
146 141
147 static XtActionsRec actionsList[] = 142 static XtActionsRec actionsList[] =
148 { 143 {
149 {"select", GaugeSelect}, 144 { (String) "select", GaugeSelect },
150 {"paste", GaugePaste}, 145 { (String) "paste", GaugePaste },
151 } ; 146 } ;
152 147
153 148
154 149
155 /**************************************************************** 150 /****************************************************************
160 155
161 GaugeClassRec gaugeClassRec = { 156 GaugeClassRec gaugeClassRec = {
162 { 157 {
163 /* core_class fields */ 158 /* core_class fields */
164 /* superclass */ (WidgetClass) &labelClassRec, 159 /* superclass */ (WidgetClass) &labelClassRec,
165 /* class_name */ "Gauge", 160 /* class_name */ (String) "Gauge",
166 /* widget_size */ sizeof(GaugeRec), 161 /* widget_size */ sizeof(GaugeRec),
167 /* class_initialize */ GaugeClassInit, 162 /* class_initialize */ GaugeClassInit,
168 /* class_part_initialize */ NULL, 163 /* class_part_initialize */ NULL,
169 /* class_inited */ FALSE, 164 /* class_inited */ FALSE,
170 /* initialize */ GaugeInit, 165 /* initialize */ GaugeInit,
227 222
228 static void 223 static void
229 GaugeClassInit (void) 224 GaugeClassInit (void)
230 { 225 {
231 XawInitializeWidgetSet(); 226 XawInitializeWidgetSet();
232 #ifdef HAVE_XMU
233 XtAddConverter(XtRString, XtROrientation, XmuCvtStringToOrientation, 227 XtAddConverter(XtRString, XtROrientation, XmuCvtStringToOrientation,
234 NULL, 0) ; 228 NULL, 0) ;
235 #endif
236 } 229 }
237 230
238 231
239 232
240 /* ARGSUSED */ 233 /* ARGSUSED */
641 634
642 printf( "requesting selection %s:%s\n", 635 printf( "requesting selection %s:%s\n",
643 XGetAtomName(XtDisplay(w),*selection), 636 XGetAtomName(XtDisplay(w),*selection),
644 XGetAtomName(XtDisplay(w),*target)); 637 XGetAtomName(XtDisplay(w),*target));
645 638
646 #ifdef HAVE_XMU
647 if( *target == XA_TARGETS(XtDisplay(w)) ) 639 if( *target == XA_TARGETS(XtDisplay(w)) )
648 { 640 {
649 XPointer stdTargets; 641 XPointer stdTargets;
650 Atom *rval ; 642 Atom *rval ;
651 unsigned long stdLength ; 643 unsigned long stdLength ;
670 XtFree((char*) stdTargets) ; 662 XtFree((char*) stdTargets) ;
671 *format = 8*sizeof(Atom) ; /* TODO: needed? */ 663 *format = 8*sizeof(Atom) ; /* TODO: needed? */
672 return True ; 664 return True ;
673 } 665 }
674 666
675 else 667 else if( *target == XA_INTEGER )
676 #endif
677 if( *target == XA_INTEGER )
678 { 668 {
679 *type = XA_INTEGER ; 669 *type = XA_INTEGER ;
680 *length = 1 ; 670 *length = 1 ;
681 *value = (XtPointer) &gw->gauge.value ; 671 *value = (XtPointer) &gw->gauge.value ;
682 *format = 8*sizeof(int) ; 672 *format = 8*sizeof(int) ;
683 return True ; 673 return True ;
684 } 674 }
685 675
686 else if( *target == XA_STRING 676 else if( *target == XA_STRING || *target == XA_TEXT(XtDisplay(w)) )
687 #ifdef HAVE_XMU
688 ||
689 *target == XA_TEXT(XtDisplay(w))
690 #endif
691 )
692 { 677 {
693 *type = *target ; 678 *type = *target ;
694 *length = strlen(gw->gauge.selstr)*sizeof(char) ; 679 *length = strlen(gw->gauge.selstr)*sizeof(char) ;
695 *value = (XtPointer) gw->gauge.selstr ; 680 *value = (XtPointer) gw->gauge.selstr ;
696 *format = 8 ; 681 *format = 8 ;
698 } 683 }
699 684
700 else 685 else
701 { 686 {
702 /* anything else, we just give it to XmuConvertStandardSelection() */ 687 /* anything else, we just give it to XmuConvertStandardSelection() */
703 #ifdef HAVE_XMU
704 req = XtGetSelectionRequest(w, *selection, NULL) ; 688 req = XtGetSelectionRequest(w, *selection, NULL) ;
705 if( XmuConvertStandardSelection(w, req->time, selection, target, 689 if( XmuConvertStandardSelection(w, req->time, selection, target,
706 type, (XPointer *) value, length, format) ) 690 type, (XPointer *) value, length, format) )
707 return True ; 691 return True ;
708 else 692 else {
709 #endif
710 {
711 printf( 693 printf(
712 "Gauge: requestor is requesting unsupported selection %s:%s\n", 694 "Gauge: requestor is requesting unsupported selection %s:%s\n",
713 XGetAtomName(XtDisplay(w),*selection), 695 XGetAtomName(XtDisplay(w),*selection),
714 XGetAtomName(XtDisplay(w),*target)); 696 XGetAtomName(XtDisplay(w),*target));
715 return False ; 697 return False ;
716 } 698 }
717 } 699 }
718 } 700 }
783 if( *type == XA_INTEGER ) { 765 if( *type == XA_INTEGER ) {
784 iptr = (int *)value ; 766 iptr = (int *)value ;
785 XawGaugeSetValue(w, *iptr) ; 767 XawGaugeSetValue(w, *iptr) ;
786 } 768 }
787 769
788 else if( *type == XA_STRING 770 else if( *type == XA_STRING || *type == XA_TEXT(dpy) ) {
789 #ifdef HAVE_XMU
790 ||
791 *type == XA_TEXT(dpy)
792 #endif
793 )
794 {
795 cptr = (char *)value ; 771 cptr = (char *)value ;
796 XawGaugeSetValue(w, atoi(cptr)) ; 772 XawGaugeSetValue(w, atoi(cptr)) ;
797 } 773 }
798 774
799 /* failed, try string */ 775 /* failed, try string */
815 /* Change gauge value. Only undraw or draw what needs to be 791 /* Change gauge value. Only undraw or draw what needs to be
816 * changed. 792 * changed.
817 */ 793 */
818 794
819 void 795 void
820 XawGaugeSetValue (Widget w, 796 XawGaugeSetValue (Widget w, int value)
821 Cardinal value)
822 { 797 {
823 GaugeWidget gw = (GaugeWidget)w ; 798 GaugeWidget gw = (GaugeWidget)w ;
824 int oldvalue ; 799 int oldvalue ;
825 GC gc ; 800 GC gc ;
826 801
836 811
837 /* need to rescale? */ 812 /* need to rescale? */
838 if(( gw->gauge.autoScaleUp && (int) value > gw->gauge.v1) || 813 if(( gw->gauge.autoScaleUp && (int) value > gw->gauge.v1) ||
839 (gw->gauge.autoScaleDown && (int) value < gw->gauge.v1/3 )) 814 (gw->gauge.autoScaleDown && (int) value < gw->gauge.v1/3 ))
840 { 815 {
841 XtVaSetValues(w, XtNvalue, value, 0) ; 816 XtVaSetValues(w, XtNvalue, value, NULL) ;
842 return ; 817 return ;
843 } 818 }
844 819
845 oldvalue = gw->gauge.value ; 820 oldvalue = gw->gauge.value ;
846 gw->gauge.value = value ; 821 gw->gauge.value = value ;
848 gc = XtIsSensitive(w) ? gw->label.normal_GC : gw->label.gray_GC ; 823 gc = XtIsSensitive(w) ? gw->label.normal_GC : gw->label.gray_GC ;
849 GaugeMercury(XtDisplay(w), XtWindow(w), gc, gw, oldvalue,value) ; 824 GaugeMercury(XtDisplay(w), XtWindow(w), gc, gw, oldvalue,value) ;
850 } 825 }
851 826
852 827
853 Cardinal 828 int
854 XawGaugeGetValue (Widget w) 829 XawGaugeGetValue (Widget w)
855 { 830 {
856 GaugeWidget gw = (GaugeWidget)w ; 831 GaugeWidget gw = (GaugeWidget)w ;
857 return gw->gauge.value ; 832 return gw->gauge.value ;
858 } 833 }
871 static void 846 static void
872 GaugeMercury (Display *dpy, 847 GaugeMercury (Display *dpy,
873 Window win, 848 Window win,
874 GC gc, 849 GC gc,
875 GaugeWidget gw, 850 GaugeWidget gw,
876 Cardinal val0, 851 int val0,
877 Cardinal val1) 852 int val1)
878 { 853 {
879 int v0 = gw->gauge.v0 ; 854 int v0 = gw->gauge.v0 ;
880 int v1 = gw->gauge.v1 ; 855 int v1 = gw->gauge.v1 ;
881 int vd = v1 - v0 ; 856 int vd = v1 - v0 ;
882 Dimension len ; /* length (width or height) of gauge */ 857 Dimension len ; /* length (width or height) of gauge */
891 e0 = gw->gauge.margin0 ; /* left (top) end */ 866 e0 = gw->gauge.margin0 ; /* left (top) end */
892 e1 = len - gw->gauge.margin1 -1 ; /* right (bottom) end */ 867 e1 = len - gw->gauge.margin1 -1 ; /* right (bottom) end */
893 868
894 if( vd <= 0 ) vd = 1 ; 869 if( vd <= 0 ) vd = 1 ;
895 870
896 if( (int) val0 < v0 ) val0 = v0 ; 871 if( val0 < v0 ) val0 = v0 ;
897 else if( (int) val0 > v1 ) val0 = v1 ; 872 else if( val0 > v1 ) val0 = v1 ;
898 if( (int) val1 < v0 ) val1 = v0 ; 873 if( val1 < v0 ) val1 = v0 ;
899 else if( (int) val1 > v1 ) val1 = v1 ; 874 else if( val1 > v1 ) val1 = v1 ;
900 875
901 p0 = (val0-v0)*(e1-e0-1)/vd ; 876 p0 = (val0-v0)*(e1-e0-1)/vd ;
902 p1 = (val1-v0)*(e1-e0-1)/vd ; 877 p1 = (val1-v0)*(e1-e0-1)/vd ;
903 878
904 if( p1 == p0 ) 879 if( p1 == p0 )
1106 static void 1081 static void
1107 GaugeGetValue (XtPointer clientData, 1082 GaugeGetValue (XtPointer clientData,
1108 XtIntervalId *UNUSED (intervalId)) 1083 XtIntervalId *UNUSED (intervalId))
1109 { 1084 {
1110 GaugeWidget gw = (GaugeWidget)clientData ; 1085 GaugeWidget gw = (GaugeWidget)clientData ;
1111 Cardinal value ; 1086 int value ;
1112 1087
1113 if( gw->gauge.update > 0 ) 1088 if( gw->gauge.update > 0 )
1114 EnableUpdate(gw) ; 1089 EnableUpdate(gw) ;
1115 1090
1116 if( gw->gauge.getValue != NULL ) 1091 if( gw->gauge.getValue != NULL )