Tidied

git-svn-id: svn+ssh://svn.gna.org/svn/gnustep/libs/gui/trunk@3942 72102866-910b-0410-8b05-ffd578937521

Source/NSSlider.m

@@ -7,14 +7,14 @@
    Date: September 1997
    Author:  Felipe A. Rodriguez <far@ix.netcom.com>
    Date: August 1998
-   
+
    This file is part of the GNUstep GUI Library.
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
-   
+
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
@@ -37,254 +37,268 @@
 
 static Class cellClass;
 
-+ (void)initialize
++ (void) initialize
 {
   if (self == [NSSlider class])
     {
       // Initial version
-      [self setVersion:1];
+      [self setVersion: 1];
 
       // Set our cell class to NSSliderCell
-      [self setCellClass:[NSSliderCell class]];
+      [self setCellClass: [NSSliderCell class]];
     }
 }
 
-+ (void)setCellClass:(Class)class		{ cellClass = class; }
-+ (Class)cellClass						{ return cellClass; }
++ (void) setCellClass: (Class)class
+{
+  cellClass = class;
+}
 
-- initWithFrame:(NSRect)frameRect
++ (Class) cellClass
+{
+  return cellClass;
+}
+
+- (id) initWithFrame: (NSRect)frameRect
 {
   NSSliderCell* theCell = [[[isa cellClass] new] autorelease];
 
-  [super initWithFrame:frameRect];
+  [super initWithFrame: frameRect];
 
   // set our cell
-  [self setCell:theCell];
-  [theCell setState:1];
+  [self setCell: theCell];
+  [theCell setState: 1];
   return self;
 }
 
-- (NSImage *)image
+- (NSImage *) image
 {
   return [[self cell] image];
 }
 
-- (int)isVertical
+- (int) isVertical
 {
   return [[self cell] isVertical];
 }
 
-- (float)knobThickness
+- (float) knobThickness
 {
   return [[self cell] knobThickness];
 }
 
-- (void)setImage:(NSImage *)backgroundImage
+- (void) setImage: (NSImage *)backgroundImage
 {
-  [[self cell] setImage:backgroundImage];
+  [[self cell] setImage: backgroundImage];
 }
 
-- (void)setKnobThickness:(float)aFloat
+- (void) setKnobThickness: (float)aFloat
 {
-  [[self cell] setKnobThickness:aFloat];
+  [[self cell] setKnobThickness: aFloat];
 }
 
-- (void)setTitle:(NSString *)aString
+- (void) setTitle: (NSString *)aString
 {
-  [[self cell] setTitle:aString];
+  [[self cell] setTitle: aString];
 }
 
-- (void)setTitleCell:(NSCell *)aCell
+- (void) setTitleCell: (NSCell *)aCell
 {
-  [[self cell] setTitleCell:aCell];
+  [[self cell] setTitleCell: aCell];
 }
 
-- (void)setTitleColor:(NSColor *)aColor
+- (void) setTitleColor: (NSColor *)aColor
 {
-  [[self cell] setTitleColor:aColor];
+  [[self cell] setTitleColor: aColor];
 }
 
-- (void)setTitleFont:(NSFont *)fontObject
+- (void) setTitleFont: (NSFont *)fontObject
 {
-  [[self cell] setTitleFont:fontObject];
+  [[self cell] setTitleFont: fontObject];
 }
 
-- (NSString *)title
+- (NSString *) title
 {
   return [[self cell] title];
 }
 
-- (id)titleCell
+- (id) titleCell
 {
   return [[self cell] titleCell];
 }
 
-- (NSColor *)titleColor
+- (NSColor *) titleColor
 {
   return [[self cell] titleColor];
 }
 
-- (NSFont *)titleFont
+- (NSFont *) titleFont
 {
   return [[self cell] titleFont];
 }
 
-- (double)maxValue
+- (double) maxValue
 {
   return [[self cell] maxValue];
 }
 
