libs-gui/Source/NSTextView.m

/* 
   NSTextView.m

   Copyright (C) 1999 Free Software Foundation, Inc.

   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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with this library; see the file COPYING.LIB.
   If not, write to the Free Software Foundation,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/ 


#include <gnustep/gui/config.h>
#include <Foundation/NSCoder.h>
#include <Foundation/NSArray.h>
#include <Foundation/NSException.h>
#include <Foundation/NSProcessInfo.h>
#include <Foundation/NSString.h>
#include <Foundation/NSNotification.h>
#include <AppKit/NSMatrix.h>
#include <AppKit/NSApplication.h>
#include <AppKit/NSWindow.h>
#include <AppKit/NSEvent.h>
#include <AppKit/NSFont.h>
#include <AppKit/NSColor.h>
#include <AppKit/NSTextView.h>
#include <AppKit/NSRulerView.h>
#include <AppKit/NSPasteboard.h>
#include <AppKit/NSSpellChecker.h>
#include <AppKit/NSFontPanel.h>
#include <AppKit/NSControl.h>
#include <AppKit/NSLayoutManager.h>
#include <AppKit/NSTextStorage.h>

@implementation NSTextView

/* Class methods */

+ (void) initialize
{
  [super initialize];

  if ([self class] == [NSTextView class])
    {
      [self setVersion: 1];
      [self registerForServices];
    }
}

+ (void) registerForServices
{
  NSArray	*r;
  NSArray	*s;
      
  /*
   * FIXME - should register for all types of data we support, not just string.
   */
  r  = [NSArray arrayWithObjects: NSStringPboardType, nil];
  s  = [NSArray arrayWithObjects: NSStringPboardType, nil];
 
  [[NSApplication sharedApplication] registerServicesMenuSendTypes: s
						       returnTypes: r];
}

/* Initializing Methods */

- (id) initWithFrame: (NSRect)frameRect
       textContainer: (NSTextContainer*)aTextContainer
{
  self = [super initWithFrame: frameRect];

  [self setTextContainer: aTextContainer];
  [self setEditable: YES];

  return self;
}

- (id) initWithFrame: (NSRect)frameRect
{
  textStorage = [[NSTextStorage alloc] init];

  layoutManager = [[NSLayoutManager alloc] init];

  [textStorage addLayoutManager: layoutManager];
  RELEASE(layoutManager);

  textContainer
    = [[NSTextContainer alloc] initWithContainerSize: frameRect.size];
  [layoutManager addTextContainer: textContainer];
  RELEASE(textContainer);

  return [self initWithFrame: frameRect textContainer: textContainer];
}

- (void) setTextContainer: (NSTextContainer*)aTextContainer
{
  ASSIGN(textContainer, aTextContainer);
}

- (NSTextContainer*) textContainer
{
  return textContainer;
}

- (void) replaceTextContainer: (NSTextContainer*)aTextContainer
{
  // Notify layoutManager of change?

  ASSIGN(textContainer, aTextContainer);
}

- (void) setTextContainerInset: (NSSize)inset
{
  textContainerInset = inset;
}

- (NSSize) textContainerInset
{
  return textContainerInset;
}

- (NSPoint) textContainerOrigin
{
  // use bounds, inset, and used rect.
  NSRect bRect = [self bounds];

  return NSZeroPoint;
}

- (void) invalidateTextContainerOrigin
{
  tv_resetTextContainerOrigin = YES;
}

- (NSLayoutManager*) layoutManager
{
  return [textContainer layoutManager];
}

- (NSTextStorage*) textStorage
{
  return textStorage;
}

- (void) setBackgroundColor: (NSColor*)aColor
{
  ASSIGN(tv_backGroundColor, aColor);
}

- (NSColor*) backgroundColor
{
  return tv_backGroundColor;
}

- (void) setDrawsBackground: (BOOL)flag
{
  tv_drawsBackground = flag;
}

- (BOOL) drawsBackground
{
  return tv_drawsBackground;
}

