WKWizardPanel.m

/*
 * WKWizardPanel.m
 *
 * Implementation of the WKWizardPanel class for the WizardKit framework
 *
 * Copyright (c) 2006, by Saso Kiselkov
 *
 * For license details please see the file COPYING included with this
 * source distribution package.
 */
 
#import "WKWizardPanel.h"
 
#import <Foundation/NSString.h>
#import <Foundation/NSBundle.h>
#import <Foundation/NSArray.h>
#import <Foundation/NSDictionary.h>
#import <Foundation/NSException.h>
#import <Foundation/NSNotification.h>
#import <Foundation/NSCoder.h>
 
#import <AppKit/NSApplication.h>

NSString * const WKWizardPanelDidChangeCurrentStageNotification
 = @"WKWizardPanelDidChangeCurrentStageNotification";
 
@interface WKWizardPanel (Private)
 
- (void) setupForStage: (NSString *) aStage;
 
@end

@implementation WKWizardPanel
 
- (void) dealloc
{
  TEST_RELEASE(stages);
  TEST_RELEASE(initialStage);
 
  [super dealloc];
}

- (void) setStages: (NSArray *) someStages
{
  if (isActive == YES)
    {
      [NSException raise: NSInternalInconsistencyException
                  format: _(@"-[WKWizardPanel setStages:]: panel already "
        @"active - stages must be set before activating the panel.")];
    }
 
  ASSIGNCOPY(stages, someStages);
  DESTROY(initialStage);
}

- (NSArray *) stages
{
  return stages;
}

- (void) setRunsInModalSession: (BOOL) flag
{
  if (isActive == YES)
    {
      [NSException raise: NSInternalInconsistencyException
                  format: _(@"-[WKWizardPanel setRunsInModalSession:] "
        @"panel already active - modality must be set before activating "
        @"the panel.")];
    }
 
  runsInModalSession = flag;
}

- (BOOL) runsInModalSession
{
  return runsInModalSession;
}

- (void) setInitialStage: (NSString *) aStageName
{
  if (aStageName != nil && [stages containsObject: aStageName] == NO)
    {
      [NSException raise: NSInvalidArgumentException
                  format: _(@"-[WKWizardPanel setInitialStage:]: "
        @"invalid stage name passed. Stage \"%@\" not in stages list: %@."),
        aStageName, stages];
    }
 
  ASSIGN(initialStage, aStageName);
}

- (NSString *) initialStage
{
  return initialStage;
}

- (void) setCentersBeforeActivating: (BOOL) flag
{
  centersBeforeActivating = flag;
}

- (BOOL) centersBeforeActivating
{
  return centersBeforeActivating;
}

- (void) setCurrentStage: (NSString *) aStageName
{
  currentStage = [stages indexOfObject: aStageName];
  if (currentStage == NSNotFound)
    {
      [NSException raise: NSInvalidArgumentException
                  format: _(@"-[WKWizardPanel setCurrentStage:]: "
        @"invalid stage name passed. Stage \"%@\" not in stages list: %@."),
        aStageName, stages];
    }
 
  [self setupForStage: aStageName];
 
  [[NSNotificationCenter defaultCenter]
    postNotificationName: WKWizardPanelDidChangeCurrentStageNotification
                  object: self
                userInfo: [NSDictionary dictionaryWithObject: aStageName
                                                      forKey: @"Stage"]];
}

- (NSArray *) currentStage
{
  return [stages objectAtIndex: currentStage];
}

- (void) nextStage: (id) sender
{
  if (currentStage + 1 < [stages count])
    {
      [self setCurrentStage: [stages objectAtIndex: currentStage + 1]];
    }
}

- (void) previousStage: (id) sender
{
  if (currentStage > 0)
    {
      [self setCurrentStage: [stages objectAtIndex: currentStage - 1]];
    }
}

- (int) activate: (id) sender
{
  if (isActive)
    {
      [NSException raise: NSInternalInconsistencyException
                  format: _(@"-[WKWizardPanel activate:]: panel "
        @"already active.")];
    }
 
  if ([stages count] == 0)
    {
      [NSException raise: NSInternalInconsistencyException
                  format: _(@"-[WKWizardPanel activate:]: no stages "
        @"set. You must set the panel's stages before activating it.")];
    }
 
  isActive = YES;
 
  if (initialStage != nil)
    {
      [self setCurrentStage: initialStage];
    }
  else
    {
      [self setCurrentStage: [stages objectAtIndex: 0]];
    }
 
  if (centersBeforeActivating)
    {
      [self center];
    }
 
  if (runsInModalSession)
    {
      int code;
 
      code = [NSApp runModalForWindow: self];
 
      [self close];
 
      return code;
    }
  else
    {
      [self makeKeyAndOrderFront: nil];
 
      return NSRunStoppedResponse;
    }
}