-- (double)minValue
+- (double) minValue
 {
   return [[self cell] minValue];
 }
 
-- (void)setMaxValue:(double)aDouble
+- (void) setMaxValue: (double)aDouble
 {
-  [[self cell] setMaxValue:aDouble];
+  [[self cell] setMaxValue: aDouble];
 }
 
-- (void)setMinValue:(double)aDouble
+- (void) setMinValue: (double)aDouble
 {
-  [[self cell] setMinValue:aDouble];
+  [[self cell] setMinValue: aDouble];
 }
 
-- (BOOL)acceptsFirstMouse:(NSEvent *)theEvent
+- (BOOL) acceptsFirstMouse: (NSEvent *)theEvent
 {
   return YES;
 }
 
-- (void)drawRect:(NSRect)rect
+- (void) drawRect: (NSRect)rect
 {
-  [[self cell] drawWithFrame:rect inView:self];
+  [[self cell] drawWithFrame: rect inView: self];
 }
 
-- (float)_floatValueForMousePoint:(NSPoint)point knobRect:(NSRect)knobRect
+- (float)_floatValueForMousePoint: (NSPoint)point knobRect: (NSRect)knobRect
 {
-NSSliderCell* theCell = [self cell];
-NSRect slotRect = [theCell trackRect];
-BOOL isVertical = [theCell isVertical];
-float minValue = [theCell minValue];
-float maxValue = [theCell maxValue];
-float floatValue = 0;
-float position;
+  NSSliderCell* theCell = [self cell];
+  NSRect slotRect = [theCell trackRect];
+  BOOL isVertical = [theCell isVertical];
+  float minValue = [theCell minValue];
+  float maxValue = [theCell maxValue];
+  float floatValue = 0;
+  float position;
 
-	if (isVertical) 
-		{			// Adjust the point to lie inside the knob slot. We don't 
-					// have to worry whether the view is flipped or not.
-		if (point.y < slotRect.origin.y + knobRect.size.height / 2)
-			position = slotRect.origin.y + knobRect.size.height / 2;
-    	else 
-			if (point.y > slotRect.origin.y + slotRect.size.height
-			    	- knobRect.size.height / 2)
-      			position = slotRect.origin.y + slotRect.size.height
-			    			- knobRect.size.height / 2;
-    		else
-      			position = point.y;
-													// Compute the float value 
-    	floatValue = (position - (slotRect.origin.y + knobRect.size.height/2))
-		  				/ (slotRect.size.height - knobRect.size.height);
-   		if ([self isFlipped])
-      		floatValue = 1 - floatValue;
-  		}
-	else 
-		{						// Adjust the point to lie inside the knob slot 
-		if (point.x < slotRect.origin.x + knobRect.size.width / 2)
-			position = slotRect.origin.x + knobRect.size.width / 2;
-		else 
-			if (point.x > slotRect.origin.x + slotRect.size.width
-			    	- knobRect.size.width / 2)
-      			position = slotRect.origin.x + slotRect.size.width
-		    				- knobRect.size.width / 2;
-    		else
-      			position = point.x;
-													// Compute the float value
-						 							// given the knob size
-    	floatValue = (position - (slotRect.origin.x + knobRect.size.width / 2))
-		  				/ (slotRect.size.width - knobRect.size.width);
-  		}
+  // Adjust the point to lie inside the knob slot. We don't
+  // have to worry whether the view is flipped or not.
+  if (isVertical)
+    {
+      if (point.y < slotRect.origin.y + knobRect.size.height / 2)
+	{
+	  position = slotRect.origin.y + knobRect.size.height / 2;
+	}
+      else if (point.y > slotRect.origin.y + slotRect.size.height
+	- knobRect.size.height / 2)
+	{
+	  position = slotRect.origin.y + slotRect.size.height
+	    - knobRect.size.height / 2;
+	}
+      else
+	position = point.y;
+										      // Compute the float value
+      floatValue = (position - (slotRect.origin.y + knobRect.size.height/2))
+	/ (slotRect.size.height - knobRect.size.height);
+      if ([self isFlipped])
+	floatValue = 1 - floatValue;
+    }
+  else
+    {
+      if (point.x < slotRect.origin.x + knobRect.size.width / 2)
+	{
+	  position = slotRect.origin.x + knobRect.size.width / 2;
+	}
+      else if (point.x > slotRect.origin.x + slotRect.size.width
+	- knobRect.size.width / 2)
+	{
+	  position = slotRect.origin.x + slotRect.size.width
+	    - knobRect.size.width / 2;
+	}
+      else
+	position = point.x;
 
-	return floatValue * (maxValue - minValue) + minValue;
+      // Compute the float value given the knob size
+      floatValue = (position - (slotRect.origin.x + knobRect.size.width / 2))
+	/ (slotRect.size.width - knobRect.size.width);
+    }
+
+  return floatValue * (maxValue - minValue) + minValue;
 }
 