- (void) setNeedsDisplayInRect: (NSRect)aRect
	 avoidAdditionalLayout: (BOOL)flag
{
/*
  NSRange	glyphsToDraw;

  glyphsToDraw = [layoutManager glyphRangeForTextContainer: textContainer];
  [self lockFocus];
  [layoutManager drawGlyphsForGlyphRange: glyphsToDraw
				 atPoint: [self frame].origin];
  [self unlockFocus];
*/
}

/* We override NSView's setNeedsDisplayInRect: */

- (void) setNeedsDisplayInRect: (NSRect)aRect
{
  [self setNeedsDisplayInRect: aRect avoidAdditionalLayout: NO];
}

- (BOOL) shouldDrawInsertionPoint
{
  return tv_shouldDrawInsertionPoint;
}

- (void) drawInsertionPointInRect: (NSRect)aRect
			    color: (NSColor*)aColor
			 turnedOn: (BOOL)flag
{
  [self lockFocus];

  NSDebugLLog(@"NSText", 
    @"drawInsertionPointInRect: (%f, %f)", aRect.size.width, aRect.size.height);

  aRect.size.width = 1;

  if (flag)
    {
      [aColor set];
      NSRectFill(aRect);
    }
  else
    {
      [[self backgroundColor] set];
      NSRectFill(aRect);
    }

  [self unlockFocus];
  [_window flushWindow];
}

- (void) setConstrainedFrameSize: (NSSize)desiredSize
{
  // some black magic here.
  [self setFrameSize: desiredSize];
}

- (void) cleanUpAfterDragOperation
{
  // release drag information
}

- (void) setEditable: (BOOL)flag
{
  if (flag)
    tv_selectable = flag;

  tv_editable = flag;
}

- (BOOL) isEditable
{
  return tv_editable;
}

- (void) setSelectable: (BOOL)flag
{
  tv_selectable = flag;
}

- (BOOL) isSelectable
{
  return tv_selectable;
}

- (void) setFieldEditor: (BOOL)flag
{
  tv_fieldEditor = flag;
}

- (BOOL) isFieldEditor
{
  return tv_fieldEditor;
}

- (void) setRichText: (BOOL)flag
{
  if (!flag)
    tv_acceptDraggedFiles = flag;

  tv_richText = flag;
}

- (BOOL) isRichText
{
  return tv_richText;
}

- (void) setImportsGraphics: (BOOL)flag
{
  if (flag)
    tv_richText = flag;

  tv_acceptDraggedFiles = flag;
}

- (BOOL) importsGraphics
{
  return tv_acceptDraggedFiles;
}

- (void) setUsesFontPanel: (BOOL)flag
{
  tv_usesFontPanel = flag;
}

- (BOOL) usesFontPanel
{
  return tv_usesFontPanel;
}

- (void) setUsesRuler: (BOOL)flag
{
  tv_usesRuler = flag;
}

- (BOOL) usesRuler
{
  return tv_usesRuler;
}

- (void) setRulerVisible: (BOOL)flag
{
  tv_rulerVisible = flag;
}

- (BOOL) isRulerVisible
{
  return tv_rulerVisible;
}

- (void) setSelectedRange: (NSRange)charRange
{
  NSLog(@"setSelectedRange (%d, %d)", charRange.location, charRange.length);
/*
  [[NSNotificationCenter defaultCenter]
    postNotificationName: NSTextViewDidChangeSelectionNotification
    object: self];
*/
  tv_selectedRange = charRange;
  [self setSelectionGranularity: NSSelectByCharacter];

  // Also removes the marking from
  // marked text if the new selection is greater than the marked region.
}

- (NSRange) selectedRange
{
  return tv_selectedRange;
}

- (void) setSelectedRange: (NSRange)charRange
		 affinity: (NSSelectionAffinity)affinity
	   stillSelecting: (BOOL)flag
{
  NSDebugLLog(@"NSText", @"setSelectedRange stillSelecting.");

  tv_selectedRange = charRange;
  [self setSelectionGranularity: NSSelectByCharacter];

  // FIXME, more.
}

- (NSSelectionAffinity) selectionAffinity
{
  return tv_selectionAffinity;
}

- (void) setSelectionGranularity: (NSSelectionGranularity)granularity
{
  tv_selectionGranularity = granularity;
}

- (NSSelectionGranularity) selectionGranularity
{
  return tv_selectionGranularity;
}

