apps-gorm/Plugins/Xib/GormXibWrapperLoader.m

/* GormXibWrapperLoader
 *
 * Copyright (C) 2010, 2021 Free Software Foundation, Inc.
 *
 * Author:      Gregory John Casamento <greg_casamento@yahoo.com>
 * Date:        2010, 2021
 *
 * This file is part of GNUstep.
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program 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 General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111 USA.
 */

#include <Foundation/Foundation.h>
#include <AppKit/AppKit.h>

#include <GNUstepGUI/GSXibKeyedUnarchiver.h>
#include <GormCore/GormCore.h>

#include "GormXibWrapperLoader.h"

/*
 * Forward declarations for classes
 */
@class GormNSWindow, GormNSMenu;

/*
 * This allows us to retrieve the customClasses from the XIB unarchiver.
 */

@interface NSKeyedUnarchiver (Private)
- (NSDictionary *) customClasses;
- (NSDictionary *) decoded;
@end


/*
 * Xib loader...
 */
@implementation GormXibWrapperLoader

+ (NSString *) fileType
{
  return @"GSXibFileType";
}

- (instancetype) init
{
  self = [super init];
  if (self != nil)
    {
      _idToName = [[NSMutableDictionary alloc] init];
      _container = nil;
      _nibFilesOwner = nil;
    }
  return self;
}

- (void) dealloc
{
  RELEASE(_idToName);
  [super dealloc];
}

- (id) _replaceProxyInstanceWithRealObject: (id)obj
			      classManager: (GormClassManager *)classManager
				    withID: (NSString *)theId
{
  NSString *className = [obj className];
  
  if ([obj isKindOfClass: [NSCustomObject class]])
    {
      if ([className isEqualToString: @"NSApplication"])
        {
          return [document filesOwner];
        }
      else if ([className isEqualToString: @"FirstResponder"])
        {
          return [document firstResponder];
        }
    }
  else if ([obj respondsToSelector: @selector(className)])
    {
      NSString *cn = [obj className];
      NSDebugLog(@"className = %@", cn);
    }
  else if (obj == nil)
    {
      id o = [_idToName objectForKey: theId];
      if (o != nil)
	{
	  return o;
	}
      else
	{
	  return [document firstResponder];
	}
    }
  
  return obj;
}