- (void) deactivate: (id) sender
{
  if (isActive == NO)
    {
      [NSException raise: NSInternalInconsistencyException
                  format: _(@"-[WKWizardPanel deactivate:]: panel "
        @"not active.")];
    }
 
  isActive = NO;
 
  if (runsInModalSession)
    {
      [NSApp stopModal];
    }
  else
    {
      [self close];
    }
}

- (void) deactivateWithCode: (int) code
{
  if (isActive == NO)
    {
      [NSException raise: NSInternalInconsistencyException
                  format: _(@"-[WKWizardPanel deactivateWithCode:]: "
                            @"panel not active.")];
    }
 
  if (runsInModalSession == NO)
    {
      [NSException raise: NSInternalInconsistencyException
                  format: _(@"-[WKWizardPanel deactivateWithCode]: "
        @"panel was not run in modal session. Use \"-deactivate:\" to "
        @"deactivate a non-modal panel instead.")];
    }
 
  isActive = NO;
 
  [NSApp stopModalWithCode: code];
}

- (BOOL) isActive
{
  return isActive;
}
 
// NSCoding protocol
 
- (void) encodeWithCoder: (NSCoder*) aCoder
{
  [super encodeWithCoder: aCoder];
 
  if ([aCoder allowsKeyedCoding])
    {
      [aCoder encodeBool: runsInModalSession
                  forKey: @"WKRunsInModalSessionFlag"];
      [aCoder encodeBool: runsInModalSession
                  forKey: @"WKCentersBeforeActivatingFlag"];
 
      [aCoder encodeObject: stages forKey: @"WKStages"];
      [aCoder encodeObject: initialStage forKey: @"WKInitialStage"];
    }
  else
    {
      [aCoder encodeValueOfObjCType: @encode(BOOL)
                                 at: &runsInModalSession];
      [aCoder encodeValueOfObjCType: @encode(BOOL)
                                 at: &centersBeforeActivating];
 
      [aCoder encodeObject: stages];
      [aCoder encodeObject: initialStage];
    }
}
 
- (id) initWithCoder: (NSCoder*) aDecoder
{
  if ((self = [super initWithCoder: aDecoder]) != nil)
    {
      if ([aDecoder allowsKeyedCoding])
        {
          runsInModalSession = [aDecoder decodeBoolForKey:
            @"WKRunsInModalSessionFlag"];
          runsInModalSession = [aDecoder decodeBoolForKey:
            @"WKCentersBeforeActivatingFlag"];
 
          ASSIGN(stages, [aDecoder decodeObjectForKey: @"WKStages"]);
          ASSIGN(initialStage, [aDecoder
            decodeObjectForKey: @"WKInitialStage"]);
        }
      else
        {
          [aDecoder decodeValueOfObjCType: @encode(BOOL)
                                     at: &runsInModalSession];
          [aDecoder decodeValueOfObjCType: @encode(BOOL)
                                     at: &centersBeforeActivating];
 
          ASSIGN(stages, [aDecoder decodeObject]);
          ASSIGN(initialStage, [aDecoder decodeObject]);
        }
    }
 
  return self;
}
 
@end

@implementation WKWizardPanel (Private)

- (void) setupForStage: (NSString *) aStage
{
  [self setContentView: [[self delegate] wizardPanel: self
                                        viewForStage: aStage]];
  [self setInitialFirstResponder: [[self delegate] wizardPanel: self
                                 initialFirstResponderForStage: aStage]];
}
 
@end

@implementation NSObject (WKWizardPanelDelegate)

- (NSView *) wizardPanel: (WKWizardPanel *) sender
            viewForStage: (NSString *) aStageName
{
  [NSException raise: NSInternalInconsistencyException
              format: _(@"Wizard delegate %@ didn't override %@."),
    [self className], NSStringFromSelector(_cmd)];
 
  return nil;
}

- (NSView *)       wizardPanel: (WKWizardPanel *) sender
 initialFirstResponderForStage: (NSString *) aStageName
{
  return nil;
}
 
@end