- (void) setInsertionPointColor: (NSColor*)aColor
{
  ASSIGN(tv_caretColor, aColor);
}

- (NSColor*) insertionPointColor
{
  return tv_caretColor;
}

- (void) updateInsertionPointStateAndRestartTimer: (BOOL)flag
{
  // tv_caretLocation =

  // restart blinking timer.
}

- (void) setSelectedTextAttributes: (NSDictionary*)attributes
{
  ASSIGN(tv_selectedTextAttributes, attributes);
}

- (NSDictionary*) selectedTextAttributes
{
  return tv_selectedTextAttributes;
}

- (NSRange) markedRange
{
  // calculate

  return NSMakeRange(NSNotFound, 0);
}

- (void) setMarkedTextAttributes: (NSDictionary*)attributes
{
  ASSIGN(tv_markedTextAttributes, attributes);
}

- (NSDictionary*) markedTextAttributes
{
  return tv_markedTextAttributes;
}

- (NSString*) preferredPasteboardTypeFromArray: (NSArray*)availableTypes
		    restrictedToTypesFromArray: (NSArray*)allowedTypes
{
  // No idea.
}

- (BOOL) readSelectionFromPasteboard: (NSPasteboard*)pboard
{
/*
Reads the text view's preferred type of data from the pasteboard specified
by the pboard parameter. This method
invokes the preferredPasteboardTypeFromArray: restrictedToTypesFromArray: 
method to determine the text view's
preferred type of data and then reads the data using the
readSelectionFromPasteboard: type: method. Returns YES if the
data was successfully read.
*/

  return NO;
}

- (BOOL) readSelectionFromPasteboard: (NSPasteboard*)pboard
				type: (NSString*)type 
{
/*
Reads data of the given type from pboard. The new data is placed at the
current insertion point, replacing the current selection if one exists.
Returns YES if the data was successfully read.

You should override this method to read pasteboard types other than the
default types. Use the rangeForUserTextChange method to obtain the range
of characters (if any) to be replaced by the new data.
*/

  return NO;
}

- (NSArray*) readablePasteboardTypes
{
  // get default types, what are they?
}

- (NSArray*) writablePasteboardTypes
{
  // the selected text can be written to the pasteboard with which types.
}

- (BOOL) writeSelectionToPasteboard: (NSPasteboard*)pboard
			       type: (NSString*)type
{
/*
Writes the current selection to pboard using the given type. Returns YES
if the data was successfully written. You can override this method to add
support for writing new types of data to the pasteboard. You should invoke
super's implementation of the method to handle any types of data your
overridden version does not.
*/

  return NO;
}

- (BOOL) writeSelectionToPasteboard: (NSPasteboard*)pboard
			      types: (NSArray*)types
{

/* Writes the current selection to pboard under each type in the types
array. Returns YES if the data for any single type was written
successfully.

You should not need to override this method. You might need to invoke this
method if you are implementing a new type of pasteboard to handle services
other than copy/paste or dragging. */

  return NO;
}

- (void) alignJustified: (id)sender
{
/*
  if (!tv_richText)
    // if plain all text is jsutified.
  else
    // selected range is fully justified.
*/
}

- (void) changeColor: (id)sender
{
//  NSColor *aColor = [sender color];

  // sets the color for the selected range.
}

- (void) setAlignment: (NSTextAlignment)alignment
		range: (NSRange)aRange
{ 
/*
Sets the alignment of the paragraphs containing characters in aRange to
alignment. alignment is one of: 

      NSLeftTextAlignment
      NSRightTextAlignment 
      NSCenterTextAlignment 
      NSJustifiedTextAlignment 
      NSNaturalTextAlignment
*/
}

- (void) setTypingAttributes: (NSDictionary*)attributes
{
  // more?

  ASSIGN(tv_typingAttributes, attributes);
}

- (NSDictionary*) typingAttributes
{
  return tv_typingAttributes;
}

- (void) useStandardKerning: (id)sender
{
  // rekern for selected range if rich text, else rekern entire document.
}

- (void) lowerBaseline: (id)sender
{
/*
  if (tv_richText)
    // lower baseline by one point for selected text
  else
    // lower baseline for entire document.
*/
}