- (BOOL) loadFileWrapper: (NSFileWrapper *)wrapper withDocument: (GormDocument *) doc
{
  BOOL result = NO;

  NS_DURING
    {
      GormPalettesManager       *palettesManager = [(id<GormAppDelegate>)[NSApp delegate] palettesManager];
      NSDictionary              *substituteClasses = [palettesManager substituteClasses];
      NSString                  *subClassName = nil;
      GormClassManager          *classManager = [doc classManager];

      if ([super loadFileWrapper: wrapper 
                    withDocument: doc] &&
	  [wrapper isDirectory] == NO)
	{
	  NSData *data = [wrapper regularFileContents];
	  id docFilesOwner;

	  // turn off custom classes...
	  [NSClassSwapper setIsInInterfaceBuilder: YES];	  
	  
	  // check the data...
	  if (data == nil) 
	    {
	      result = NO;
	    }
	  else
	    {
              NSEnumerator *en;
              NSKeyedUnarchiver *u; // using superclass for its interface.

	      //
	      // Create an unarchiver, and use it to unarchive the xib file while
	      // handling class replacement so that standard objects understood
	      // by the gui library are converted to their Gorm internal equivalents.
	      //
	      u = [GSXibKeyedUnarchiver unarchiverForReadingWithData: data];
	      [u setDelegate: self];
	      
	      //
	      // Special internal classes
	      // 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wreceiver-forward-class"
	      [u setClass: [GormCustomView class] 
		 forClassName: @"NSCustomView"];
	      [u setClass: [GormWindowTemplate class] 
		 forClassName: @"NSWindowTemplate"];
	      [u setClass: [GormNSWindow class] 
		 forClassName: @"NSWindow"];
	      [u setClass: [GormNSMenu class] 
		 forClassName: @"NSMenu"];
              [u setClass: [IBUserDefinedRuntimeAttribute class]
                 forClassName: @"IBUserDefinedRuntimeAttribute5"];
#pragma GCC diagnostic pop
	      
	      //
	      // Substitute any classes specified by the palettes...
	      //
	      en = [substituteClasses keyEnumerator];
	      while ((subClassName = [en nextObject]) != nil)
		{
		  NSString *realClassName = [substituteClasses objectForKey: subClassName];
		  Class substituteClass = NSClassFromString(subClassName);
		  [u setClass: substituteClass
		     forClassName: realClassName];
		}
	      
	      //
	      // decode
	      //
	      _container = [u decodeObjectForKey: @"IBDocument.Objects"];
	      if (_container == nil || [_container isKindOfClass: [IBObjectContainer class]] == NO)
		{
		  result = NO;
		}
	      else
		{
		  IBConnectionRecord *cr = nil;
                  NSArray *rootObjects = nil;
                  id xibFirstResponder = nil;
		  id xibFontManager = nil;
		  
                  rootObjects = [u decodeObjectForKey: @"IBDocument.RootObjects"];
		  _nibFilesOwner = [rootObjects objectAtIndex: 0];
		  xibFirstResponder = [rootObjects objectAtIndex: 1];
		  docFilesOwner = [doc filesOwner];
		  // xibFontManager = [self _findFontManager: rootObjects];
		  
		  //
		  // set the current class on the File's owner...
		  //
		  if ([_nibFilesOwner isKindOfClass: [NSCustomObject class]])
		    {
		      [docFilesOwner setClassName: [_nibFilesOwner className]];	  
		    }
		  
		  //
		  // add root objects...
		  //
		  en = [rootObjects objectEnumerator];
                  id obj = nil;
		  while ((obj = [en nextObject]) != nil)
		    {
		      NSString *customClassName = nil;
		      NSString *objName = nil;
		      
		      // skip the file's owner, it is handled above...
		      if ((obj == _nibFilesOwner)
			  || (obj == xibFirstResponder)
			  || (obj == xibFontManager))
                        {
                          continue;
                        }

                      //
                      // If it's NSApplication (most likely the File's Owner)
                      // skip it...
                      //
                      if ([obj isKindOfClass: [NSCustomObject class]])
                        {
                          if ([[obj className] isEqualToString: @"NSApplication"])
                            {
                              continue;
                            }

                          customClassName = [obj className];
                        }
                      
		      //
		      // if it's a window template, then replace it with an
                      // actual window.
		      //
                      id o = nil;
		      if ([obj isKindOfClass: [GormWindowTemplate class]])
			{
			  NSString *className = [obj className];
			  BOOL isDeferred = [obj isDeferred];
			  BOOL isVisible = YES;
                          
			  // make the object deferred/visible...
			  o = [obj nibInstantiate];
                          NSDebugLog(@"Decoding window as %@", o);
			  
			  [doc setObject: o isDeferred: isDeferred];
			  [doc setObject: o isVisibleAtLaunch: isVisible];

                          // Add to the document...			  
                          [doc attachObject: o
                                   toParent: nil];			  
			  
			  // record the custom class...
			  if ([classManager isCustomClass: className])
			    {
			      customClassName = className;
			    }
			}
		      
		      if ([rootObjects containsObject: obj] && obj != nil &&
                          [obj isKindOfClass: [GormWindowTemplate class]] == NO)
			{
                          NSLog(@"obj = %@",obj);
			  if ([obj respondsToSelector: @selector(className)])
			    {
			      if ([obj isKindOfClass: [NSCustomObject class]])
				{
				  NSLog(@"Skipping NSCustomObject %@ -- adding custom class using GormDocument methods...", obj);
				  continue;
				}
			    }
			  
                          [doc attachObject: obj
				   toParent: nil];
                        }
                      
		      if (customClassName != nil)
			{
			  objName = [doc nameForObject: obj];
                          if (objName != nil)
                            {
                              [classManager setCustomClass: customClassName
                                                   forName: objName];
                            }
                        }
                    }
		  
		  /*
                   * Add custom classes...
                   */
                  NSDictionary *customClasses = [u customClasses];
                  NSEnumerator *en = [customClasses keyEnumerator];
                  NSString *customClassName = nil;
                  NSDictionary *decoded = [u decoded];
                  
                  NSLog(@"customClasses = %@", customClasses);
                  while ((customClassName = [en nextObject]) != nil)
                    {
                      NSDictionary *customClassDict = [customClasses objectForKey: customClassName];;
                      NSString *theId = [customClassDict objectForKey: @"id"];
                      NSString *parentClassName = [customClassDict objectForKey: @"parentClassName"];
                      id realObject = [decoded objectForKey: theId];
                      NSString *theName = nil;

		      // Set the file's owner correctly...
		      if ([theId isEqualToString: @"-2"]) // The File's Owner node...
			{
			  [[doc filesOwner] setClassName: customClassName];
			  continue;
			}

		      // these are preset values
		      if ([theId isEqualToString: @"-1"]
			  || [theId isEqualToString: @"-3"]
			  || [customClassName isEqualToString: @"NSFontManager"]) 
			{
			  continue;
			}
		      
                      realObject = [self _replaceProxyInstanceWithRealObject: realObject
								classManager: classManager
								      withID: theId];
                      NSDebugLog(@"realObject = %@", realObject);
                      
                      if ([doc containsObject: realObject])
                        {
                          theName = [doc nameForObject: realObject];
                          NSDebugLog(@"Found name = %@ for realObject = %@", theName, realObject);
                        }
                      else
                        {
                          NSDebugLog(@"realObject = %@ has no name in document", realObject);
                          // continue;
                        }
                      
                      if ([parentClassName isEqualToString: @"NSCustomObject5"])
                        {
                          parentClassName = @"NSObject";
                        }
                      
                      NSLog(@"Adding customClassName = %@ with parent className = %@", customClassName,
                            parentClassName);
                      [classManager addClassNamed: customClassName
                              withSuperClassNamed: parentClassName
                                      withActions: nil
                                      withOutlets: nil
                                         isCustom: YES];

		      // If the name of the object does not exist, then create it...
		      if (theName == nil)
			{
			  theName = [doc instantiateClassNamed: customClassName];
			}

		      // Set up the mapping...
		      if (theName != nil)
			{
			  [_idToName setObject: theName forKey: theId];
			}
		    }
                  
		  /*
                   * add connections...
                   */
		  en = [_container connectionRecordEnumerator];
		  while ((cr = [en nextObject]) != nil)
		    {
		      IBConnection *conn = [cr connection];
                      
                      if ([conn respondsToSelector: @selector(nibConnector)])
                        {
                          NSNibConnector *o = [conn nibConnector];
                          
                          if (o != nil)
                            {
                              id dest = [o destination];
                              id src = [o source];
			      NSString *destId = [document nameForObject: dest];
			      NSString *srcId = [document nameForObject: src];
			      
                              // Replace files owner with the document files owner for loading...
                              dest = [self _replaceProxyInstanceWithRealObject: dest
								  classManager: classManager
									withID: destId];

                              src = [self _replaceProxyInstanceWithRealObject: src
								 classManager: classManager
								       withID: srcId];
                              
                              // Reset them...
                              [o setDestination: dest];
                              [o setSource: src];

                              NSDebugLog(@"connector = %@", o);

                              if([o isKindOfClass: [NSNibControlConnector class]])
                                {
                                  NSString *tag = [o label];
                                  NSRange colonRange = [tag rangeOfString: @":"];
                                  NSUInteger location = colonRange.location;
                                  
                                  if(location == NSNotFound)
                                    {
                                      NSString *newTag = [NSString stringWithFormat: @"%@:",tag];
                                      [o setLabel: (id)newTag];
                                    }

                                  [classManager addAction: [o label]
                                                forObject: src];

                                  // For control connectors these roles are reversed...
                                  [o setSource: dest];
                                  [o setDestination: src];
                                }
                              else if ([o isKindOfClass: [NSNibOutletConnector class]])
                                {
                                  [classManager addOutlet: [o label]
                                                forObject: src];
                                }
                              
                              // check src/dest for window template...
                              if ([src isKindOfClass: [NSWindowTemplate class]])
                                {
                                  id win = [src realObject];
                                  [o setSource: win];
                                }
                              
                              if ([dest isKindOfClass: [NSWindowTemplate class]])
                                {
                                  id win = [dest realObject];
                                  [o setDestination: win];
                                }
                              
                              // skip any help connectors...
                              if ([o isKindOfClass: [NSIBHelpConnector class]])
                                {
                                  continue;
                                }

                              [doc addConnector: o];
                            }
                        }
                    }
		  
		  // turn on custom classes.
		  [NSClassSwapper setIsInInterfaceBuilder: NO]; 
		  
		  // clear the changes, since we just loaded the document.
		  [doc updateChangeCount: NSChangeCleared];
		  
		  result = YES;
		}
	    }

	  NSArray *errors = [doc validate];
	  NSLog(@"errors = %@", errors);
	  
	  [NSClassSwapper setIsInInterfaceBuilder: NO];      
	}
    }
  NS_HANDLER
    {
      NSRunAlertPanel(_(@"Problem Loading"), 
		      [NSString stringWithFormat: @"Failed to load file.  Exception: %@",[localException reason]], 
		      _(@"OK"), nil, nil);
      result = NO; 
    }
  NS_ENDHANDLER;

  // return the result.
  return result;
}

- (void) unarchiver: (NSKeyedUnarchiver *)unarchiver 
  willReplaceObject: (id)obj 
	 withObject: (id)newObj
{
  // Nothing for now...
}

- (id) unarchiver: (NSKeyedUnarchiver *)unarchiver didDecodeObject: (id)obj
{
  if ([obj isKindOfClass: [NSWindowTemplate class]])
    {
      GormClassManager *classManager = [document classManager];
      // Class clz;
      NSString *className = [obj className];
      
      if([classManager isCustomClass: className])
	{
	  className = [classManager nonCustomSuperClassOf: className];
	}
      // clz = [unarchiver classForClassName: className];
    }
  else if ([obj isKindOfClass: [NSMatrix class]])
    {
      if ([obj cellClass] == NULL)
	{
	  [obj setCellClass: [NSButtonCell class]];
	}
    }
  else if ([obj respondsToSelector: @selector(setTarget:)] &&
           [obj respondsToSelector: @selector(setAction:)] &&
           [obj isKindOfClass: [NSCell class]] == NO)
    {
      // blank the target/action for all objects.
      [obj setTarget: nil];
      [obj setAction: NULL];
    }
  return obj;
}
@end