-- (void)trackKnob:(NSEvent*)theEvent knobRect:(NSRect)knobRect
+- (void) trackKnob: (NSEvent*)theEvent knobRect: (NSRect)knobRect
 {
-NSApplication *app = [NSApplication sharedApplication];
-unsigned int eventMask = NSLeftMouseDownMask | NSLeftMouseUpMask
-							| NSLeftMouseDraggedMask | NSMouseMovedMask
-							| NSPeriodicMask;
-NSPoint point = [self convertPoint:[theEvent locationInWindow] fromView:nil];
-NSEventType eventType = [theEvent type];
-BOOL isContinuous = [self isContinuous];
-NSSliderCell* theCell = [self cell];
-float oldFloatValue = [theCell floatValue];
-id target = [theCell target];
-SEL action = [theCell action];
+  NSApplication *app = [NSApplication sharedApplication];
+  unsigned int eventMask = NSLeftMouseDownMask | NSLeftMouseUpMask
+			  | NSLeftMouseDraggedMask | NSMouseMovedMask
+			  | NSPeriodicMask;
+  NSPoint point = [self convertPoint: [theEvent locationInWindow] fromView: nil];
+  NSEventType eventType = [theEvent type];
+  BOOL isContinuous = [self isContinuous];
+  NSSliderCell* theCell = [self cell];
+  float oldFloatValue = [theCell floatValue];
+  id target = [theCell target];
+  SEL action = [theCell action];
 
-	[NSEvent startPeriodicEventsAfterDelay:0.05 withPeriod:0.05];
-	[[NSRunLoop currentRunLoop] limitDateForMode:NSEventTrackingRunLoopMode];
+  [NSEvent startPeriodicEventsAfterDelay: 0.05 withPeriod: 0.05];
+  [[NSRunLoop currentRunLoop] limitDateForMode: NSEventTrackingRunLoopMode];
 
-	while (eventType != NSLeftMouseUp) 
+  while (eventType != NSLeftMouseUp)
+    {
+      theEvent = [app nextEventMatchingMask: eventMask
+				  untilDate: [NSDate distantFuture]
+				     inMode: NSEventTrackingRunLoopMode
+				    dequeue: YES];
+      eventType = [theEvent type];
+
+      if (eventType != NSPeriodic)
+	point = [self convertPoint: [theEvent locationInWindow]
+			  fromView: nil];
+      else
+	{
+	  if (point.x != knobRect.origin.x || point.y != knobRect.origin.y)
+	    {
+	      float floatValue = [self _floatValueForMousePoint: point
+						       knobRect: knobRect];
+
+	      if (floatValue != oldFloatValue)
 		{
-		theEvent = [app nextEventMatchingMask:eventMask
-						untilDate:[NSDate distantFuture] 
-						inMode:NSEventTrackingRunLoopMode
-						dequeue:YES];
-		eventType = [theEvent type];
-
-		if (eventType != NSPeriodic)
-      		point = [self convertPoint:[theEvent locationInWindow] 
-						  fromView:nil];
-		else
-			{
-			if (point.x != knobRect.origin.x || point.y != knobRect.origin.y) 
-				{
-				float floatValue = [self _floatValueForMousePoint:point
-										 knobRect:knobRect];
-
-				if (floatValue != oldFloatValue) 
-					{
-					[theCell setFloatValue:floatValue];
-					[theCell drawWithFrame:[self bounds] inView:self];
-					[window flushWindow];
-					if (isContinuous)
-	  					[target performSelector:action withObject:self];
-					oldFloatValue = floatValue;
-      				}
-      			knobRect.origin = point;
-    			}
-			}
-	}								 
-									// If the control is not continuous send
-	if (!isContinuous)				// the action at the end of the drag
-		[target performSelector:action withObject:self];
-	[NSEvent stopPeriodicEvents];
+		  [theCell setFloatValue: floatValue];
+		  [theCell drawWithFrame: [self bounds] inView: self];
+		  [window flushWindow];
+		  if (isContinuous)
+		    [target performSelector: action withObject: self];
+		  oldFloatValue = floatValue;
+		}
+	      knobRect.origin = point;
+	    }
+	}
+    }
+  // If the control is not continuous send the action at the end of the drag
+  if (!isContinuous)
+    [target performSelector: action withObject: self];
+  [NSEvent stopPeriodicEvents];
 }
 