- (void) raiseBaseline: (id)sender
{
/*
  if (tv_richText)
    // raise baseline by one point for selected text
  else
    // raise baseline for entire document.
*/
}

- (void) turnOffKerning: (id)sender
{
/*
  if (tv_richText)
    // turn off kerning in selection.
  else
    // turn off kerning document wide.
*/
}

- (void) loosenKerning: (id)sender
{
/*
  if (tv_richText)
    // loosen kerning in selection.
  else
    // loosen kerning document wide.
*/
}

- (void) tightenKerning: (id)sender
{
/*
  if (tv_richText)
    // tighten kerning in selection.
  else
    // tighten kerning document wide.
*/
}

- (void) useStandardLigatures: (id)sender
{
  // well.
}

- (void) turnOffLigatures: (id)sender
{
  // sure.
}

- (void) useAllLigatures: (id)sender
{
  // as you say.
}

- (void) clickedOnLink: (id)link
	       atIndex: (unsigned int)charIndex
{

/* Notifies the delegate that the user clicked in a link at the specified
charIndex. The delegate may take any appropriate actions to handle the
click in its textView: clickedOnLink: atIndex: method.Notifies the delegate
that the user clicked in a link at the specified charIndex. The delegate
may take any appropriate actions to handle the click in its
textView: clickedOnLink: atIndex: method. */
 
}

/*
The text is inserted at the insertion point if there is one, otherwise
replacing the selection.
*/

- (void) pasteAsPlainText: (id)sender
{
  [self insertText: [sender string]];
}

- (void) pasteAsRichText: (id)sender
{
  [self insertText: [sender string]];
}

- (void) updateFontPanel
{
  // [fontPanel setFont: [self fontFromRange]];
}

- (void) updateRuler
{
  // ruler!
}

- (NSArray*) acceptableDragTypes
{
}

- (void) updateDragTypeRegistration
{
}

- (NSRange) selectionRangeForProposedRange: (NSRange)proposedSelRange
			       granularity: (NSSelectionGranularity)granularity
{
  NSRange retRange;

  switch (granularity)
    {
      case NSSelectByParagraph: 
        // we need to: 1, find how far to end of paragraph; 2, increase
        // range.
      case NSSelectByWord: 
        // we need to: 1, find how far to end of word; 2, increase range.
      case NSSelectByCharacter: 
      default: 
        retRange = proposedSelRange;
    }

  return retRange;
}

- (NSRange) rangeForUserCharacterAttributeChange
{
  if (!tv_editable || !tv_usesFontPanel)
    return NSMakeRange(NSNotFound, 0);

  if (tv_richText)
    return tv_selectedRange;
  else
    return NSMakeRange(NSNotFound, 0); // should be entire contents.
}

- (NSRange) rangeForUserParagraphAttributeChange
{
  if (!tv_editable)
    return NSMakeRange(NSNotFound, 0);

  if (tv_richText)
    return [self selectionRangeForProposedRange: tv_selectedRange
		granularity: NSSelectByParagraph];
  else
    return NSMakeRange(NSNotFound, 0); // should be entire contents.
}

- (NSRange) rangeForUserTextChange
{
  if (!tv_editable || !tv_usesRuler)
    return NSMakeRange(NSNotFound, 0);

  return tv_selectedRange;
}

- (BOOL) shouldChangeTextInRange: (NSRange)affectedCharRange
	       replacementString: (NSString*)replacementString
{
/*
This method checks with the delegate as needed using
textShouldBeginEditing: and
textView: shouldChangeTextInRange: replacementString: , returning YES to
allow the change, and NO to prohibit it.

This method must be invoked at the start of any sequence of user-initiated
editing changes. If your subclass of NSTextView implements new methods
that modify the text, make sure to invoke this method to determine whether
the change should be made. If the change is allowed, complete the change
by invoking the didChangeText method. See Notifying About Changes to the
Text in the class description for more information. If you can't determine
the affected range or replacement string before beginning changes, pass
(NSNotFound, 0) and nil for these values. */

  return NO;
}

