diff options
Diffstat (limited to 'macosx/PictureController.m')
| -rw-r--r-- | macosx/PictureController.m | 1384 |
1 files changed, 1384 insertions, 0 deletions
diff --git a/macosx/PictureController.m b/macosx/PictureController.m new file mode 100644 index 000000000..307962aeb --- /dev/null +++ b/macosx/PictureController.m @@ -0,0 +1,1384 @@ +/* $Id: PictureController.mm,v 1.11 2005/08/01 15:10:44 titer Exp $ + + This file is part of the HandBrake source code. + Homepage: <http://handbrake.fr/>. + It may be used under the terms of the GNU General Public License. */ + +#import "PictureController.h" +#import "Controller.h" +#import "HBPreviewController.h" + + + +@implementation PictureController + +- (id)init +{ + if (self = [super initWithWindowNibName:@"PictureSettings"]) + { + // NSWindowController likes to lazily load its window. However since + // this controller tries to set all sorts of outlets before the window + // is displayed, we need it to load immediately. The correct way to do + // this, according to the documentation, is simply to invoke the window + // getter once. + // + // If/when we switch a lot of this stuff to bindings, this can probably + // go away. + [self window]; + + fPreviewController = [[PreviewController alloc] init]; + } + return self; +} + +//------------------------------------------------------------------------------------ +// Displays and brings the picture window to the front +//------------------------------------------------------------------------------------ +- (IBAction) showPictureWindow: (id)sender +{ + if ([fPreviewController fullScreen] == YES) + { + [self showWindow:sender]; + [[NSUserDefaults standardUserDefaults] setBool:YES forKey:@"PictureSizeWindowIsOpen"]; + [self setToFullScreenMode]; + } + else + { + if ([[self window] isVisible]) + { + [[self window] close]; + } + else + { + [self showWindow:sender]; + [[NSUserDefaults standardUserDefaults] setBool:YES forKey:@"PictureSizeWindowIsOpen"]; + [self setToWindowedMode]; + } + } + [self adjustFilterDisplay:nil]; + [self adjustSizingDisplay:nil]; +} + +- (BOOL) previewFullScreenMode +{ + return [fPreviewController fullScreen]; +} + +/* this method is used to detect clicking on a tab in fSizeFilterView */ +- (void)tabView:(NSTabView *)tabView didSelectTabViewItem:(NSTabViewItem *)tabViewItem +{ + +[self resizeInspectorForTab:nil]; + +} + +#pragma mark - + +/* resizeInspectorForTab is called at launch, and each time either the + * Size or Filters tab is clicked. Size gives a horizontally oriented + * inspector and Filters is a vertically aligned inspector. + */ +- (IBAction) resizeInspectorForTab: (id)sender +{ + NSRect frame = [[self window] frame]; + NSPoint windowOrigin = [[self window] frame].origin; + NSSize screenSize = [[[self window] screen] frame].size; + NSPoint screenOrigin = [[[self window] screen] frame].origin; + + /* We base our inspector size/layout on which tab is active for fSizeFilterView */ + /* we are 1 which is Filters*/ + if ([fSizeFilterView indexOfTabViewItem: [fSizeFilterView selectedTabViewItem]] == 1) + { + frame.size.width = 314; + /* we glean the height from the size of the boxes plus the extra window space + * needed for non boxed display + */ + frame.size.height = 110.0 + [fDetelecineBox frame].size.height + [fDecombDeinterlaceBox frame].size.height + [fDenoiseBox frame].size.height + [fDeblockBox frame].size.height; + /* Hide the size readout at the bottom as the vertical inspector is not wide enough */ + [fSizeInfoField setHidden:YES]; + } + else // we are Tab index 0 which is size + { + frame.size.width = 50.0 + [fPictureSizeBox frame].size.width + [fPictureCropBox frame].size.width; + frame.size.height = [fPictureSizeBox frame].size.height + 85; + /* hide the size summary field at the bottom */ + [fSizeInfoField setHidden:NO]; + } + /* get delta's for the change in window size */ + CGFloat deltaX = frame.size.width - [[self window] frame].size.width; + CGFloat deltaY = frame.size.height - [[self window] frame].size.height; + + /* Check to see if we have changed the height from current */ + //if (frame.size.height != [[self window] frame].size.height) + //{ + /* change the inspector origin via the deltaY */ + frame.origin.y -= deltaY; + /* keep the inspector centered so the tabs stay in place */ + frame.origin.x -= deltaX / 2.0; + //} + + /* we make sure we are not horizontally off of our screen. + * this would be the case if we are on the vertical filter tab + * and we hit the size tab and the inspector grows horizontally + * off the screen to the right + */ + if ((frame.origin.x + frame.size.width) > (screenOrigin.x + screenSize.width)) + { + /* the right side of the preview is off the screen, so shift to the left */ + frame.origin.x = (screenOrigin.x + screenSize.width) - frame.size.width; + } + + [[self window] setFrame:frame display:YES animate:YES]; +} + +- (IBAction) adjustSizingDisplay: (id) sender +{ + NSSize pictureSizingBoxSize = [fPictureSizeBox frame].size; + + NSPoint fPictureSizeBoxOrigin = [fPictureSizeBox frame].origin; + NSSize pictureCropBoxSize = [fPictureCropBox frame].size; + NSPoint fPictureCropBoxOrigin = [fPictureCropBox frame].origin; + + if ([fAnamorphicPopUp indexOfSelectedItem] == 3) // custom / power user jamboree + { + pictureSizingBoxSize.width = 530; + + /* Set visibility of capuj widgets */ + [fParWidthField setHidden: NO]; + [fParHeightField setHidden: NO]; + [fParWidthLabel setHidden: NO]; + [fParHeightLabel setHidden: NO]; + [fDisplayWidthField setHidden: NO]; + [fDisplayWidthLabel setHidden: NO]; + [fModulusLabel setHidden: NO]; + [fModulusPopUp setHidden: NO]; + /* adjust/move keep ar checkbox */ + [fRatioLabel setHidden: YES]; + [fRatioLabel2 setHidden: NO]; + + /* Optionally swith the Storage and Display width positions*/ + /* + NSPoint fWidthLabelOrigin = [fWidthLabel frame].origin; + NSPoint fWidthFieldOrigin = [fWidthField frame].origin; + NSPoint fWidthStepperOrigin = [fWidthStepper frame].origin; + fWidthFieldOrigin.x = [fRatioLabel2 frame].origin.x + [fRatioLabel2 frame].size.width + 4; + [fWidthField setFrameOrigin:fWidthFieldOrigin]; + + fWidthStepperOrigin.x = [fWidthField frame].origin.x + [fWidthField frame].size.width + 4; + [fWidthStepper setFrameOrigin:fWidthStepperOrigin]; + + fWidthLabelOrigin.x = [fWidthField frame].origin.x - [fWidthLabel frame].size.width - 4; + [fWidthLabel setFrameOrigin:fWidthLabelOrigin]; + [fWidthLabel setStringValue:@"Storage Width:"]; + */ + + /* set the origin for fRatioCheck so origin.y == fRatioLabel2 + * and origin.x == fDisplayWidthField + */ + NSPoint fRatioCheckOrigin = [fRatioCheck frame].origin; + fRatioCheckOrigin.y = [fRatioLabel2 frame].origin.y - 2; + fRatioCheckOrigin.x = [fRatioLabel2 frame].origin.x + [fRatioLabel2 frame].size.width + 4; + [fRatioCheck setFrameOrigin:fRatioCheckOrigin]; + + } + else + { + pictureSizingBoxSize.width = 200; + + /* Set visibility of capuj widgets */ + [fParWidthField setHidden: YES]; + [fParHeightField setHidden: YES]; + [fParWidthLabel setHidden: YES]; + [fParHeightLabel setHidden: YES]; + [fDisplayWidthField setHidden: YES]; + [fDisplayWidthLabel setHidden: YES]; + [fModulusLabel setHidden: YES]; + [fModulusPopUp setHidden: YES]; + /* adjust/move keep ar checkbox */ + [fRatioLabel setHidden: NO]; + [fRatioLabel2 setHidden: YES]; + + /* Optionally swith the Storage and Display width positions*/ + + /* + NSPoint fWidthLabelOrigin = [fWidthLabel frame].origin; + NSPoint fWidthFieldOrigin = [fWidthField frame].origin; + NSPoint fWidthStepperOrigin = [fWidthStepper frame].origin; + + fWidthFieldOrigin.x = [fHeightField frame].origin.x; + [fWidthField setFrameOrigin:fWidthFieldOrigin]; + + fWidthStepperOrigin.x = [fHeightStepper frame].origin.x; + [fWidthStepper setFrameOrigin:fWidthStepperOrigin]; + + fWidthLabelOrigin.x = [fWidthField frame].origin.x - [fWidthLabel frame].size.width -4; + [fWidthLabel setFrameOrigin:fWidthLabelOrigin]; + [fWidthLabel setStringValue:@"Width:"]; + */ + + + /* set the origin for fRatioCheck so origin.y == fRatioLabel + * and origin.x == fWidthStepper + */ + NSPoint fRatioCheckOrigin = [fRatioCheck frame].origin; + fRatioCheckOrigin.y = [fRatioLabel frame].origin.y - 2; + fRatioCheckOrigin.x = [fWidthStepper frame].origin.x - 2; + [fRatioCheck setFrameOrigin:fRatioCheckOrigin]; + + } + + /* Check to see if we have changed the size from current */ + if (pictureSizingBoxSize.height != [fPictureSizeBox frame].size.height || pictureSizingBoxSize.width != [fPictureSizeBox frame].size.width) + { + /* Get our delta for the change in picture size box height */ + CGFloat deltaYSizeBoxShift = pictureSizingBoxSize.height - [fPictureSizeBox frame].size.height; + fPictureSizeBoxOrigin.y -= deltaYSizeBoxShift; + /* Get our delta for the change in picture size box width */ + CGFloat deltaXSizeBoxShift = pictureSizingBoxSize.width - [fPictureSizeBox frame].size.width; + //fPictureSizeBoxOrigin.x += deltaXSizeBoxShift; + /* set our new Picture size box size */ + [fPictureSizeBox setFrameSize:pictureSizingBoxSize]; + [fPictureSizeBox setFrameOrigin:fPictureSizeBoxOrigin]; + + pictureCropBoxSize.height += deltaYSizeBoxShift; + fPictureCropBoxOrigin.y -= deltaYSizeBoxShift; + fPictureCropBoxOrigin.x += deltaXSizeBoxShift; + + [fPictureCropBox setFrameSize:pictureCropBoxSize]; + [[fPictureCropBox animator] setFrameOrigin:fPictureCropBoxOrigin]; + } + + + /* now we call to resize the entire inspector window */ + [self resizeInspectorForTab:nil]; +} + +- (IBAction) adjustFilterDisplay: (id) sender +{ + + NSBox * filterBox = nil; + NSTextField * filterField; + if (sender == fDetelecinePopUp) + { + filterBox = fDetelecineBox; + filterField = fDetelecineField; + } + + if (sender == fDecombDeinterlaceSlider) + { + if ([fDecombDeinterlaceSlider floatValue] == 0.0) + { + filterBox = fDecombBox; + filterField = fDecombField; + } + else + { + filterBox = fDeinterlaceBox; + filterField = fDeinterlaceField; + } + } + + if (sender == fDecombPopUp) + { + filterBox = fDecombBox; + filterField = fDecombField; + } + if (sender == fDeinterlacePopUp) + { + filterBox = fDeinterlaceBox; + filterField = fDeinterlaceField; + } + + if (sender == fDenoisePopUp) + { + filterBox = fDenoiseBox; + filterField = fDenoiseField; + } + + NSSize currentSize = [filterBox frame].size; + NSRect boxFrame = [filterBox frame]; + + if ([sender titleOfSelectedItem] == @"Custom") + { + + currentSize.height = 60; + + } + else + { + currentSize.height = 30; + + } + /* Check to see if we have changed the size from current */ + if (currentSize.height != [filterBox frame].size.height) + { + /* We are changing the size of the box, so recalc the origin */ + NSPoint boxOrigin = [filterBox frame].origin; + /* We get the deltaY here for how much we are expanding/contracting the box vertically */ + CGFloat deltaYBoxShift = currentSize.height - [filterBox frame].size.height; + boxOrigin.y -= deltaYBoxShift; + + boxFrame.size.height = currentSize.height; + boxFrame.origin.y = boxOrigin.y; + [filterBox setFrame:boxFrame]; + + /* go ahead and resize the box */ + //[[filterBox animator] setFrameSize:currentSize]; + //[[filterBox animator] setFrameOrigin:origin]; + + + if (filterBox == fDecombBox || filterBox == fDeinterlaceBox) + { + /* fDecombDeinterlaceBox*/ + NSSize decombDeinterlaceBoxSize = [fDecombDeinterlaceBox frame].size; + NSPoint decombDeinterlaceBoxOrigin = [fDecombDeinterlaceBox frame].origin; + + //decombDeinterlaceBoxSize.height = [filterBox frame].size.height + 50; + if (sender == fDecombDeinterlaceSlider) + { + [fHBController writeToActivityLog: "Sender is deinterlace decomb slider"]; + } + + if ([fDeinterlaceBox isHidden] == YES) + { + decombDeinterlaceBoxSize.height = [fDecombBox frame].size.height + 50; + [fHBController writeToActivityLog: "Resize by Decomb box"]; + } + else + { + decombDeinterlaceBoxSize.height = [fDeinterlaceBox frame].size.height + 50; + [fHBController writeToActivityLog: "Resize by Deinterlace box"]; + } + /* get delta's for the change in window size */ + + CGFloat deltaYdecombDeinterlace = decombDeinterlaceBoxSize.height - [fDecombDeinterlaceBox frame].size.height; + + deltaYBoxShift = deltaYdecombDeinterlace; + + decombDeinterlaceBoxOrigin.y -= deltaYdecombDeinterlace; + + [fDecombDeinterlaceBox setFrameSize:decombDeinterlaceBoxSize]; + [fDecombDeinterlaceBox setFrameOrigin:decombDeinterlaceBoxOrigin]; + } + + /* now we must reset the origin of each box below the adjusted box*/ + NSPoint decombDeintOrigin = [fDecombDeinterlaceBox frame].origin; + NSPoint denoiseOrigin = [fDenoiseBox frame].origin; + NSPoint deblockOrigin = [fDeblockBox frame].origin; + if (sender == fDetelecinePopUp) + { + decombDeintOrigin.y -= deltaYBoxShift; + [fDecombDeinterlaceBox setFrameOrigin:decombDeintOrigin]; + + denoiseOrigin.y -= deltaYBoxShift; + [fDenoiseBox setFrameOrigin:denoiseOrigin]; + + deblockOrigin.y -= deltaYBoxShift; + [fDeblockBox setFrameOrigin:deblockOrigin]; + } + if (sender == fDecombPopUp || sender == fDeinterlacePopUp) + { + denoiseOrigin.y -= deltaYBoxShift; + [fDenoiseBox setFrameOrigin:denoiseOrigin]; + + deblockOrigin.y -= deltaYBoxShift; + [fDeblockBox setFrameOrigin:deblockOrigin]; + } + + if (sender == fDenoisePopUp) + { + deblockOrigin.y -= deltaYBoxShift; + [fDeblockBox setFrameOrigin:deblockOrigin]; + } + + /* now we call to resize the entire inspector window */ + [self resizeInspectorForTab:nil]; + } + +} + + +#pragma mark - + +- (IBAction) previewGoWindowed: (id)sender +{ + [fPreviewController goWindowedScreen:self]; +} + +- (IBAction) showPreviewWindow: (id)sender +{ + [[NSUserDefaults standardUserDefaults] setBool:YES forKey:@"PreviewWindowIsOpen"]; + [fPreviewController showWindow:sender]; +} + + + + +- (void) setToFullScreenMode +{ + int32_t shieldLevel = CGShieldingWindowLevel(); + + [fPictureWindow setLevel:shieldLevel + 1]; + // Show the window. + [fPictureWindow makeKeyAndOrderFront:self]; +} + +- (void) setToWindowedMode +{ + /* Set the window back to Floating Window mode + * This will put the window always on top, but + * since we have Hide on Deactivate set in our + * xib, if other apps are put in focus we will + * hide properly to stay out of the way + */ + [[self window] setLevel:NSFloatingWindowLevel]; +} + +- (void)setHBController: (HBController *)controller +{ + fHBController = controller; + [fPreviewController setHBController: controller]; + +} + +- (void)awakeFromNib +{ + [fPictureWindow setDelegate:self]; + if( ![[self window] setFrameUsingName:@"PictureSizing"] ) + [[self window] center]; + [self setWindowFrameAutosaveName:@"PictureSizing"]; + [[self window] setExcludedFromWindowsMenu:YES]; + + [self setInitialPictureFilters]; + + /* Setup our layers for core animation */ + [fSizeFilterView setWantsLayer:YES]; + [fPictureSizeBox setWantsLayer:YES]; + [fPictureCropBox setWantsLayer:YES]; + +} + + +- (void)windowWillClose:(NSNotification *)aNotification +{ +[[NSUserDefaults standardUserDefaults] setBool:NO forKey:@"PictureSizeWindowIsOpen"]; +} + +- (BOOL)windowShouldClose:(id)fPictureWindow +{ + return YES; +} + +- (void) dealloc +{ + [fPreviewController release]; + [super dealloc]; +} + +- (void) SetHandle: (hb_handle_t *) handle +{ + fHandle = handle; + + [fPreviewController SetHandle: fHandle]; +} + +- (void) SetTitle: (hb_title_t *) title +{ + hb_job_t * job = title->job; + + fTitle = title; + + [fWidthStepper setValueWraps: NO]; + [fWidthStepper setIncrement: 16]; + [fWidthStepper setMinValue: 64]; + [fHeightStepper setValueWraps: NO]; + [fHeightStepper setIncrement: 16]; + [fHeightStepper setMinValue: 64]; + + [fCropTopStepper setIncrement: 2]; + [fCropTopStepper setMinValue: 0]; + [fCropBottomStepper setIncrement: 2]; + [fCropBottomStepper setMinValue: 0]; + [fCropLeftStepper setIncrement: 2]; + [fCropLeftStepper setMinValue: 0]; + [fCropRightStepper setIncrement: 2]; + [fCropRightStepper setMinValue: 0]; + + [fWidthStepper setMaxValue: title->width]; + [fWidthStepper setIntValue: job->width]; + [fWidthField setIntValue: job->width]; + [fHeightStepper setMaxValue: title->height]; + [fHeightStepper setIntValue: job->height]; + [fHeightField setIntValue: job->height]; + [fRatioCheck setState: job->keep_ratio ? NSOnState : NSOffState]; + [fCropTopStepper setMaxValue: title->height/2-2]; + [fCropBottomStepper setMaxValue: title->height/2-2]; + [fCropLeftStepper setMaxValue: title->width/2-2]; + [fCropRightStepper setMaxValue: title->width/2-2]; + + /* Populate the Anamorphic NSPopUp button here */ + [fAnamorphicPopUp removeAllItems]; + [fAnamorphicPopUp addItemWithTitle: @"None"]; + [fAnamorphicPopUp addItemWithTitle: @"Strict"]; + if (allowLooseAnamorphic) + { + [fAnamorphicPopUp addItemWithTitle: @"Loose"]; + } + [fAnamorphicPopUp addItemWithTitle: @"Custom"]; + [fAnamorphicPopUp selectItemAtIndex: job->anamorphic.mode]; + + //[self adjustSizingDisplay:nil]; + + /* populate the modulus popup here */ + [fModulusPopUp removeAllItems]; + [fModulusPopUp addItemWithTitle: @"16"]; + [fModulusPopUp addItemWithTitle: @"8"]; + [fModulusPopUp addItemWithTitle: @"4"]; + [fModulusPopUp addItemWithTitle: @"2"]; + if (job->anamorphic.mode == 3) + { + [fModulusPopUp selectItemWithTitle: [NSString stringWithFormat:@"%d",job->anamorphic.modulus]]; + } + else + { + [fModulusPopUp selectItemWithTitle: @"16"]; + } + + /* We initially set the previous state of keep ar to on */ + keepAspectRatioPreviousState = 1; + if (!autoCrop) + { + [fCropMatrix selectCellAtRow: 1 column:0]; + /* If auto, lets set the crop steppers according to current job->crop values */ + [fCropTopStepper setIntValue: job->crop[0]]; + [fCropTopField setIntValue: job->crop[0]]; + [fCropBottomStepper setIntValue: job->crop[1]]; + [fCropBottomField setIntValue: job->crop[1]]; + [fCropLeftStepper setIntValue: job->crop[2]]; + [fCropLeftField setIntValue: job->crop[2]]; + [fCropRightStepper setIntValue: job->crop[3]]; + [fCropRightField setIntValue: job->crop[3]]; + } + else + { + [fCropMatrix selectCellAtRow: 0 column:0]; + } + + /* Set filters widgets according to the filters struct */ + [fDetelecinePopUp selectItemAtIndex:fPictureFilterSettings.detelecine]; + [fDecombPopUp selectItemAtIndex:fPictureFilterSettings.decomb]; + [fDeinterlacePopUp selectItemAtIndex: fPictureFilterSettings.deinterlace]; + [fDenoisePopUp selectItemAtIndex: fPictureFilterSettings.denoise]; + [fDeblockSlider setFloatValue:fPictureFilterSettings.deblock]; + [fGrayscaleCheck setState:fPictureFilterSettings.grayscale]; + + [self deblockSliderChanged: nil]; + + fPicture = 0; + MaxOutputWidth = title->width - job->crop[2] - job->crop[3]; + MaxOutputHeight = title->height - job->crop[0] - job->crop[1]; + + titleDarWidth = job->anamorphic.dar_width; + titleDarHeight = job->anamorphic.dar_height; + + titleParWidth = job->anamorphic.par_width; + titleParHeight = job->anamorphic.par_height; + + [self SettingsChanged: nil]; +} + +- (IBAction) storageLinkChanged: (id) sender +{ + /* since we have a tickless slider, make sure we are at 0.0 or 1.0 */ + if ([fStorageLinkSlider floatValue] < 0.50) + { + [fStorageLinkSlider setFloatValue:0.0]; + /* set slider labels to reflect choice */ + [fStorageLinkParLabel setEnabled:YES]; + [fStorageLinkDisplayLabel setEnabled:NO]; + + } + else + { + [fStorageLinkSlider setFloatValue:1.0]; + /* set slider labels to reflect choice */ + [fStorageLinkParLabel setEnabled:NO]; + [fStorageLinkDisplayLabel setEnabled:YES]; + } + +} + +- (IBAction) parLinkChanged: (id) sender +{ + /* since we have a tickless slider, make sure we are at 0.0 or 1.0 */ + if ([fParLinkSlider floatValue] < 0.50) + { + [fParLinkSlider setFloatValue:0.0]; + /* set slider labels to reflect choice */ + [fParLinkStorageLabel setEnabled:YES]; + [fParLinkDisplayLabel setEnabled:NO]; + } + else + { + [fParLinkSlider setFloatValue:1.0]; + /* set slider labels to reflect choice */ + [fParLinkStorageLabel setEnabled:NO]; + [fParLinkDisplayLabel setEnabled:YES]; + } + +} + +- (IBAction) displayLinkChanged: (id) sender +{ + /* since we have a tickless slider, make sure we are at 0.0 or 1.0 */ + if ([fDisplayLinkSlider floatValue] < 0.50) + { + [fDisplayLinkSlider setFloatValue:0.0]; + /* set slider labels to reflect choice */ + [fDisplayLinkStorageLabel setEnabled:YES]; + [fDisplayLinkParLabel setEnabled:NO]; + } + else + { + [fDisplayLinkSlider setFloatValue:1.0]; + /* set slider labels to reflect choice */ + [fDisplayLinkStorageLabel setEnabled:NO]; + [fDisplayLinkParLabel setEnabled:YES]; + } + +} + +- (IBAction) SettingsChanged: (id) sender +{ + hb_job_t * job = fTitle->job; + [fModulusPopUp setEnabled:NO]; + job->anamorphic.modulus = 16; + + /* Since custom anamorphic allows for a height setting > fTitle->height + * check to make sure it is returned to fTitle->height for all other modes + */ + [fHeightStepper setMaxValue: fTitle->height]; + + autoCrop = ( [fCropMatrix selectedRow] == 0 ); + [fCropTopStepper setEnabled: !autoCrop]; + [fCropBottomStepper setEnabled: !autoCrop]; + [fCropLeftStepper setEnabled: !autoCrop]; + [fCropRightStepper setEnabled: !autoCrop]; + + if( autoCrop ) + { + memcpy( job->crop, fTitle->crop, 4 * sizeof( int ) ); + } + else + { + job->crop[0] = [fCropTopStepper intValue]; + job->crop[1] = [fCropBottomStepper intValue]; + job->crop[2] = [fCropLeftStepper intValue]; + job->crop[3] = [fCropRightStepper intValue]; + } + + [fRatioCheck setEnabled: YES]; + + + [fParWidthField setEnabled: NO]; + [fParHeightField setEnabled: NO]; + [fDisplayWidthField setEnabled: NO]; + + /* If we are not custom anamorphic, make sure we retain the orginal par */ + if( [fAnamorphicPopUp indexOfSelectedItem] != 3 ) + { + job->anamorphic.par_width = titleParWidth; + job->anamorphic.par_height = titleParHeight; + [fRatioLabel setHidden: NO]; + + [fWidthStepper setIncrement: 16]; + [fHeightStepper setIncrement: 16]; + } + else + { + [fWidthStepper setIncrement: [[fModulusPopUp titleOfSelectedItem] intValue]]; + [fHeightStepper setIncrement: [[fModulusPopUp titleOfSelectedItem] intValue]]; + } + + if( [fAnamorphicPopUp indexOfSelectedItem] > 0 ) + { + if ([fAnamorphicPopUp indexOfSelectedItem] == 1) // strict + { + [fWidthStepper setIntValue: fTitle->width-fTitle->job->crop[2]-fTitle->job->crop[3]]; + [fWidthField setIntValue: fTitle->width-fTitle->job->crop[2]-fTitle->job->crop[3]]; + + /* This will show correct anamorphic height values, but + show distorted preview picture ratio */ + [fHeightStepper setIntValue: fTitle->height-fTitle->job->crop[0]-fTitle->job->crop[1]]; + [fHeightField setIntValue: fTitle->height-fTitle->job->crop[0]-fTitle->job->crop[1]]; + job->width = [fWidthStepper intValue]; + job->height = [fHeightStepper intValue]; + + job->anamorphic.mode = 1; + [fWidthStepper setEnabled: NO]; + [fWidthField setEnabled: NO]; + [fHeightStepper setEnabled: NO]; + [fHeightField setEnabled: NO]; + [fRatioCheck setEnabled: NO]; + } + else if ([fAnamorphicPopUp indexOfSelectedItem] == 2) // Loose anamorphic + { + job->anamorphic.mode = 2; + [fWidthStepper setEnabled: YES]; + [fWidthField setEnabled: YES]; + [fRatioCheck setEnabled: NO]; + [fHeightStepper setEnabled: NO]; + [fHeightField setEnabled: NO]; + /* We set job->width and call hb_set_anamorphic_size in libhb to do a "dry run" to get + * the values to be used by libhb for loose anamorphic + */ + /* if the sender is the anamorphic popup, then we know that loose anamorphic has just + * been turned on, so snap the width to full width for the source. + */ + if (sender == fAnamorphicPopUp) + { + [fWidthStepper setIntValue: fTitle->width-fTitle->job->crop[2]-fTitle->job->crop[3]]; + [fWidthField setIntValue: fTitle->width-fTitle->job->crop[2]-fTitle->job->crop[3]]; + } + job->width = [fWidthStepper intValue]; + hb_set_anamorphic_size(job, &output_width, &output_height, &output_par_width, &output_par_height); + [fHeightStepper setIntValue: output_height]; + [fHeightField setIntValue: output_height]; + job->height = [fHeightStepper intValue]; + + } + else if ([fAnamorphicPopUp indexOfSelectedItem] == 3) // custom / power user jamboree + { + +#pragma mark - STARTCapuj + + job->anamorphic.mode = 3; + + /* Set the status of our custom ana only widgets accordingly */ + /* for mod 3 we can use modulus other than 16 */ + [fModulusPopUp setEnabled:YES]; + job->anamorphic.modulus = [[fModulusPopUp titleOfSelectedItem] intValue]; + + [fWidthStepper setEnabled: YES]; + [fWidthField setEnabled: YES]; + + [fHeightStepper setEnabled: YES]; + /* for capuj the storage field is immaterial */ + [fHeightField setEnabled: YES]; + + [fRatioCheck setEnabled: YES]; + if (sender == fRatioCheck) + { + if ([fRatioCheck state] == NSOnState) + { + [fParWidthField setEnabled: NO]; + [fParHeightField setEnabled: NO]; + } + else + { + [fParWidthField setEnabled: YES]; + [fParHeightField setEnabled: YES]; + } + } + + [fParWidthField setEnabled: YES]; + [fParHeightField setEnabled: YES]; + + [fDisplayWidthField setEnabled: YES]; + + + /* If we are coming into custom anamorphic we reset the par to original + * which gives us a way back if things get hosed up. + */ + + if (sender == fAnamorphicPopUp) + { + /* When entering custom anamorphic, we start with keep ar on */ + [fRatioCheck setState: NSOnState]; + /* + KEEPING ASPECT RATIO + Disable editing: PIXEL WIDTH, PIXEL HEIGHT + */ + [fParWidthField setEnabled: NO]; + [fParHeightField setEnabled: NO]; + + job->width = [fWidthStepper intValue]; + job->height = [fHeightStepper intValue]; + + /* make sure our par is set back to original */ + job->anamorphic.par_width = titleParWidth; + job->anamorphic.par_height = titleParHeight; + + [fParWidthField setIntValue: titleParWidth]; + [fParHeightField setIntValue: titleParHeight]; + + /* modify our par dims from our storage dims */ + hb_set_anamorphic_size(job, &output_width, &output_height, &output_par_width, &output_par_height); + float par_display_width = (float)output_width * (float)output_par_width / (float)output_par_height; + + /* go ahead and mod the display dims */ + [fDisplayWidthField setStringValue: [NSString stringWithFormat:@"%.2f", par_display_width]]; + + job->anamorphic.dar_width = [fDisplayWidthField floatValue]; + job->anamorphic.dar_height = (float)[fHeightStepper intValue]; + + /* Set our dar here assuming we are just coming into capuj mode */ + dar = [fDisplayWidthField floatValue] / (float)[fHeightField intValue]; + + } + + /* For capuj we disable these fields if we are keeping the dispay aspect */ + if ([fRatioCheck state] == NSOnState) + { + /* + KEEPING ASPECT RATIO + DAR = DISPLAY WIDTH / DISPLAY HEIGHT (cache after every modification) */ + /*Disable editing: PIXEL WIDTH, PIXEL HEIGHT */ + + [fParWidthField setEnabled: NO]; + [fParHeightField setEnabled: NO]; + + /* Changing DISPLAY WIDTH: */ + if (sender == fDisplayWidthField) + { + job->anamorphic.dar_width = [fDisplayWidthField floatValue]; + /* Changes HEIGHT to keep DAR */ + /* calculate the height to retain the dar */ + int raw_calulated_height = (int)((int)[fDisplayWidthField floatValue] / dar); + /* now use the modulus to go lower if there is a remainder */ + /* Note to me, raw_calulated_height % [[fModulusPopUp titleOfSelectedItem] intValue] + * gives me the remainder we are not mod (whatever our modulus is) subtract that from + * the actual calculated value derived from the dar to round down to the nearest mod value. + * This should be desireable over rounding up to the next mod value + */ + int modulus_height = raw_calulated_height - (raw_calulated_height % [[fModulusPopUp titleOfSelectedItem] intValue]); + if (modulus_height > fTitle->height) + { + [fHeightStepper setMaxValue: modulus_height]; + } + [fHeightStepper setIntValue: modulus_height]; + job->anamorphic.dar_height = (float)[fHeightStepper intValue]; + job->height = [fHeightStepper intValue]; + + /* Changes PIXEL WIDTH to new DISPLAY WIDTH */ + [fParWidthField setIntValue: [fDisplayWidthField intValue]]; + job->anamorphic.par_width = [fParWidthField intValue]; + /* Changes PIXEL HEIGHT to STORAGE WIDTH */ + [fParHeightField setIntValue: [fWidthField intValue]]; + job->anamorphic.par_height = [fParHeightField intValue]; + + } + /* Changing HEIGHT: */ + if (sender == fHeightStepper) + { + job->anamorphic.dar_height = (float)[fHeightStepper intValue]; + job->height = [fHeightStepper intValue]; + + /* Changes DISPLAY WIDTH to keep DAR*/ + [fDisplayWidthField setStringValue: [NSString stringWithFormat: @"%.2f",[fHeightStepper intValue] * dar]]; + job->anamorphic.dar_width = [fDisplayWidthField floatValue]; + /* Changes PIXEL WIDTH to new DISPLAY WIDTH */ + [fParWidthField setIntValue: [fDisplayWidthField intValue]]; + job->anamorphic.par_width = [fParWidthField intValue]; + /* Changes PIXEL HEIGHT to STORAGE WIDTH */ + [fParHeightField setIntValue: [fWidthField intValue]]; + job->anamorphic.par_height = [fParHeightField intValue]; + } + /* Changing STORAGE_WIDTH: */ + if (sender == fWidthStepper) + { + job->width = [fWidthStepper intValue]; + + job->anamorphic.dar_width = [fDisplayWidthField floatValue]; + job->anamorphic.dar_height = [fHeightStepper floatValue]; + + /* Changes PIXEL WIDTH to DISPLAY WIDTH */ + [fParWidthField setIntValue: [fDisplayWidthField intValue]]; + job->anamorphic.par_width = [fParWidthField intValue]; + /* Changes PIXEL HEIGHT to new STORAGE WIDTH */ + [fParHeightField setIntValue: [fWidthStepper intValue]]; + job->anamorphic.par_height = [fParHeightField intValue]; + } + } + else if ([fRatioCheck state] == NSOffState) + { + /* Changing STORAGE_WIDTH: */ + if (sender == fWidthStepper) + { + job->width = [fWidthStepper intValue]; + /* changes DISPLAY WIDTH to STORAGE WIDTH * PIXEL WIDTH / PIXEL HEIGHT */ + [fDisplayWidthField setStringValue: [NSString stringWithFormat: @"%.2f",(float)[fWidthStepper intValue] * [fParWidthField intValue] / [fParHeightField intValue]]]; + job->anamorphic.dar_width = [fDisplayWidthField floatValue]; + } + /* Changing PIXEL dimensions */ + if (sender == fParWidthField || sender == fParHeightField) + { + job->anamorphic.par_width = [fParWidthField intValue]; + job->anamorphic.par_height = [fParHeightField intValue]; + /* changes DISPLAY WIDTH to STORAGE WIDTH * PIXEL WIDTH / PIXEL HEIGHT */ + [fDisplayWidthField setStringValue: [NSString stringWithFormat: @"%.2f",(float)[fWidthStepper intValue] * [fParWidthField intValue] / [fParHeightField intValue]]]; + job->anamorphic.dar_width = [fDisplayWidthField floatValue]; + } + /* Changing DISPLAY WIDTH: */ + if (sender == fDisplayWidthField) + { + job->anamorphic.dar_width = [fDisplayWidthField floatValue]; + job->anamorphic.dar_height = (float)[fHeightStepper intValue]; + /* changes PIXEL WIDTH to DISPLAY WIDTH and PIXEL HEIGHT to STORAGE WIDTH */ + [fParWidthField setIntValue: [fDisplayWidthField intValue]]; + job->anamorphic.par_width = [fParWidthField intValue]; + + [fParHeightField setIntValue: [fWidthField intValue]]; + job->anamorphic.par_height = [fParHeightField intValue]; + hb_set_anamorphic_size(job, &output_width, &output_height, &output_par_width, &output_par_height); + } + /* Changing HEIGHT: */ + if (sender == fHeightStepper) + { + /* just....changes the height.*/ + job->anamorphic.dar_height = [fHeightStepper intValue]; + job->height = [fHeightStepper intValue]; + } + + } + +#pragma mark - END Capuj + } + + /* if the sender is the Anamorphic checkbox, record the state + of KeepAspect Ratio so it can be reset if Anamorphic is unchecked again */ + if (sender == fAnamorphicPopUp) + { + keepAspectRatioPreviousState = [fRatioCheck state]; + } + if ([fAnamorphicPopUp indexOfSelectedItem] != 3) + { + [fRatioCheck setState:NSOffState]; + } + + } + else + { + job->width = [fWidthStepper intValue]; + job->height = [fHeightStepper intValue]; + job->anamorphic.mode = 0; + [fWidthStepper setEnabled: YES]; + [fWidthField setEnabled: YES]; + [fHeightStepper setEnabled: YES]; + [fHeightField setEnabled: YES]; + [fRatioCheck setEnabled: YES]; + /* if the sender is the Anamorphic checkbox, we return the + keep AR checkbox to its previous state */ + if (sender == fAnamorphicPopUp) + { + [fRatioCheck setState:keepAspectRatioPreviousState]; + } + + } + + //job->keep_ratio = ( [fRatioCheck state] == NSOnState ); + + if ([fAnamorphicPopUp indexOfSelectedItem] != 3) + { + job->keep_ratio = ( [fRatioCheck state] == NSOnState ); + if( job->keep_ratio ) + { + if( sender == fWidthStepper || sender == fRatioCheck || + sender == fCropTopStepper || sender == fCropBottomStepper ) + { + hb_fix_aspect( job, HB_KEEP_WIDTH ); + if( job->height > fTitle->height ) + { + job->height = fTitle->height; + hb_fix_aspect( job, HB_KEEP_HEIGHT ); + } + } + else + { + hb_fix_aspect( job, HB_KEEP_HEIGHT ); + if( job->width > fTitle->width ) + { + job->width = fTitle->width; + hb_fix_aspect( job, HB_KEEP_WIDTH ); + } + } + + } + } + + // hb_get_preview can't handle sizes that are larger than the original title + if ([fAnamorphicPopUp indexOfSelectedItem] != 3) + { + // dimensions + if( job->width > fTitle->width ) + { + job->width = fTitle->width; + } + + if( job->height > fTitle->height ) + { + job->height = fTitle->height; + } + } + + [fWidthStepper setIntValue: job->width]; + [fWidthField setIntValue: job->width]; + if( [fAnamorphicPopUp indexOfSelectedItem] != 2) // if we are not loose or custom + { + [fHeightStepper setIntValue: job->height]; + [fHeightField setIntValue: job->height]; + } + + [fCropTopStepper setIntValue: job->crop[0]]; + [fCropTopField setIntValue: job->crop[0]]; + [fCropBottomStepper setIntValue: job->crop[1]]; + [fCropBottomField setIntValue: job->crop[1]]; + [fCropLeftStepper setIntValue: job->crop[2]]; + [fCropLeftField setIntValue: job->crop[2]]; + [fCropRightStepper setIntValue: job->crop[3]]; + [fCropRightField setIntValue: job->crop[3]]; + + //[fPreviewController SetTitle:fTitle]; + + /* Sanity Check Here for < 16 px preview to avoid + crashing hb_get_preview. In fact, just for kicks + lets getting previews at a min limit of 32, since + no human can see any meaningful detail below that */ + if (job->width >= 64 && job->height >= 64) + { + [self reloadStillPreview]; + } + + /* we get the sizing info to display from fPreviewController */ + [fSizeInfoField setStringValue: [fPreviewController pictureSizeInfoString]]; + + if (sender != nil) + { + [fHBController pictureSettingsDidChange]; + } + + if ([[self window] isVisible]) + { + [self adjustSizingDisplay:nil]; + } + +} + +- (NSString*) getPictureSizeInfoString +{ + return [fSizeInfoField stringValue]; +} + +- (void)reloadStillPreview +{ + hb_job_t * job = fTitle->job; + + [fPreviewController SetTitle:fTitle]; + /* Sanity Check Here for < 16 px preview to avoid + crashing hb_get_preview. In fact, just for kicks + lets getting previews at a min limit of 32, since + no human can see any meaningful detail below that */ + if (job->width >= 64 && job->height >= 64) + { + + // Purge the existing picture previews so they get recreated the next time + // they are needed. + // [fPreviewController purgeImageCache]; + /* We actually call displayPreview now from pictureSliderChanged which keeps + * our picture preview slider in sync with the previews being shown + */ + + //[fPreviewController pictureSliderChanged:nil]; + } + +} + + +#pragma mark - + +- (BOOL) autoCrop +{ + return autoCrop; +} +- (void) setAutoCrop: (BOOL) setting +{ + autoCrop = setting; +} + +- (BOOL) allowLooseAnamorphic +{ + return allowLooseAnamorphic; +} + +- (void) setAllowLooseAnamorphic: (BOOL) setting +{ + allowLooseAnamorphic = setting; +} + +- (IBAction)showPreviewPanel: (id)sender forTitle: (hb_title_t *)title +{ + //[self SetTitle:title]; + [self showWindow:sender]; + //[self adjustSizingDisplay:nil]; + //[self adjustFilterDisplay:nil]; + +} + + +#pragma mark - +/* we use this to setup the initial picture filters upon first launch, after that their states +are maintained across different sources */ +- (void) setInitialPictureFilters +{ + /* we use a popup to show the detelecine settings */ + [fDetelecinePopUp removeAllItems]; + [fDetelecinePopUp addItemWithTitle: @"Off"]; + [fDetelecinePopUp addItemWithTitle: @"Custom"]; + [fDetelecinePopUp addItemWithTitle: @"Default"]; + [fDetelecinePopUp selectItemAtIndex: fPictureFilterSettings.detelecine]; + + [self modeDecombDeinterlaceSliderChanged:nil]; + /* we use a popup to show the decomb settings */ + [fDecombPopUp removeAllItems]; + [fDecombPopUp addItemWithTitle: @"Off"]; + [fDecombPopUp addItemWithTitle: @"Custom"]; + [fDecombPopUp addItemWithTitle: @"Default"]; + + [fDecombPopUp selectItemAtIndex: fPictureFilterSettings.decomb]; + + /* we use a popup to show the deinterlace settings */ + [fDeinterlacePopUp removeAllItems]; + [fDeinterlacePopUp addItemWithTitle: @"Off"]; + [fDeinterlacePopUp addItemWithTitle: @"Custom"]; + [fDeinterlacePopUp addItemWithTitle: @"Fast"]; + [fDeinterlacePopUp addItemWithTitle: @"Slow"]; + [fDeinterlacePopUp addItemWithTitle: @"Slower"]; + + /* Set deinterlaces level according to the integer in the main window */ + [fDeinterlacePopUp selectItemAtIndex: fPictureFilterSettings.deinterlace]; + + /* we use a popup to show the denoise settings */ + [fDenoisePopUp removeAllItems]; + [fDenoisePopUp addItemWithTitle: @"Off"]; + [fDenoisePopUp addItemWithTitle: @"Custom"]; + [fDenoisePopUp addItemWithTitle: @"Weak"]; + [fDenoisePopUp addItemWithTitle: @"Medium"]; + [fDenoisePopUp addItemWithTitle: @"Strong"]; + /* Set denoises level according to the integer in the main window */ + [fDenoisePopUp selectItemAtIndex: fPictureFilterSettings.denoise]; + + +} + + + + +- (IBAction) modeDecombDeinterlaceSliderChanged: (id) sender +{ + + /* since its a tickless slider, we have to make sure we are on or off */ + if ([fDecombDeinterlaceSlider floatValue] < 0.50) + { + [fDecombDeinterlaceSlider setFloatValue:0.0]; + } + else + { + [fDecombDeinterlaceSlider setFloatValue:1.0]; + } + + + /* Decomb selected*/ + if ([fDecombDeinterlaceSlider floatValue] == 0.0) + { + [fDecombBox setHidden:NO]; + [fDeinterlaceBox setHidden:YES]; + fPictureFilterSettings.decomb = [fDecombPopUp indexOfSelectedItem]; + fPictureFilterSettings.usedecomb = 1; + fPictureFilterSettings.deinterlace = 0; + [fDecombPopUp selectItemAtIndex:fPictureFilterSettings.decomb]; + [self adjustFilterDisplay:fDecombPopUp]; + } + else + { + [fDecombBox setHidden:YES]; + [fDeinterlaceBox setHidden:NO]; + fPictureFilterSettings.usedecomb = 0; + fPictureFilterSettings.decomb = 0; + [fDeinterlacePopUp selectItemAtIndex: fPictureFilterSettings.deinterlace]; + [self adjustFilterDisplay:fDeinterlacePopUp]; + } + [self FilterSettingsChanged: fDecombDeinterlaceSlider]; +} + + +- (IBAction) FilterSettingsChanged: (id) sender +{ + + fPictureFilterSettings.detelecine = [fDetelecinePopUp indexOfSelectedItem]; + [self adjustFilterDisplay:fDetelecinePopUp]; + + fPictureFilterSettings.decomb = [fDecombPopUp indexOfSelectedItem]; + [self adjustFilterDisplay:fDecombPopUp]; + + fPictureFilterSettings.deinterlace = [fDeinterlacePopUp indexOfSelectedItem]; + [self adjustFilterDisplay:fDeinterlacePopUp]; + + fPictureFilterSettings.denoise = [fDenoisePopUp indexOfSelectedItem]; + [self adjustFilterDisplay:fDenoisePopUp]; + + if ([fDeblockField stringValue] == @"Off") + { + fPictureFilterSettings.deblock = 0; + } + else + { + fPictureFilterSettings.deblock = [fDeblockField intValue]; + } + + fPictureFilterSettings.grayscale = [fGrayscaleCheck state]; + + if (sender != nil) + { + [fHBController pictureSettingsDidChange]; + + } + +} + + +#pragma mark - + +- (IBAction) deblockSliderChanged: (id) sender +{ + if ([fDeblockSlider floatValue] == 4.0) + { + [fDeblockField setStringValue: [NSString stringWithFormat: @"Off"]]; + } + else + { + [fDeblockField setStringValue: [NSString stringWithFormat: @"%.0f", [fDeblockSlider floatValue]]]; + } + [self FilterSettingsChanged: sender]; +} + + +- (int) detelecine +{ + return fPictureFilterSettings.detelecine; +} + +- (NSString*) detelecineCustomString +{ + return [fDetelecineField stringValue]; +} + +- (void) setDetelecine: (int) setting +{ + fPictureFilterSettings.detelecine = setting; +} + +- (void) setDetelecineCustomString: (NSString*) string +{ + [fDetelecineField setStringValue:string]; +} + +- (int) deinterlace +{ + return fPictureFilterSettings.deinterlace; +} +- (NSString*) deinterlaceCustomString +{ + return [fDeinterlaceField stringValue]; +} + +- (void) setDeinterlaceCustomString: (NSString*) string +{ + [fDeinterlaceField setStringValue:string]; +} + +- (void) setDeinterlace: (int) setting +{ + fPictureFilterSettings.deinterlace = setting; +} +- (int) decomb +{ + return fPictureFilterSettings.decomb; +} + +- (NSString*) decombCustomString +{ + return [fDecombField stringValue]; +} + +- (int) useDecomb +{ + return fPictureFilterSettings.usedecomb; +} + +- (void) setUseDecomb: (int) setting +{ + fPictureFilterSettings.usedecomb = setting; + if (fPictureFilterSettings.usedecomb == 1) + { + [fDecombDeinterlaceSlider setFloatValue:0.0]; + } + else + { + [fDecombDeinterlaceSlider setFloatValue:1.0]; + } + [self modeDecombDeinterlaceSliderChanged:nil]; +} + +- (void) setDecomb: (int) setting { + fPictureFilterSettings.decomb = setting; +} + +- (void) setDecombCustomString: (NSString*) string +{ + [fDecombField setStringValue:string]; +} + +- (int) denoise +{ + return fPictureFilterSettings.denoise; +} + +- (NSString*) denoiseCustomString +{ + return [fDenoiseField stringValue]; +} + +- (void) setDenoiseCustomString: (NSString*) string +{ + [fDenoiseField setStringValue:string]; +} + +- (void) setDenoise: (int) setting +{ + fPictureFilterSettings.denoise = setting; +} + +- (int) deblock +{ + return fPictureFilterSettings.deblock; +} + +- (void) setDeblock: (int) setting +{ + fPictureFilterSettings.deblock = setting; +} + +- (int) grayscale +{ + return fPictureFilterSettings.grayscale; +} + +- (void) setGrayscale: (int) setting +{ + fPictureFilterSettings.grayscale = setting; +} + + + +@end + |