X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=macosx%2FPictureController.mm;h=38e312ee4010afcb84cfd75e9811a90cdaa5634c;hb=44946a6f8be82a70e65ca534541183a26fdb804b;hp=c0f5771af06c6f1e17078b327239e81e0011fe3f;hpb=a9d3c32580cb8c232db08615ce5ee7c284d088f2;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/macosx/PictureController.mm b/macosx/PictureController.mm index c0f5771a..38e312ee 100644 --- a/macosx/PictureController.mm +++ b/macosx/PictureController.mm @@ -5,19 +5,14 @@ It may be used under the terms of the GNU General Public License. */ #import "PictureController.h" +#import "Controller.h" +#import "HBPreviewController.h" -@interface PictureController (Private) -- (NSSize)optimalViewSizeForImageSize: (NSSize)imageSize; -- (void)resizeSheetForViewSize: (NSSize)viewSize; -- (void)setViewSize: (NSSize)viewSize; -- (BOOL)viewNeedsToResizeToSize: (NSSize)newSize; - -@end @implementation PictureController -- (id)initWithDelegate:(id)del +- (id)init { if (self = [super initWithWindowNibName:@"PictureSettings"]) { @@ -31,28 +26,452 @@ // go away. [self window]; - delegate = del; - fPicturePreviews = [[NSMutableDictionary dictionaryWithCapacity: HB_NUM_HBLIB_PICTURES] retain]; - /* Init libhb with check for updates libhb style set to "0" so its ignored and lets sparkle take care of it */ - int loggingLevel = [[[NSUserDefaults standardUserDefaults] objectForKey:@"LoggingLevel"] intValue]; - fPreviewLibhb = hb_init(loggingLevel, 0); - } + fPreviewController = [[PreviewController alloc] init]; + } return self; } -- (void) dealloc +//------------------------------------------------------------------------------------ +// 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 { - hb_stop(fPreviewLibhb); - if (fPreviewMoviePath) + + 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 { - [[NSFileManager defaultManager] removeFileAtPath:fPreviewMoviePath handler:nil]; - [fPreviewMoviePath release]; - } + 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]; - [fLibhbTimer invalidate]; - [fLibhbTimer release]; + /* Setup our layers for core animation */ + [fSizeFilterView setWantsLayer:YES]; + [fPictureSizeBox setWantsLayer:YES]; + [fPictureCropBox setWantsLayer:YES]; - [fPicturePreviews release]; +} + + +- (void)windowWillClose:(NSNotification *)aNotification +{ +[[NSUserDefaults standardUserDefaults] setBool:NO forKey:@"PictureSizeWindowIsOpen"]; +} + +- (BOOL)windowShouldClose:(id)fPictureWindow +{ + return YES; +} + +- (void) dealloc +{ + [fPreviewController release]; [super dealloc]; } @@ -60,6 +479,15 @@ { 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]; @@ -76,44 +504,6 @@ [fCropRightStepper setIncrement: 2]; [fCropRightStepper setMinValue: 0]; - /* we set the preview length popup in seconds */ - [fPreviewMovieLengthPopUp removeAllItems]; - [fPreviewMovieLengthPopUp addItemWithTitle: @"5"]; - [fPreviewMovieLengthPopUp addItemWithTitle: @"10"]; - [fPreviewMovieLengthPopUp addItemWithTitle: @"15"]; - [fPreviewMovieLengthPopUp addItemWithTitle: @"20"]; - [fPreviewMovieLengthPopUp addItemWithTitle: @"25"]; - [fPreviewMovieLengthPopUp addItemWithTitle: @"30"]; - [fPreviewMovieLengthPopUp addItemWithTitle: @"35"]; - [fPreviewMovieLengthPopUp addItemWithTitle: @"40"]; - [fPreviewMovieLengthPopUp addItemWithTitle: @"45"]; - [fPreviewMovieLengthPopUp addItemWithTitle: @"50"]; - [fPreviewMovieLengthPopUp addItemWithTitle: @"55"]; - [fPreviewMovieLengthPopUp addItemWithTitle: @"60"]; - - /* adjust the preview slider length */ - /* We use our advance pref to determine how many previews we scanned */ - int hb_num_previews = [[[NSUserDefaults standardUserDefaults] objectForKey:@"PreviewsNumber"] intValue]; - [fPictureSlider setMaxValue: hb_num_previews - 1.0]; - [fPictureSlider setNumberOfTickMarks: hb_num_previews]; - - if ([[NSUserDefaults standardUserDefaults] objectForKey:@"PreviewLength"]) - { - [fPreviewMovieLengthPopUp selectItemWithTitle:[[NSUserDefaults standardUserDefaults] objectForKey:@"PreviewLength"]]; - } - else - { - /* currently hard set default to 10 seconds */ - [fPreviewMovieLengthPopUp selectItemAtIndex: 1]; - } -} - -- (void) SetTitle: (hb_title_t *) title -{ - hb_job_t * job = title->job; - - fTitle = title; - [fWidthStepper setMaxValue: title->width]; [fWidthStepper setIntValue: job->width]; [fWidthField setIntValue: job->width]; @@ -134,7 +524,25 @@ { [fAnamorphicPopUp addItemWithTitle: @"Loose"]; } - [fAnamorphicPopUp selectItemAtIndex: job->pixel_ratio]; + [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; @@ -156,147 +564,107 @@ [fCropMatrix selectCellAtRow: 0 column:0]; } - /* Set filters widgets according to the filters struct */ - [fDetelecineCheck setState:fPictureFilterSettings.detelecine]; + /* Set filters widgets according to the filters struct */ + [fDetelecinePopUp selectItemAtIndex:fPictureFilterSettings.detelecine]; + [fDecombPopUp selectItemAtIndex:fPictureFilterSettings.decomb]; [fDeinterlacePopUp selectItemAtIndex: fPictureFilterSettings.deinterlace]; [fDenoisePopUp selectItemAtIndex: fPictureFilterSettings.denoise]; - [fDeblockCheck setState: fPictureFilterSettings.deblock]; - [fDecombCheck setState: fPictureFilterSettings.decomb]; + [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]; - [self SettingsChanged: nil]; -} - -/* 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 deinterlace settings */ - [fDeinterlacePopUp removeAllItems]; - [fDeinterlacePopUp addItemWithTitle: @"None"]; - [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: @"None"]; - [fDenoisePopUp addItemWithTitle: @"Weak"]; - [fDenoisePopUp addItemWithTitle: @"Medium"]; - [fDenoisePopUp addItemWithTitle: @"Strong"]; - /* Set denoises level according to the integer in the main window */ - [fDenoisePopUp selectItemAtIndex: fPictureFilterSettings.denoise]; + titleDarWidth = job->anamorphic.dar_width; + titleDarHeight = job->anamorphic.dar_height; - + titleParWidth = job->anamorphic.par_width; + titleParHeight = job->anamorphic.par_height; + + [self SettingsChanged: nil]; } -// Adjusts the window to draw the current picture (fPicture) adjusting its size as -// necessary to display as much of the picture as possible. -- (void) displayPreview +- (IBAction) storageLinkChanged: (id) sender { - - /* lets make sure that the still picture view is not hidden and that - * the movie preview is - */ - [fMovieView pause:nil]; - [fMovieView setHidden:YES]; - [fMovieCreationProgressIndicator stopAnimation: nil]; - [fMovieCreationProgressIndicator setHidden: YES]; - - [fPictureView setHidden:NO]; - - [fPictureView setImage: [self imageForPicture: fPicture]]; - - NSSize displaySize = NSMakeSize( ( CGFloat )fTitle->width, ( CGFloat )fTitle->height ); - /* Set the picture size display fields below the Preview Picture*/ - if( fTitle->job->pixel_ratio == 1 ) // Original PAR Implementation - { - output_width = fTitle->width-fTitle->job->crop[2]-fTitle->job->crop[3]; - output_height = fTitle->height-fTitle->job->crop[0]-fTitle->job->crop[1]; - display_width = output_width * fTitle->job->pixel_aspect_width / fTitle->job->pixel_aspect_height; - [fInfoField setStringValue:[NSString stringWithFormat: - @"Source: %dx%d, Output: %dx%d, Anamorphic: %dx%d", - fTitle->width, fTitle->height, output_width, output_height, display_width, output_height]]; - displaySize.width *= ( ( CGFloat )fTitle->job->pixel_aspect_width ) / ( ( CGFloat )fTitle->job->pixel_aspect_height ); - } - else if (fTitle->job->pixel_ratio == 2) // Loose Anamorphic + /* since we have a tickless slider, make sure we are at 0.0 or 1.0 */ + if ([fStorageLinkSlider floatValue] < 0.50) { - display_width = output_width * output_par_width / output_par_height; - [fInfoField setStringValue:[NSString stringWithFormat: - @"Source: %dx%d, Output: %dx%d, Anamorphic: %dx%d", - fTitle->width, fTitle->height, output_width, output_height, display_width, output_height]]; - - displaySize.width = display_width; + [fStorageLinkSlider setFloatValue:0.0]; + /* set slider labels to reflect choice */ + [fStorageLinkParLabel setEnabled:YES]; + [fStorageLinkDisplayLabel setEnabled:NO]; + } - else // No Anamorphic + else { - [fInfoField setStringValue: [NSString stringWithFormat: - @"Source: %dx%d, Output: %dx%d", fTitle->width, fTitle->height, - fTitle->job->width, fTitle->job->height]]; + [fStorageLinkSlider setFloatValue:1.0]; + /* set slider labels to reflect choice */ + [fStorageLinkParLabel setEnabled:NO]; + [fStorageLinkDisplayLabel setEnabled:YES]; } + +} - NSSize viewSize = [self optimalViewSizeForImageSize:displaySize]; - if( [self viewNeedsToResizeToSize:viewSize] ) +- (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) { - /* In the case of loose anamorphic, do not resize the window when scaling down */ - if (fTitle->job->pixel_ratio != 2 || [fWidthField intValue] == fTitle->width) - { - [self resizeSheetForViewSize:viewSize]; - [self setViewSize:viewSize]; - } + [fParLinkSlider setFloatValue:0.0]; + /* set slider labels to reflect choice */ + [fParLinkStorageLabel setEnabled:YES]; + [fParLinkDisplayLabel setEnabled:NO]; } - - // Show the scaled text (use the height to check since the width can vary - // with anamorphic video). - if( ( ( int )viewSize.height ) != fTitle->height ) + else { - CGFloat scale = viewSize.width / ( ( CGFloat ) fTitle->width ); - NSString *scaleString = [NSString stringWithFormat: - NSLocalizedString( @" (Preview scaled to %.0f%% actual size)", - @"String shown when a preview is scaled" ), - scale * 100.0]; - [fInfoField setStringValue: [[fInfoField stringValue] stringByAppendingString:scaleString]]; + [fParLinkSlider setFloatValue:1.0]; + /* set slider labels to reflect choice */ + [fParLinkStorageLabel setEnabled:NO]; + [fParLinkDisplayLabel setEnabled:YES]; } - -} - -- (IBAction) previewDurationPopUpChanged: (id) sender -{ - -[[NSUserDefaults standardUserDefaults] setObject:[fPreviewMovieLengthPopUp titleOfSelectedItem] forKey:@"PreviewLength"]; - -} - +} -- (IBAction) deblockSliderChanged: (id) sender +- (IBAction) displayLinkChanged: (id) sender { - if ([fDeblockSlider floatValue] == 4.0) + /* since we have a tickless slider, make sure we are at 0.0 or 1.0 */ + if ([fDisplayLinkSlider floatValue] < 0.50) { - [fDeblockField setStringValue: [NSString stringWithFormat: @"Off"]]; + [fDisplayLinkSlider setFloatValue:0.0]; + /* set slider labels to reflect choice */ + [fDisplayLinkStorageLabel setEnabled:YES]; + [fDisplayLinkParLabel setEnabled:NO]; } else { - [fDeblockField setStringValue: [NSString stringWithFormat: @"%.0f", [fDeblockSlider floatValue]]]; + [fDisplayLinkSlider setFloatValue:1.0]; + /* set slider labels to reflect choice */ + [fDisplayLinkStorageLabel setEnabled:NO]; + [fDisplayLinkParLabel setEnabled:YES]; } - [self SettingsChanged: sender]; -} + +} - (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 ) ); @@ -309,13 +677,58 @@ are maintained across different sources */ 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] == 2) // Loose anamorphic + 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->pixel_ratio = 2; + 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 */ @@ -334,21 +747,202 @@ are maintained across different sources */ job->height = [fHeightStepper intValue]; } - else // must be "1" or strict anamorphic + else if ([fAnamorphicPopUp indexOfSelectedItem] == 3) // custom / power user jamboree { - [fWidthStepper setIntValue: fTitle->width-fTitle->job->crop[2]-fTitle->job->crop[3]]; - [fWidthField setIntValue: fTitle->width-fTitle->job->crop[2]-fTitle->job->crop[3]]; + +#pragma mark - STARTCapuj + + job->anamorphic.mode = 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]; + /* 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]; - job->pixel_ratio = 1; - [fWidthStepper setEnabled: NO]; - [fWidthField setEnabled: NO]; + [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 @@ -357,19 +951,17 @@ are maintained across different sources */ { keepAspectRatioPreviousState = [fRatioCheck state]; } - [fRatioCheck setState:NSOffState]; - [fRatioCheck setEnabled: NO]; - - - [fHeightStepper setEnabled: NO]; - [fHeightField setEnabled: NO]; + if ([fAnamorphicPopUp indexOfSelectedItem] != 3) + { + [fRatioCheck setState:NSOffState]; + } } else { job->width = [fWidthStepper intValue]; job->height = [fHeightStepper intValue]; - job->pixel_ratio = 0; + job->anamorphic.mode = 0; [fWidthStepper setEnabled: YES]; [fWidthField setEnabled: YES]; [fHeightStepper setEnabled: YES]; @@ -384,72 +976,59 @@ are maintained across different sources */ } - job->keep_ratio = ( [fRatioCheck state] == NSOnState ); + //job->keep_ratio = ( [fRatioCheck state] == NSOnState ); - fPictureFilterSettings.deinterlace = [fDeinterlacePopUp indexOfSelectedItem]; - /* if the gui deinterlace settings are fast through slowest, the job->deinterlace - value needs to be set to one, for the job as well as the previews showing deinterlacing - otherwise set job->deinterlace to 0 or "off" */ - if (fPictureFilterSettings.deinterlace > 0) + if ([fAnamorphicPopUp indexOfSelectedItem] != 3) { - job->deinterlace = 1; - } - else - { - job->deinterlace = 0; - } - fPictureFilterSettings.denoise = [fDenoisePopUp indexOfSelectedItem]; - - fPictureFilterSettings.detelecine = [fDetelecineCheck state]; - - if ([fDeblockField stringValue] == @"Off") - { - fPictureFilterSettings.deblock = 0; - } - else - { - fPictureFilterSettings.deblock = [fDeblockField intValue]; - } - - fPictureFilterSettings.decomb = [fDecombCheck state]; - - if( job->keep_ratio ) - { - if( sender == fWidthStepper || sender == fRatioCheck || - sender == fCropTopStepper || sender == fCropBottomStepper ) + job->keep_ratio = ( [fRatioCheck state] == NSOnState ); + if( job->keep_ratio ) { - hb_fix_aspect( job, HB_KEEP_WIDTH ); - if( job->height > fTitle->height ) + if( sender == fWidthStepper || sender == fRatioCheck || + sender == fCropTopStepper || sender == fCropBottomStepper ) { - job->height = fTitle->height; - hb_fix_aspect( job, HB_KEEP_HEIGHT ); + 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 ) + else { - job->width = fTitle->width; - hb_fix_aspect( job, HB_KEEP_WIDTH ); + 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 + } + + // 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( [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]]; @@ -458,6 +1037,43 @@ are maintained across different sources */ [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 @@ -467,383 +1083,220 @@ are maintained across different sources */ // Purge the existing picture previews so they get recreated the next time // they are needed. - [self purgeImageCache]; + // [fPreviewController purgeImageCache]; /* We actually call displayPreview now from pictureSliderChanged which keeps * our picture preview slider in sync with the previews being shown */ - //[self displayPreview]; - [self pictureSliderChanged:nil]; + //[fPreviewController pictureSliderChanged:nil]; } - - if (sender != nil) - { - if ([delegate respondsToSelector:@selector(pictureSettingsDidChange)]) - [delegate pictureSettingsDidChange]; - } } -- (IBAction) pictureSliderChanged: (id) sender + +#pragma mark - + +- (BOOL) autoCrop { - // Show the picture view - [fCreatePreviewMovieButton setTitle: @"Live Preview"]; - [fPictureView setHidden:NO]; - [fMovieView pause:nil]; - [fMovieView setHidden:YES]; - [fPreviewMovieStatusField setHidden: YES]; - - int newPicture = [fPictureSlider intValue]; - if (newPicture != fPicture) - { - fPicture = newPicture; - } - [self displayPreview]; - + return autoCrop; +} +- (void) setAutoCrop: (BOOL) setting +{ + autoCrop = setting; } -#pragma mark Movie Preview -- (IBAction) createMoviePreview: (id) sender +- (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 { - /* Lets make sure the still picture previews are showing in case - * there is currently a movie showing */ - [self pictureSliderChanged:nil]; + /* we use a popup to show the detelecine settings */ + [fDetelecinePopUp removeAllItems]; + [fDetelecinePopUp addItemWithTitle: @"Off"]; + [fDetelecinePopUp addItemWithTitle: @"Default"]; + [fDetelecinePopUp addItemWithTitle: @"Custom"]; + [fDetelecinePopUp selectItemAtIndex: fPictureFilterSettings.detelecine]; - /* Rip or Cancel ? */ - hb_state_t s; - hb_get_state2( fPreviewLibhb, &s ); + [self modeDecombDeinterlaceSliderChanged:nil]; + /* we use a popup to show the decomb settings */ + [fDecombPopUp removeAllItems]; + [fDecombPopUp addItemWithTitle: @"Off"]; + [fDecombPopUp addItemWithTitle: @"Default"]; + [fDecombPopUp addItemWithTitle: @"Custom"]; + [fDecombPopUp selectItemAtIndex: fPictureFilterSettings.decomb]; - if(s.state == HB_STATE_WORKING || s.state == HB_STATE_PAUSED) - { - - play_movie = NO; - hb_stop( fPreviewLibhb ); - [fPictureView setHidden:NO]; - [fMovieView pause:nil]; - [fMovieView setHidden:YES]; - [fPictureSlider setHidden:NO]; - [fCreatePreviewMovieButton setTitle: @"Live Preview"]; - return; - } + /* we use a popup to show the deinterlace settings */ + [fDeinterlacePopUp removeAllItems]; + [fDeinterlacePopUp addItemWithTitle: @"None"]; + [fDeinterlacePopUp addItemWithTitle: @"Fast"]; + [fDeinterlacePopUp addItemWithTitle: @"Slow"]; + [fDeinterlacePopUp addItemWithTitle: @"Slower"]; + [fDeinterlacePopUp addItemWithTitle: @"Custom"]; - /* we use controller.mm's prepareJobForPreview to go ahead and set all of our settings - * however, we want to use a temporary destination field of course - * so that we do not put our temp preview in the users chosen - * directory */ + /* 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: @"None"]; + [fDenoisePopUp addItemWithTitle: @"Weak"]; + [fDenoisePopUp addItemWithTitle: @"Medium"]; + [fDenoisePopUp addItemWithTitle: @"Strong"]; + [fDenoisePopUp addItemWithTitle: @"Custom"]; + /* Set denoises level according to the integer in the main window */ + [fDenoisePopUp selectItemAtIndex: fPictureFilterSettings.denoise]; - hb_job_t * job = fTitle->job; - /* We run our current setting through prepeareJob in Controller.mm - * just as if it were a regular encode */ - if ([delegate respondsToSelector:@selector(prepareJobForPreview)]) - { - [delegate prepareJobForPreview]; - } + +} + + + + +- (IBAction) modeDecombDeinterlaceSliderChanged: (id) sender +{ - /* Destination file. We set this to our preview directory - * changing the extension appropriately.*/ - if (fTitle->job->mux == HB_MUX_MP4) // MP4 file + /* since its a tickless slider, we have to make sure we are on or off */ + if ([fDecombDeinterlaceSlider floatValue] < 0.50) { - /* we use .m4v for our mp4 files so that ac3 and chapters in mp4 will play properly */ - fPreviewMoviePath = @"~/Library/Application Support/HandBrake/Previews/preview_temp.m4v"; + [fDecombDeinterlaceSlider setFloatValue:0.0]; } - else if (fTitle->job->mux == HB_MUX_MKV) // MKV file - { - fPreviewMoviePath = @"~/Library/Application Support/HandBrake/Previews/preview_temp.mkv"; - } - else if (fTitle->job->mux == HB_MUX_AVI) // AVI file - { - fPreviewMoviePath = @"~/Library/Application Support/HandBrake/Previews/preview_temp.avi"; - } - else if (fTitle->job->mux == HB_MUX_OGM) // OGM file + else { - fPreviewMoviePath = @"~/Library/Application Support/HandBrake/Previews/preview_temp.ogm"; + [fDecombDeinterlaceSlider setFloatValue:1.0]; } - fPreviewMoviePath = [[fPreviewMoviePath stringByExpandingTildeInPath]retain]; - /* See if there is an existing preview file, if so, delete it */ - if( ![[NSFileManager defaultManager] fileExistsAtPath:fPreviewMoviePath] ) + /* Decomb selected*/ + if ([fDecombDeinterlaceSlider floatValue] == 0.0) { - [[NSFileManager defaultManager] removeFileAtPath:fPreviewMoviePath - handler:nil]; + [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 +{ - /* We now direct our preview encode to fPreviewMoviePath */ - fTitle->job->file = [fPreviewMoviePath UTF8String]; - - /* We use our advance pref to determine how many previews to scan */ - int hb_num_previews = [[[NSUserDefaults standardUserDefaults] objectForKey:@"PreviewsNumber"] intValue]; - job->start_at_preview = fPicture + 1; - job->seek_points = hb_num_previews; - - /* we use the preview duration popup to get the specified - * number of seconds for the preview encode. - */ - - job->pts_to_stop = [[fPreviewMovieLengthPopUp titleOfSelectedItem] intValue] * 90000LL; - - /* lets go ahead and send it off to libhb - * Note: unlike a full encode, we only send 1 pass regardless if the final encode calls for 2 passes. - * this should suffice for a fairly accurate short preview and cuts our preview generation time in half. - */ - hb_add( fPreviewLibhb, job ); - - [fPictureSlider setHidden:YES]; - [fMovieCreationProgressIndicator setHidden: NO]; - [fPreviewMovieStatusField setHidden: NO]; - [self startReceivingLibhbNotifications]; + fPictureFilterSettings.detelecine = [fDetelecinePopUp indexOfSelectedItem]; + [self adjustFilterDisplay:fDetelecinePopUp]; + fPictureFilterSettings.decomb = [fDecombPopUp indexOfSelectedItem]; + [self adjustFilterDisplay:fDecombPopUp]; - [fCreatePreviewMovieButton setTitle: @"Cancel Preview"]; + fPictureFilterSettings.deinterlace = [fDeinterlacePopUp indexOfSelectedItem]; + [self adjustFilterDisplay:fDeinterlacePopUp]; - play_movie = YES; + fPictureFilterSettings.denoise = [fDenoisePopUp indexOfSelectedItem]; + [self adjustFilterDisplay:fDenoisePopUp]; - /* Let fPreviewLibhb do the job */ - hb_start( fPreviewLibhb ); - -} - -- (void) startReceivingLibhbNotifications -{ - if (!fLibhbTimer) + if ([fDeblockField stringValue] == @"Off") { - fLibhbTimer = [NSTimer scheduledTimerWithTimeInterval:0.5 target:self selector:@selector(libhbTimerFired:) userInfo:nil repeats:YES]; - [fLibhbTimer retain]; + fPictureFilterSettings.deblock = 0; } -} - -- (void) stopReceivingLibhbNotifications -{ - if (fLibhbTimer) + else { - [fLibhbTimer invalidate]; - [fLibhbTimer release]; - fLibhbTimer = nil; + fPictureFilterSettings.deblock = [fDeblockField intValue]; } -} -- (void) libhbTimerFired: (NSTimer*)theTimer -{ - hb_state_t s; - hb_get_state( fPreviewLibhb, &s ); - [self libhbStateChanged: s]; -} -- (void) libhbStateChanged: (hb_state_t &)state -{ - switch( state.state ) + + fPictureFilterSettings.grayscale = [fGrayscaleCheck state]; + + if (sender != nil) { - case HB_STATE_IDLE: - case HB_STATE_SCANNING: - case HB_STATE_SCANDONE: - break; - - case HB_STATE_WORKING: - { -#define p state.param.working - - NSMutableString * string; - /* Update text field */ - string = [NSMutableString stringWithFormat: NSLocalizedString( @"Encoding %d seconds of preview %d: %.2f %%", @"" ), [[fPreviewMovieLengthPopUp titleOfSelectedItem] intValue], fPicture + 1, 100.0 * p.progress]; - - if( p.seconds > -1 ) - { - [string appendFormat: - NSLocalizedString( @" (%.2f fps, avg %.2f fps, ETA %02dh%02dm%02ds)", @"" ), - p.rate_cur, p.rate_avg, p.hours, p.minutes, p.seconds]; - } - [fPreviewMovieStatusField setStringValue: string]; - - [fMovieCreationProgressIndicator setIndeterminate: NO]; - /* Update slider */ - [fMovieCreationProgressIndicator setDoubleValue: 100.0 * p.progress]; - - [fCreatePreviewMovieButton setTitle: @"Cancel Preview"]; - - break; - - } -#undef p - -#define p state.param.muxing - case HB_STATE_MUXING: - { - // Update fMovieCreationProgressIndicator - [fMovieCreationProgressIndicator setIndeterminate: YES]; - [fMovieCreationProgressIndicator startAnimation: nil]; - [fPreviewMovieStatusField setStringValue: [NSString stringWithFormat: - NSLocalizedString( @"Muxing Preview ...", @"" )]]; - break; - } -#undef p - case HB_STATE_PAUSED: - [fMovieCreationProgressIndicator stopAnimation: nil]; - break; - - case HB_STATE_WORKDONE: - { - // Delete all remaining jobs since libhb doesn't do this on its own. - hb_job_t * job; - while( ( job = hb_job(fPreviewLibhb, 0) ) ) - hb_rem( fHandle, job ); - - [self stopReceivingLibhbNotifications]; - [fPreviewMovieStatusField setStringValue: @""]; - [fPreviewMovieStatusField setHidden: YES]; - - [fMovieCreationProgressIndicator stopAnimation: nil]; - [fMovieCreationProgressIndicator setHidden: YES]; - /* we make sure the picture slider and preview match */ - [self pictureSliderChanged:nil]; - [fPictureSlider setHidden:NO]; - - // Show the movie view - if (play_movie) - { - [self showMoviePreview:fPreviewMoviePath]; - } - - [fCreatePreviewMovieButton setTitle: @"Live Preview"]; - - - break; - } - } - + [fHBController pictureSettingsDidChange]; + + } + } -- (IBAction) showMoviePreview: (NSString *) path + +#pragma mark - + +- (IBAction) deblockSliderChanged: (id) sender { - /* Since the gray background for the still images is part of - * fPictureView, lets leave the picture view visible and postion - * the fMovieView over the image portion of fPictureView so - * we retain the gray cropping border we have already established - * with the still previews - */ - [fMovieView setHidden:NO]; - - /* Load the new movie into fMovieView */ - QTMovie * aMovie; - NSRect movieBounds; - if (path) + if ([fDeblockSlider floatValue] == 4.0) { - [fMovieView setControllerVisible: YES]; - /* let's make sure there is no movie currently set */ - [fMovieView setMovie:nil]; - - aMovie = [QTMovie movieWithFile:path error:nil]; - - /* we get some size information from the preview movie */ - Rect movieBox; - GetMovieBox ([aMovie quickTimeMovie], &movieBox); - movieBounds = [fMovieView movieBounds]; - movieBounds.size.height = movieBox.bottom - movieBox.top; - - if ([fMovieView isControllerVisible]) - movieBounds.size.height += [fMovieView controllerBarHeight]; - /* since for whatever the reason I cannot seem to get the [fMovieView controllerBarHeight] - * For now just use 15 for additional height as it seems to line up well - */ - movieBounds.size.height += 15; - - movieBounds.size.width = movieBox.right - movieBox.left; - - /* We need to find out if the preview movie needs to be scaled down so - * that it doesn't overflow our available viewing container (just like for image - * in -displayPreview) for HD sources, etc. [fPictureViewArea frame].size.height*/ - if( ((int)movieBounds.size.height) > [fPictureView frame].size.height ) - { - /* The preview movie would be larger than the available viewing area - * in the preview movie, so we go ahead and scale it down to the same size - * as the still preview or we readjust our window to allow for the added height if need be - */ - NSSize displaySize = NSMakeSize( (float)movieBounds.size.width, (float)movieBounds.size.height ); - //NSSize displaySize = NSMakeSize( (float)fTitle->width, (float)fTitle->height ); - NSSize viewSize = [self optimalViewSizeForImageSize:displaySize]; - if( [self viewNeedsToResizeToSize:viewSize] ) - { - - [self resizeSheetForViewSize:viewSize]; - [self setViewSize:viewSize]; - - } - - [fMovieView setFrameSize:viewSize]; - } - else - { - /* Since the preview movie is smaller than the available viewing area - * we can go ahead and use the preview movies native size */ - [fMovieView setFrameSize:movieBounds.size]; - } - - // lets reposition the movie if need be - NSPoint origin = [fPictureViewArea frame].origin; - origin.x += trunc(([fPictureViewArea frame].size.width - - [fMovieView frame].size.width) / 2.0); - /* Since we are adding 15 to the height to allow for the controller bar - * we need to subtract half of that for the origin.y to get the controller bar - * below the movie to it lines up vertically with where our still preview was - */ - origin.y += trunc((([fPictureViewArea frame].size.height - - [fMovieView frame].size.height) / 2.0) - 7.5); - [fMovieView setFrameOrigin:origin]; - - [fMovieView setMovie:aMovie]; - /// to actually play the movie - [fMovieView play:aMovie]; + [fDeblockField setStringValue: [NSString stringWithFormat: @"Off"]]; } else { - aMovie = nil; - } - + [fDeblockField setStringValue: [NSString stringWithFormat: @"%.0f", [fDeblockSlider floatValue]]]; + } + [self FilterSettingsChanged: sender]; } -#pragma mark - -- (IBAction) ClosePanel: (id) sender +- (int) detelecine { - if ([delegate respondsToSelector:@selector(pictureSettingsDidChange)]) - [delegate pictureSettingsDidChange]; - - [NSApp endSheet:[self window]]; - [[self window] orderOut:self]; + return fPictureFilterSettings.detelecine; } -- (BOOL) autoCrop -{ - return autoCrop; -} -- (void) setAutoCrop: (BOOL) setting +- (NSString*) detelecineCustomString { - autoCrop = setting; + return [fDetelecineField stringValue]; } -- (BOOL) allowLooseAnamorphic +- (void) setDetelecine: (int) setting { - return allowLooseAnamorphic; + fPictureFilterSettings.detelecine = setting; } -- (void) setAllowLooseAnamorphic: (BOOL) setting +- (void) setDetelecineCustomString: (NSString*) string { - allowLooseAnamorphic = setting; + [fDetelecineField setStringValue:string]; } -- (int) detelecine +- (int) deinterlace { - return fPictureFilterSettings.detelecine; + return fPictureFilterSettings.deinterlace; } - -- (void) setDetelecine: (int) setting +- (NSString*) deinterlaceCustomString { - fPictureFilterSettings.detelecine = setting; + return [fDeinterlaceField stringValue]; } -- (int) deinterlace +- (void) setDeinterlaceCustomString: (NSString*) string { - return fPictureFilterSettings.deinterlace; + [fDeinterlaceField setStringValue:string]; } -- (void) setDeinterlace: (int) setting { +- (void) setDeinterlace: (int) setting +{ fPictureFilterSettings.deinterlace = setting; } - (int) decomb @@ -851,330 +1304,80 @@ are maintained across different sources */ return fPictureFilterSettings.decomb; } -- (void) setDecomb: (int) setting { - fPictureFilterSettings.decomb = setting; -} -- (int) denoise +- (NSString*) decombCustomString { - return fPictureFilterSettings.denoise; + return [fDecombField stringValue]; } -- (void) setDenoise: (int) setting +- (int) useDecomb { - fPictureFilterSettings.denoise = setting; + return fPictureFilterSettings.usedecomb; } -- (int) deblock +- (void) setUseDecomb: (int) setting { - return fPictureFilterSettings.deblock; + fPictureFilterSettings.usedecomb = setting; + if (fPictureFilterSettings.usedecomb == 1) + { + [fDecombDeinterlaceSlider setFloatValue:0.0]; + } + else + { + [fDecombDeinterlaceSlider setFloatValue:1.0]; + } + [self modeDecombDeinterlaceSliderChanged:nil]; } -- (void) setDeblock: (int) setting -{ - fPictureFilterSettings.deblock = setting; +- (void) setDecomb: (int) setting { + fPictureFilterSettings.decomb = setting; } -- (IBAction)showPreviewPanel: (id)sender forTitle: (hb_title_t *)title +- (void) setDecombCustomString: (NSString*) string { - [self SetTitle:title]; - [self showWindow:sender]; - + [fDecombField setStringValue:string]; } - -// This function converts an image created by libhb (specified via pictureIndex) into -// an NSImage suitable for the GUI code to use. If removeBorders is YES, -// makeImageForPicture crops the image generated by libhb stripping off the gray -// border around the content. This is the low-level method that generates the image. -// -imageForPicture calls this function whenever it can't find an image in its cache. -+ (NSImage *) makeImageForPicture: (int)pictureIndex - libhb:(hb_handle_t*)handle - title:(hb_title_t*)title - removeBorders:(BOOL)removeBorders +- (int) denoise { - if (removeBorders) - { - // |<---------- title->width ----------->| - // | |<---- title->job->width ---->| | - // | | | | - // ....................................... - // ....+-----------------------------+.... - // ....| |....<-- gray border - // ....| |.... - // ....| |.... - // ....| |<------- image - // ....| |.... - // ....| |.... - // ....| |.... - // ....| |.... - // ....| |.... - // ....+-----------------------------+.... - // ....................................... - - static uint8_t * buffer; - static int bufferSize; - - // Make sure we have a big enough buffer to receive the image from libhb. libhb - // creates images with a one-pixel border around the original content. Hence we - // add 2 pixels horizontally and vertically to the buffer size. - int srcWidth = title->width + 2; - int srcHeight= title->height + 2; - int newSize; - newSize = srcWidth * srcHeight * 4; - if( bufferSize < newSize ) - { - bufferSize = newSize; - buffer = (uint8_t *) realloc( buffer, bufferSize ); - } - - hb_get_preview( handle, title, pictureIndex, buffer ); - - // Create an NSBitmapImageRep and copy the libhb image into it, converting it from - // libhb's format to one suitable for NSImage. Along the way, we'll strip off the - // border around libhb's image. - - // The image data returned by hb_get_preview is 4 bytes per pixel, BGRA format. - // Alpha is ignored. - - int dstWidth = title->job->width; - int dstHeight = title->job->height; - NSBitmapFormat bitmapFormat = (NSBitmapFormat)NSAlphaFirstBitmapFormat; - NSBitmapImageRep * imgrep = [[[NSBitmapImageRep alloc] - initWithBitmapDataPlanes:nil - pixelsWide:dstWidth - pixelsHigh:dstHeight - bitsPerSample:8 - samplesPerPixel:3 // ignore alpha - hasAlpha:NO - isPlanar:NO - colorSpaceName:NSCalibratedRGBColorSpace - bitmapFormat:bitmapFormat - bytesPerRow:dstWidth * 4 - bitsPerPixel:32] autorelease]; - - int borderTop = (srcHeight - dstHeight) / 2; - int borderLeft = (srcWidth - dstWidth) / 2; - - UInt32 * src = (UInt32 *)buffer; - UInt32 * dst = (UInt32 *)[imgrep bitmapData]; - src += borderTop * srcWidth; // skip top rows in src to get to first row of dst - src += borderLeft; // skip left pixels in src to get to first pixel of dst - for (int r = 0; r < dstHeight; r++) - { - for (int c = 0; c < dstWidth; c++) -#if TARGET_RT_LITTLE_ENDIAN - *dst++ = Endian32_Swap(*src++); -#else - *dst++ = *src++; -#endif - src += (srcWidth - dstWidth); // skip to next row in src - } - - NSImage * img = [[[NSImage alloc] initWithSize: NSMakeSize(dstWidth, dstHeight)] autorelease]; - [img addRepresentation:imgrep]; - - return img; - } - else - { - // Make sure we have big enough buffer - static uint8_t * buffer; - static int bufferSize; - - int newSize; - newSize = ( title->width + 2 ) * (title->height + 2 ) * 4; - if( bufferSize < newSize ) - { - bufferSize = newSize; - buffer = (uint8_t *) realloc( buffer, bufferSize ); - } - - hb_get_preview( handle, title, pictureIndex, buffer ); - - // The image data returned by hb_get_preview is 4 bytes per pixel, BGRA format. - // We'll copy that into an NSImage swapping it to ARGB in the process. Alpha is - // ignored. - int width = title->width + 2; // hblib adds a one-pixel border to the image - int height = title->height + 2; - int numPixels = width * height; - NSBitmapFormat bitmapFormat = (NSBitmapFormat)NSAlphaFirstBitmapFormat; - NSBitmapImageRep * imgrep = [[[NSBitmapImageRep alloc] - initWithBitmapDataPlanes:nil - pixelsWide:width - pixelsHigh:height - bitsPerSample:8 - samplesPerPixel:3 // ignore alpha - hasAlpha:NO - isPlanar:NO - colorSpaceName:NSCalibratedRGBColorSpace - bitmapFormat:bitmapFormat - bytesPerRow:width * 4 - bitsPerPixel:32] autorelease]; - - UInt32 * src = (UInt32 *)buffer; - UInt32 * dst = (UInt32 *)[imgrep bitmapData]; - for (int i = 0; i < numPixels; i++) -#if TARGET_RT_LITTLE_ENDIAN - *dst++ = Endian32_Swap(*src++); -#else - *dst++ = *src++; -#endif - - NSImage * img = [[[NSImage alloc] initWithSize: NSMakeSize(width, height)] autorelease]; - [img addRepresentation:imgrep]; - - return img; - } + return fPictureFilterSettings.denoise; } -// Returns the preview image for the specified index, retrieving it from its internal -// cache or by calling makeImageForPicture if it is not cached. Generally, you should -// use imageForPicture so that images are cached. Calling makeImageForPicture will -// always generate a new copy of the image. -- (NSImage *) imageForPicture: (int) pictureIndex +- (NSString*) denoiseCustomString { - // The preview for the specified index may not currently exist, so this method - // generates it if necessary. - NSString * key = [NSString stringWithFormat:@"%d", pictureIndex]; - NSImage * theImage = [fPicturePreviews objectForKey:key]; - if (!theImage) - { - theImage = [PictureController makeImageForPicture:pictureIndex libhb:fHandle title:fTitle removeBorders: NO]; - [fPicturePreviews setObject:theImage forKey:key]; - } - return theImage; + return [fDenoiseField stringValue]; } -// Purges all images from the cache. The next call to imageForPicture will cause a new -// image to be generated. -- (void) purgeImageCache +- (void) setDenoiseCustomString: (NSString*) string { - [fPicturePreviews removeAllObjects]; + [fDenoiseField setStringValue:string]; } -@end - -@implementation PictureController (Private) - -// -// -[PictureController(Private) optimalViewSizeForImageSize:] -// -// Given the size of the preview image to be shown, returns the best possible -// size for the view. -// -- (NSSize)optimalViewSizeForImageSize: (NSSize)imageSize +- (void) setDenoise: (int) setting { - // The min size is 320x240 - CGFloat minWidth = 320.0; - CGFloat minHeight = 240.0; - - NSSize screenSize = [[NSScreen mainScreen] frame].size; - NSSize sheetSize = [[self window] frame].size; - NSSize viewAreaSize = [fPictureViewArea frame].size; - CGFloat paddingX = sheetSize.width - viewAreaSize.width; - CGFloat paddingY = sheetSize.height - viewAreaSize.height; - /* Since we are now non-modal, lets go ahead and allow the mac size to - * go up to the full screen height or width below. Am leaving the original - * code here that blindjimmy setup for 85% in case we don't like it. - */ - // The max size of the view is when the sheet is taking up 85% of the screen. - //CGFloat maxWidth = (0.85 * screenSize.width) - paddingX; - //CGFloat maxHeight = (0.85 * screenSize.height) - paddingY; - CGFloat maxWidth = screenSize.width - paddingX; - CGFloat maxHeight = screenSize.height - paddingY; - - NSSize resultSize = imageSize; - - // Its better to have a view that's too small than a view that's too big, so - // apply the maximum constraints last. - if( resultSize.width < minWidth ) - { - resultSize.height *= (minWidth / resultSize.width); - resultSize.width = minWidth; - } - if( resultSize.height < minHeight ) - { - resultSize.width *= (minHeight / resultSize.height); - resultSize.height = minHeight; - } - if( resultSize.width > maxWidth ) - { - resultSize.height *= (maxWidth / resultSize.width); - resultSize.width = maxWidth; - } - if( resultSize.height > maxHeight ) - { - resultSize.width *= (maxHeight / resultSize.height); - resultSize.height = maxHeight; - } - - return resultSize; + fPictureFilterSettings.denoise = setting; } -// -// -[PictureController(Private) resizePanelForViewSize:animate:] -// -// Resizes the entire sheet to accomodate a view of a particular size. -// -- (void)resizeSheetForViewSize: (NSSize)viewSize +- (int) deblock { - // Figure out the deltas for the new frame area - NSSize currentSize = [fPictureViewArea frame].size; - CGFloat deltaX = viewSize.width - currentSize.width; - CGFloat deltaY = viewSize.height - currentSize.height; - - // Now resize the whole panel by those same deltas, but don't exceed the min - NSRect frame = [[self window] frame]; - NSSize maxSize = [[self window] maxSize]; - NSSize minSize = [[self window] minSize]; - frame.size.width += deltaX; - frame.size.height += deltaY; - if( frame.size.width < minSize.width ) - { - frame.size.width = minSize.width; - } - if( frame.size.height < minSize.height ) - { - frame.size.height = minSize.height; - } - - // But now the sheet is off-center, so also shift the origin to center it and - // keep the top aligned. - if( frame.size.width != [[self window] frame].size.width ) - frame.origin.x -= (deltaX / 2.0); - - if( frame.size.height != [[self window] frame].size.height ) - frame.origin.y -= deltaY; + return fPictureFilterSettings.deblock; +} - [[self window] setFrame:frame display:YES animate:YES]; +- (void) setDeblock: (int) setting +{ + fPictureFilterSettings.deblock = setting; } -// -// -[PictureController(Private) setViewSize:] -// -// Changes the view's size and centers it vertically inside of its area. -// Assumes resizeSheetForViewSize: has already been called. -// -- (void)setViewSize: (NSSize)viewSize +- (int) grayscale { - [fPictureView setFrameSize:viewSize]; - - // center it vertically - NSPoint origin = [fPictureViewArea frame].origin; - origin.y += ([fPictureViewArea frame].size.height - - [fPictureView frame].size.height) / 2.0; - [fPictureView setFrameOrigin:origin]; + return fPictureFilterSettings.grayscale; } -// -// -[PictureController(Private) viewNeedsToResizeToSize:] -// -// Returns YES if the view will need to resize to match the given size. -// -- (BOOL)viewNeedsToResizeToSize: (NSSize)newSize +- (void) setGrayscale: (int) setting { - NSSize viewSize = [fPictureView frame].size; - return (newSize.width != viewSize.width || newSize.height != viewSize.height); + fPictureFilterSettings.grayscale = setting; } + + @end +