- (void) didChangeText
{
  [[NSNotificationCenter defaultCenter]
    postNotificationName: NSTextDidChangeNotification object: self];
}

- (void) setSmartInsertDeleteEnabled: (BOOL)flag
{
  tv_smartInsertDelete = flag;
}

- (BOOL) smartInsertDeleteEnabled
{
  return tv_smartInsertDelete;
}

- (NSRange) smartDeleteRangeForProposedRange: (NSRange)proposedCharRange
{
// FIXME.
  return proposedCharRange;
}

- (void) smartInsertForString: (NSString*)aString
	       replacingRange: (NSRange)charRange
		 beforeString: (NSString*)beforeString 
		  afterString: (NSString*)afterString
{

/* Determines whether whitespace needs to be added around aString to
preserve proper spacing and punctuation when it's inserted into the
receiver's text over charRange. Returns by reference in beforeString and
afterString any whitespace that should be added, unless either or both is
nil. Both are returned as nil if aString is nil or if smart insertion and
deletion is disabled.

As part of its implementation, this method calls
smartInsertAfterStringForString: replacingRange: and
smartInsertBeforeStringForString: replacingRange: .To change this method's
behavior, override those two methods instead of this one.

NSTextView uses this method as necessary. You can also use it in
implementing your own methods that insert text. To do so, invoke this
method with the proper arguments, then insert beforeString, aString, and
afterString in order over charRange. */

}

- (BOOL) resignFirstResponder
{
/*
  if (nextRsponder == NSTextView_in_NSLayoutManager)
    return YES;
  else
    {
      if (![self textShouldEndEditing])
	return NO;
      else
	{
  	  [[NSNotificationCenter defaultCenter]
    	    postNotificationName: NSTextDidEndEditingNotification object: self];
	  // [self hideSelection];
	  return YES;
	}
    }
*/
  return YES;
}

- (BOOL) becomeFirstResponder
{
/*
  if (!nextRsponder == NSTextView_in_NSLayoutManager)
    {
      //draw selection
      //update the insertion point
    }
*/
  return YES;
}

- (id) validRequestorForSendType: (NSString*)sendType
		      returnType: (NSString*)returnType
{
/*
Returns self if sendType specifies a type of data the text view can put on
the pasteboard and returnType contains a type of data the text view can
read from the pasteboard; otherwise returns nil.
*/

 return nil;
}

- (int) spellCheckerDocumentTag
{
/*
  if (!tv_spellTag)
    tv_spellTag = [[NSSpellingServer sharedServer] uniqueSpellDocumentTag];
*/
  return tv_spellTag;
}

- (void) rulerView: (NSRulerView*)aRulerView
     didMoveMarker: (NSRulerMarker*)aMarker
{
/*
NSTextView checks for permission to make the change in its
rulerView: shouldMoveMarker: method, which invokes
shouldChangeTextInRange: replacementString: to send out the proper request
and notifications, and only invokes this
method if permission is granted.

  [self didChangeText];
*/
}

- (void) rulerView: (NSRulerView*)aRulerView
   didRemoveMarker: (NSRulerMarker*)aMarker
{
/*
NSTextView checks for permission to move or remove a tab stop in its
rulerView: shouldMoveMarker: method, which invokes
shouldChangeTextInRange: replacementString: to send out the proper request
and notifications, and only invokes this method if permission is granted.
*/
}

- (void) rulerView: (NSRulerView*)aRulerView
   handleMouseDown: (NSEvent*)theEvent
{
/*
This NSRulerView client method adds a left tab marker to the ruler, but a
subclass can override this method to provide other behavior, such as
creating guidelines. This method is invoked once with theEvent when the
user first clicks in the aRulerView's ruler area, as described in the
NSRulerView class specification.
*/
}

- (BOOL) rulerView: (NSRulerView*)aRulerView
   shouldAddMarker: (NSRulerMarker*)aMarker
{

/* This NSRulerView client method controls whether a new tab stop can be
added. The receiver checks for permission to make the change by invoking
shouldChangeTextInRange: replacementString: and returning the return value
of that message. If the change is allowed, the receiver is then sent a
rulerView: didAddMarker: message. */

  return NO;
}