-- (void)mouseDown:(NSEvent *)theEvent
+- (void) mouseDown: (NSEvent *)theEvent
 {
-NSPoint location = [self convertPoint:[theEvent locationInWindow]fromView:nil];
-NSSliderCell* theCell = [self cell];
-NSRect rect;
+  NSPoint location = [self convertPoint: [theEvent locationInWindow]fromView: nil];
+  NSSliderCell* theCell = [self cell];
+  NSRect rect;
 
-	[self lockFocus];
-	
-	rect = [theCell knobRectFlipped:[self isFlipped]];
-	if (![self mouse:location inRect:rect]) 
-		{									// Mouse is not on the knob, move 
-											// the knob to the mouse position 
-		float floatValue = [self _floatValueForMousePoint:location 
-								 knobRect:rect];
-	
-		[theCell setFloatValue:floatValue];
-		if ([self isContinuous])
-			[[theCell target] performSelector:[theCell action] 
-							  withObject:self];
-		[theCell drawWithFrame:[self bounds] inView:self];
-		[window flushWindow];
-		}
-	
-	[self trackKnob:theEvent knobRect:rect];
+  [self lockFocus];
+
+  rect = [theCell knobRectFlipped: [self isFlipped]];
+  if (![self mouse: location inRect: rect])
+    {
+      // Mouse is not on the knob, move the knob to the mouse position
+      float floatValue = [self _floatValueForMousePoint: location
+					       knobRect: rect];
+
+      [theCell setFloatValue: floatValue];
+      if ([self isContinuous])
+	[[theCell target] performSelector: [theCell action]
+			       withObject: self];
+      [theCell drawWithFrame: [self bounds] inView: self];
+      [window flushWindow];
+    }
+
+  [self trackKnob: theEvent knobRect: rect];
 }
 
 @end

Source/NSSliderCell.m

@@ -37,30 +37,35 @@
 
 @implementation NSSliderCell
 
-- init
+- (id) init
 {
-  [self initImageCell:nil];
+  [self initImageCell: nil];
   _altIncrementValue = -1;
   _isVertical = -1;
   _minValue = 0;
   _maxValue = 1;
   _floatValue = 0;
-  [self setBordered:YES];
-  [self setBezeled:YES];
+  [self setBordered: YES];
+  [self setBezeled: YES];
 
   _knobCell = [NSCell new];
 
   return self;
 }
 