- (BOOL) rulerView: (NSRulerView*)aRulerView
  shouldMoveMarker: (NSRulerMarker*)aMarker
{

/* This NSRulerView client method controls whether an existing tab stop
can be moved. The receiver checks for permission to make the change by
invoking shouldChangeTextInRange: replacementString: and returning the
return value of that message. If the change is allowed, the receiver is
then sent a rulerView: didAddMarker: message. */

  return NO;
}

- (BOOL) rulerView: (NSRulerView*)aRulerView
shouldRemoveMarker: (NSRulerMarker*)aMarker
{

/* This NSRulerView client method controls whether an existing tab stop
can be removed. Returns YES if aMarker represents an NSTextTab, NO
otherwise. Because this method can be invoked repeatedly as the user drags
a ruler marker, it returns that value immediately. If the change is allows
and the user actually removes the marker, the receiver is also sent a
rulerView: didRemoveMarker: message. */

  return NO;
}

- (float) rulerView: (NSRulerView*)aRulerView
      willAddMarker: (NSRulerMarker*)aMarker 
	 atLocation: (float)location
{

/* This NSRulerView client method ensures that the proposed location of
aMarker lies within the appropriate bounds for the receiver's text
container, returning the modified location. */

  return 0.0;
}

- (float) rulerView: (NSRulerView*)aRulerView
     willMoveMarker: (NSRulerMarker*)aMarker 
	 toLocation: (float)location
{

/* This NSRulerView client method ensures that the proposed location of
aMarker lies within the appropriate bounds for the receiver's text
container, returning the modified location. */

  return 0.0;
}

- (void) setDelegate: (id) anObject
{
  NSNotificationCenter  *nc = [NSNotificationCenter defaultCenter];

  [super setDelegate: anObject];
 
#define SET_DELEGATE_NOTIFICATION(notif_name) \
  if ([delegate respondsToSelector: @selector(textView##notif_name: )]) \
    [nc addObserver: delegate \
           selector: @selector(textView##notif_name: ) \
               name: NSTextView##notif_name##Notification \
             object: self]
 
  SET_DELEGATE_NOTIFICATION(DidChangeSelection);
  SET_DELEGATE_NOTIFICATION(WillChangeNotifyingTextView);
}

- (void) setString: (NSString*)string
{
  NSAttributedString	*aString;

  aString = [NSAttributedString alloc];
  aString = [aString initWithString: string
			 attributes: [self typingAttributes]];
  AUTORELEASE(aString);

//  [textStorage replaceRange: NSMakeRange(0, [string length])
//	withString: aString];

  [textStorage setAttributedString: aString];

//replaceCharactersInRange: NSMakeRange(0, [string length])
//                   withAttributedString: aString];

//  [textStorage insertAttributedString: aString atIndex: 0];
}

- (void) setText: (NSString*)string
{
  [self setString: string];
}

- (void) insertText: (NSString*)aString
{
  NSDebugLLog(@"NSText", @"%@", aString);

  if (![aString isKindOfClass: [NSAttributedString class]])
    aString = [[NSAttributedString alloc] initWithString: aString
		attributes: [self typingAttributes]];

  [textStorage replaceCharactersInRange: [self selectedRange]
       withAttributedString: (NSAttributedString*)aString];

  [self sizeToFit];                       // ScrollView interaction

  [self setSelectedRange: NSMakeRange([self 
    selectedRange].location+[aString length],0)];

  [self display];
  [_window update]; 

  NSLog(@"%@", [textStorage string]);
  /*
   * broadcast notification
   */
  [[NSNotificationCenter defaultCenter]
    postNotificationName: NSTextDidChangeNotification
    object: self];
}

- (void) sizeToFit
{
  NSLog(@"sizeToFit called.\n");
}

- (void) drawRect: (NSRect)aRect
{
  NSRange	glyphRange;

  if (tv_backGroundColor)
    {
      [tv_backGroundColor set];
      NSRectFill(aRect);
    }
  glyphRange = [layoutManager glyphRangeForTextContainer: textContainer];
  if (glyphRange.length > 0)
    {
      [layoutManager drawGlyphsForGlyphRange: glyphRange
				     atPoint: [self frame].origin];
    }
}

@end