-- (void)dealloc
+- (void) dealloc
 {
   [_titleCell release];
   [_knobCell release];
   [super dealloc];
 }
 
-- (void)setFloatValue:(float)aFloat
+- (BOOL) isFliped
+{
+  return YES;
+}
+
+- (void) setFloatValue: (float)aFloat
 {
   if (aFloat < _minValue)
     _floatValue = _minValue;
@@ -70,16 +75,13 @@
     _floatValue = aFloat;
 }
 
-- (void)drawBarInside:(NSRect)rect flipped:(BOOL)flipped
-{														// not per spec FIX ME
-	if ([self image])
-		return;
-
-	[[NSColor darkGrayColor] set];					
-	NSRectFill(rect);									// draw the bar
+- (void) drawBarInside: (NSRect)rect flipped: (BOOL)flipped
+{
+  [[NSColor scrollBarColor] set];					
+  NSRectFill(rect);
 }
 
-- (NSRect)knobRectFlipped:(BOOL)flipped
+- (NSRect) knobRectFlipped: (BOOL)flipped
 {
   NSImage* image = [_knobCell image];
   NSSize size;
@@ -107,17 +109,17 @@
   return NSMakeRect (origin.x, origin.y, size.width, size.height); 
 }
 
-- (void)drawKnob
+- (void) drawKnob
 {
-  [self drawKnob:[self knobRectFlipped:[[self controlView] isFlipped]]];
+  [self drawKnob: [self knobRectFlipped: [[self controlView] isFlipped]]];
 }
 
-- (void)drawKnob:(NSRect)knobRect
+- (void) drawKnob: (NSRect)knobRect
 {
-  [_knobCell drawInteriorWithFrame:knobRect inView:[self controlView]];
+  [_knobCell drawInteriorWithFrame: knobRect inView: [self controlView]];
 }
 
-- (void)drawInteriorWithFrame:(NSRect)cellFrame inView:(NSView*)controlView
+- (void) drawInteriorWithFrame: (NSRect)cellFrame inView: (NSView*)controlView
 {
   BOOL vertical = (cellFrame.size.height > cellFrame.size.width);
   NSImage* image;
@@ -125,16 +127,16 @@
 
   if (vertical != _isVertical) {
     if (vertical) {
-      image = [NSImage imageNamed:@"common_SliderVert"];
+      image = [NSImage imageNamed: @"common_SliderVert"];
       size = [image size];
-      [_knobCell setImage:image];
-      [image setSize:NSMakeSize (cellFrame.size.width, size.height)];
+      [_knobCell setImage: image];
+      [image setSize: NSMakeSize (cellFrame.size.width, size.height)];
     }
     else {
-      image = [NSImage imageNamed:@"common_SliderHoriz"];
+      image = [NSImage imageNamed: @"common_SliderHoriz"];
       size = [image size];
-      [_knobCell setImage:image];
-      [image setSize:NSMakeSize (size.width, cellFrame.size.height)];
+      [_knobCell setImage: image];
+      [image setSize: NSMakeSize (size.width, cellFrame.size.height)];
     }
   }
   _isVertical = vertical;
@@ -142,13 +144,13 @@
   _trackRect = cellFrame;
 
   if (_titleCell)
-    [_titleCell drawInteriorWithFrame:cellFrame inView:controlView];
+    [_titleCell drawInteriorWithFrame: cellFrame inView: controlView];
 
-  [self drawBarInside:cellFrame flipped:[controlView isFlipped]];
+  [self drawBarInside: cellFrame flipped: [controlView isFlipped]];
   [self drawKnob];
 }
 
-- (float)knobThickness
+- (float) knobThickness
 {
   NSImage* image = [_knobCell image];
   NSSize size = [image size];
@@ -156,7 +158,7 @@
   return _isVertical ? size.height : size.width;
 }
 
-- (void)setKnobThickness:(float)thickness
+- (void) setKnobThickness: (float)thickness
 {
   NSImage* image = [_knobCell image];
   NSSize size = [image size];
@@ -166,48 +168,48 @@
   else
     size.width = thickness;
 
-  [image setSize:size];
+  [image setSize: size];
 }
 
-- (void)setAltIncrementValue:(double)increment
+- (void) setAltIncrementValue: (double)increment
 {
   _altIncrementValue = increment;
 }
 
-- (void)setMinValue:(double)aDouble
+- (void) setMinValue: (double)aDouble
 {
   _minValue = aDouble;
   if (_floatValue < _minValue)
     _floatValue = _minValue;
 }
 
-- (void)setMaxValue:(double)aDouble
+- (void) setMaxValue: (double)aDouble
 {
   _maxValue = aDouble;
   if (_floatValue > _maxValue)
     _floatValue = _maxValue;
 }
 
-- (id)titleCell				{ return _titleCell; }
-- (NSColor*)titleColor			{ return [_titleCell textColor]; }
-- (NSFont*)titleFont			{ return [_titleCell font]; }
-- (void)setTitle:(NSString*)title	{ [_titleCell setStringValue:title]; }
-- (NSString*)title			{ return [_titleCell stringValue]; }
-- (void)setTitleCell:(NSCell*)aCell	{ ASSIGN(_titleCell, aCell); }
-- (void)setTitleColor:(NSColor*)color	{ [_titleCell setTextColor:color]; }
-- (void)setTitleFont:(NSFont*)font	{ [_titleCell setFont:font]; }
-- (int)isVertical			{ return _isVertical; }
-- (double)altIncrementValue		{ return _altIncrementValue; }
-+ (BOOL)prefersTrackingUntilMouseUp	{ return YES; }
-- (NSRect)trackRect			{ return _trackRect; }
-- (double)minValue			{ return _minValue; }
-- (double)maxValue			{ return _maxValue; }
-- (float)floatValue			{ return _floatValue; }
+- (id) titleCell				{ return _titleCell; }
+- (NSColor*) titleColor			{ return [_titleCell textColor]; }
+- (NSFont*) titleFont			{ return [_titleCell font]; }
+- (void) setTitle: (NSString*)title	{ [_titleCell setStringValue: title]; }
+- (NSString*) title			{ return [_titleCell stringValue]; }
+- (void) setTitleCell: (NSCell*)aCell	{ ASSIGN(_titleCell, aCell); }
+- (void) setTitleColor: (NSColor*)color	{ [_titleCell setTextColor: color]; }
+- (void) setTitleFont: (NSFont*)font	{ [_titleCell setFont: font]; }
+- (int) isVertical			{ return _isVertical; }
+- (double) altIncrementValue		{ return _altIncrementValue; }
++ (BOOL) prefersTrackingUntilMouseUp	{ return YES; }
+- (NSRect) trackRect			{ return _trackRect; }
+- (double) minValue			{ return _minValue; }
+- (double) maxValue			{ return _maxValue; }
+- (float) floatValue			{ return _floatValue; }
 
 - (id) initWithCoder: (NSCoder*)decoder
 {
   self = [super initWithCoder: decoder];
-  [decoder decodeValuesOfObjCTypes:"ffff",
+  [decoder decodeValuesOfObjCTypes: "ffff",
 	      &_minValue, &_maxValue, &_floatValue, &_altIncrementValue];
   return self;
 }
@@ -215,7 +217,7 @@
 - (void) encodeWithCoder: (NSCoder*)coder
 {
   [super encodeWithCoder: coder];
-  [coder encodeValuesOfObjCTypes:"ffff",
+  [coder encodeValuesOfObjCTypes: "ffff",
 	      &_minValue, &_maxValue, &_floatValue, &_altIncrementValue];
 }