1 /* $Id: PictureController.mm,v 1.11 2005/08/01 15:10:44 titer Exp $
3 This file is part of the HandBrake source code.
4 Homepage: <http://handbrake.fr/>.
5 It may be used under the terms of the GNU General Public License. */
7 #import "PictureController.h"
9 #import "HBPreviewController.h"
13 @implementation PictureController
17 if (self = [super initWithWindowNibName:@"PictureSettings"])
19 // NSWindowController likes to lazily load its window. However since
20 // this controller tries to set all sorts of outlets before the window
21 // is displayed, we need it to load immediately. The correct way to do
22 // this, according to the documentation, is simply to invoke the window
25 // If/when we switch a lot of this stuff to bindings, this can probably
29 fPreviewController = [[PreviewController alloc] init];
34 //------------------------------------------------------------------------------------
35 // Displays and brings the picture window to the front
36 //------------------------------------------------------------------------------------
37 - (IBAction) showPictureWindow: (id)sender
41 if ([[self window] isVisible])
43 [[self window] close];
47 [self showWindow:sender];
48 [[NSUserDefaults standardUserDefaults] setBool:YES forKey:@"PictureSizeWindowIsOpen"];
49 [self setToWindowedMode];
52 [self adjustFilterDisplay:nil];
53 [self adjustSizingDisplay:nil];
58 /* this method is used to detect clicking on a tab in fSizeFilterView */
59 - (void)tabView:(NSTabView *)tabView didSelectTabViewItem:(NSTabViewItem *)tabViewItem
62 [self resizeInspectorForTab:nil];
68 /* resizeInspectorForTab is called at launch, and each time either the
69 * Size or Filters tab is clicked. Size gives a horizontally oriented
70 * inspector and Filters is a vertically aligned inspector.
72 - (IBAction) resizeInspectorForTab: (id)sender
74 NSRect frame = [[self window] frame];
75 NSPoint windowOrigin = [[self window] frame].origin;
76 NSSize screenSize = [[[self window] screen] frame].size;
77 NSPoint screenOrigin = [[[self window] screen] frame].origin;
79 /* We base our inspector size/layout on which tab is active for fSizeFilterView */
80 /* we are 1 which is Filters*/
81 if ([fSizeFilterView indexOfTabViewItem: [fSizeFilterView selectedTabViewItem]] == 1)
83 frame.size.width = 314;
84 /* we glean the height from the size of the boxes plus the extra window space
85 * needed for non boxed display
87 frame.size.height = 110.0 + [fDetelecineBox frame].size.height + [fDecombDeinterlaceBox frame].size.height + [fDenoiseBox frame].size.height + [fDeblockBox frame].size.height;
88 /* Hide the size readout at the bottom as the vertical inspector is not wide enough */
89 [fSizeInfoField setHidden:YES];
91 else // we are Tab index 0 which is size
93 frame.size.width = 50.0 + [fPictureSizeBox frame].size.width + [fPictureCropBox frame].size.width;
94 frame.size.height = [fPictureSizeBox frame].size.height + 85;
95 /* hide the size summary field at the bottom */
96 [fSizeInfoField setHidden:NO];
98 /* get delta's for the change in window size */
99 CGFloat deltaX = frame.size.width - [[self window] frame].size.width;
100 CGFloat deltaY = frame.size.height - [[self window] frame].size.height;
102 /* Check to see if we have changed the height from current */
103 //if (frame.size.height != [[self window] frame].size.height)
105 /* change the inspector origin via the deltaY */
106 frame.origin.y -= deltaY;
107 /* keep the inspector centered so the tabs stay in place */
108 frame.origin.x -= deltaX / 2.0;
111 /* we make sure we are not horizontally off of our screen.
112 * this would be the case if we are on the vertical filter tab
113 * and we hit the size tab and the inspector grows horizontally
114 * off the screen to the right
116 if ((frame.origin.x + frame.size.width) > (screenOrigin.x + screenSize.width))
118 /* the right side of the preview is off the screen, so shift to the left */
119 frame.origin.x = (screenOrigin.x + screenSize.width) - frame.size.width;
122 [[self window] setFrame:frame display:YES animate:YES];
125 - (IBAction) adjustSizingDisplay: (id) sender
127 NSSize pictureSizingBoxSize = [fPictureSizeBox frame].size;
129 NSPoint fPictureSizeBoxOrigin = [fPictureSizeBox frame].origin;
130 NSSize pictureCropBoxSize = [fPictureCropBox frame].size;
131 NSPoint fPictureCropBoxOrigin = [fPictureCropBox frame].origin;
133 if ([fAnamorphicPopUp indexOfSelectedItem] == 3) // custom / power user jamboree
135 pictureSizingBoxSize.width = 530;
137 /* Set visibility of capuj widgets */
138 [fParWidthField setHidden: NO];
139 [fParHeightField setHidden: NO];
140 [fParWidthLabel setHidden: NO];
141 [fParHeightLabel setHidden: NO];
142 [fDisplayWidthField setHidden: NO];
143 [fDisplayWidthLabel setHidden: NO];
144 /* adjust/move keep ar checkbox */
145 [fRatioLabel setHidden: YES];
146 [fRatioLabel2 setHidden: NO];
148 /* Optionally swith the Storage and Display width positions*/
150 NSPoint fWidthLabelOrigin = [fWidthLabel frame].origin;
151 NSPoint fWidthFieldOrigin = [fWidthField frame].origin;
152 NSPoint fWidthStepperOrigin = [fWidthStepper frame].origin;
153 fWidthFieldOrigin.x = [fRatioLabel2 frame].origin.x + [fRatioLabel2 frame].size.width + 4;
154 [fWidthField setFrameOrigin:fWidthFieldOrigin];
156 fWidthStepperOrigin.x = [fWidthField frame].origin.x + [fWidthField frame].size.width + 4;
157 [fWidthStepper setFrameOrigin:fWidthStepperOrigin];
159 fWidthLabelOrigin.x = [fWidthField frame].origin.x - [fWidthLabel frame].size.width - 4;
160 [fWidthLabel setFrameOrigin:fWidthLabelOrigin];
161 [fWidthLabel setStringValue:@"Storage Width:"];
164 /* set the origin for fRatioCheck so origin.y == fRatioLabel2
165 * and origin.x == fDisplayWidthField
167 NSPoint fRatioCheckOrigin = [fRatioCheck frame].origin;
168 fRatioCheckOrigin.y = [fRatioLabel2 frame].origin.y - 2;
169 fRatioCheckOrigin.x = [fRatioLabel2 frame].origin.x + [fRatioLabel2 frame].size.width + 4;
170 [fRatioCheck setFrameOrigin:fRatioCheckOrigin];
175 pictureSizingBoxSize.width = 200;
177 /* Set visibility of capuj widgets */
178 [fParWidthField setHidden: YES];
179 [fParHeightField setHidden: YES];
180 [fParWidthLabel setHidden: YES];
181 [fParHeightLabel setHidden: YES];
182 [fDisplayWidthField setHidden: YES];
183 [fDisplayWidthLabel setHidden: YES];
184 /* adjust/move keep ar checkbox */
185 [fRatioLabel setHidden: NO];
186 [fRatioLabel2 setHidden: YES];
188 /* Optionally swith the Storage and Display width positions*/
191 NSPoint fWidthLabelOrigin = [fWidthLabel frame].origin;
192 NSPoint fWidthFieldOrigin = [fWidthField frame].origin;
193 NSPoint fWidthStepperOrigin = [fWidthStepper frame].origin;
195 fWidthFieldOrigin.x = [fHeightField frame].origin.x;
196 [fWidthField setFrameOrigin:fWidthFieldOrigin];
198 fWidthStepperOrigin.x = [fHeightStepper frame].origin.x;
199 [fWidthStepper setFrameOrigin:fWidthStepperOrigin];
201 fWidthLabelOrigin.x = [fWidthField frame].origin.x - [fWidthLabel frame].size.width -4;
202 [fWidthLabel setFrameOrigin:fWidthLabelOrigin];
203 [fWidthLabel setStringValue:@"Width:"];
207 /* set the origin for fRatioCheck so origin.y == fRatioLabel
208 * and origin.x == fWidthStepper
210 NSPoint fRatioCheckOrigin = [fRatioCheck frame].origin;
211 fRatioCheckOrigin.y = [fRatioLabel frame].origin.y - 2;
212 fRatioCheckOrigin.x = [fWidthStepper frame].origin.x - 2;
213 [fRatioCheck setFrameOrigin:fRatioCheckOrigin];
217 /* Check to see if we have changed the size from current */
218 if (pictureSizingBoxSize.height != [fPictureSizeBox frame].size.height || pictureSizingBoxSize.width != [fPictureSizeBox frame].size.width)
220 /* Get our delta for the change in picture size box height */
221 CGFloat deltaYSizeBoxShift = pictureSizingBoxSize.height - [fPictureSizeBox frame].size.height;
222 fPictureSizeBoxOrigin.y -= deltaYSizeBoxShift;
223 /* Get our delta for the change in picture size box width */
224 CGFloat deltaXSizeBoxShift = pictureSizingBoxSize.width - [fPictureSizeBox frame].size.width;
225 //fPictureSizeBoxOrigin.x += deltaXSizeBoxShift;
226 /* set our new Picture size box size */
227 [fPictureSizeBox setFrameSize:pictureSizingBoxSize];
228 [fPictureSizeBox setFrameOrigin:fPictureSizeBoxOrigin];
230 pictureCropBoxSize.height += deltaYSizeBoxShift;
231 fPictureCropBoxOrigin.y -= deltaYSizeBoxShift;
232 fPictureCropBoxOrigin.x += deltaXSizeBoxShift;
234 [fPictureCropBox setFrameSize:pictureCropBoxSize];
235 [[fPictureCropBox animator] setFrameOrigin:fPictureCropBoxOrigin];
239 /* now we call to resize the entire inspector window */
240 [self resizeInspectorForTab:nil];
243 - (IBAction) adjustFilterDisplay: (id) sender
246 NSBox * filterBox = nil;
247 NSTextField * filterField;
248 if (sender == fDetelecinePopUp)
250 filterBox = fDetelecineBox;
251 filterField = fDetelecineField;
254 if (sender == fDecombDeinterlaceSlider)
256 if ([fDecombDeinterlaceSlider floatValue] == 0.0)
258 filterBox = fDecombBox;
259 filterField = fDecombField;
263 filterBox = fDeinterlaceBox;
264 filterField = fDeinterlaceField;
268 if (sender == fDecombPopUp)
270 filterBox = fDecombBox;
271 filterField = fDecombField;
273 if (sender == fDeinterlacePopUp)
275 filterBox = fDeinterlaceBox;
276 filterField = fDeinterlaceField;
279 if (sender == fDenoisePopUp)
281 filterBox = fDenoiseBox;
282 filterField = fDenoiseField;
285 NSSize currentSize = [filterBox frame].size;
286 NSRect boxFrame = [filterBox frame];
288 if ([sender titleOfSelectedItem] == @"Custom")
291 currentSize.height = 60;
296 currentSize.height = 30;
299 /* Check to see if we have changed the size from current */
300 if (currentSize.height != [filterBox frame].size.height)
302 /* We are changing the size of the box, so recalc the origin */
303 NSPoint boxOrigin = [filterBox frame].origin;
304 /* We get the deltaY here for how much we are expanding/contracting the box vertically */
305 CGFloat deltaYBoxShift = currentSize.height - [filterBox frame].size.height;
306 boxOrigin.y -= deltaYBoxShift;
308 boxFrame.size.height = currentSize.height;
309 boxFrame.origin.y = boxOrigin.y;
310 [filterBox setFrame:boxFrame];
312 /* go ahead and resize the box */
313 //[[filterBox animator] setFrameSize:currentSize];
314 //[[filterBox animator] setFrameOrigin:origin];
317 if (filterBox == fDecombBox || filterBox == fDeinterlaceBox)
319 /* fDecombDeinterlaceBox*/
320 NSSize decombDeinterlaceBoxSize = [fDecombDeinterlaceBox frame].size;
321 NSPoint decombDeinterlaceBoxOrigin = [fDecombDeinterlaceBox frame].origin;
323 //decombDeinterlaceBoxSize.height = [filterBox frame].size.height + 50;
324 if (sender == fDecombDeinterlaceSlider)
326 [fHBController writeToActivityLog: "Sender is deinterlace decomb slider"];
329 if ([fDeinterlaceBox isHidden] == YES)
331 decombDeinterlaceBoxSize.height = [fDecombBox frame].size.height + 50;
332 [fHBController writeToActivityLog: "Resize by Decomb box"];
336 decombDeinterlaceBoxSize.height = [fDeinterlaceBox frame].size.height + 50;
337 [fHBController writeToActivityLog: "Resize by Deinterlace box"];
339 /* get delta's for the change in window size */
341 CGFloat deltaYdecombDeinterlace = decombDeinterlaceBoxSize.height - [fDecombDeinterlaceBox frame].size.height;
343 deltaYBoxShift = deltaYdecombDeinterlace;
345 decombDeinterlaceBoxOrigin.y -= deltaYdecombDeinterlace;
347 [fDecombDeinterlaceBox setFrameSize:decombDeinterlaceBoxSize];
348 [fDecombDeinterlaceBox setFrameOrigin:decombDeinterlaceBoxOrigin];
351 /* now we must reset the origin of each box below the adjusted box*/
352 NSPoint decombDeintOrigin = [fDecombDeinterlaceBox frame].origin;
353 NSPoint denoiseOrigin = [fDenoiseBox frame].origin;
354 NSPoint deblockOrigin = [fDeblockBox frame].origin;
355 if (sender == fDetelecinePopUp)
357 decombDeintOrigin.y -= deltaYBoxShift;
358 [fDecombDeinterlaceBox setFrameOrigin:decombDeintOrigin];
360 denoiseOrigin.y -= deltaYBoxShift;
361 [fDenoiseBox setFrameOrigin:denoiseOrigin];
363 deblockOrigin.y -= deltaYBoxShift;
364 [fDeblockBox setFrameOrigin:deblockOrigin];
366 if (sender == fDecombPopUp || sender == fDeinterlacePopUp)
368 denoiseOrigin.y -= deltaYBoxShift;
369 [fDenoiseBox setFrameOrigin:denoiseOrigin];
371 deblockOrigin.y -= deltaYBoxShift;
372 [fDeblockBox setFrameOrigin:deblockOrigin];
375 if (sender == fDenoisePopUp)
377 deblockOrigin.y -= deltaYBoxShift;
378 [fDeblockBox setFrameOrigin:deblockOrigin];
381 /* now we call to resize the entire inspector window */
382 [self resizeInspectorForTab:nil];
392 - (IBAction) showPreviewWindow: (id)sender
394 [[NSUserDefaults standardUserDefaults] setBool:YES forKey:@"PreviewWindowIsOpen"];
395 [fPreviewController showWindow:sender];
398 - (void) enablePreviewHudControls
400 [fPreviewController enableHudControls];
403 - (void) disablePreviewHudControls
405 [fPreviewController disableHudControls];
408 - (void) setToWindowedMode
410 /* Set the window back to Floating Window mode
411 * This will put the window always on top, but
412 * since we have Hide on Deactivate set in our
413 * xib, if other apps are put in focus we will
414 * hide properly to stay out of the way
416 [[self window] setLevel:NSFloatingWindowLevel];
419 - (void)setHBController: (HBController *)controller
421 fHBController = controller;
422 [fPreviewController setHBController: controller];
428 [fPictureWindow setDelegate:self];
429 if( ![[self window] setFrameUsingName:@"PictureSizing"] )
430 [[self window] center];
431 [self setWindowFrameAutosaveName:@"PictureSizing"];
432 [[self window] setExcludedFromWindowsMenu:YES];
434 [self setInitialPictureFilters];
436 /* Setup our layers for core animation */
437 [fSizeFilterView setWantsLayer:YES];
438 [fPictureSizeBox setWantsLayer:YES];
439 [fPictureCropBox setWantsLayer:YES];
444 - (void)windowWillClose:(NSNotification *)aNotification
446 [[NSUserDefaults standardUserDefaults] setBool:NO forKey:@"PictureSizeWindowIsOpen"];
449 - (BOOL)windowShouldClose:(id)fPictureWindow
456 [fPreviewController release];
460 - (void) SetHandle: (hb_handle_t *) handle
464 [fPreviewController SetHandle: fHandle];
467 - (void) SetTitle: (hb_title_t *) title
469 hb_job_t * job = title->job;
473 [fWidthStepper setValueWraps: NO];
474 [fWidthStepper setIncrement: 16];
475 [fWidthStepper setMinValue: 64];
476 [fHeightStepper setValueWraps: NO];
477 [fHeightStepper setIncrement: 16];
478 [fHeightStepper setMinValue: 64];
480 [fCropTopStepper setIncrement: 2];
481 [fCropTopStepper setMinValue: 0];
482 [fCropBottomStepper setIncrement: 2];
483 [fCropBottomStepper setMinValue: 0];
484 [fCropLeftStepper setIncrement: 2];
485 [fCropLeftStepper setMinValue: 0];
486 [fCropRightStepper setIncrement: 2];
487 [fCropRightStepper setMinValue: 0];
489 [fWidthStepper setMaxValue: title->width];
490 [fWidthStepper setIntValue: job->width];
491 [fWidthField setIntValue: job->width];
492 [fHeightStepper setMaxValue: title->height];
493 [fHeightStepper setIntValue: job->height];
494 [fHeightField setIntValue: job->height];
495 [fRatioCheck setState: job->keep_ratio ? NSOnState : NSOffState];
496 [fCropTopStepper setMaxValue: title->height/2-2];
497 [fCropBottomStepper setMaxValue: title->height/2-2];
498 [fCropLeftStepper setMaxValue: title->width/2-2];
499 [fCropRightStepper setMaxValue: title->width/2-2];
501 /* Populate the Anamorphic NSPopUp button here */
502 [fAnamorphicPopUp removeAllItems];
503 [fAnamorphicPopUp addItemWithTitle: @"None"];
504 [fAnamorphicPopUp addItemWithTitle: @"Strict"];
505 [fAnamorphicPopUp addItemWithTitle: @"Loose"];
506 [fAnamorphicPopUp addItemWithTitle: @"Custom"];
507 [fAnamorphicPopUp selectItemAtIndex: job->anamorphic.mode];
509 //[self adjustSizingDisplay:nil];
511 /* populate the modulus popup here */
512 [fModulusPopUp removeAllItems];
513 [fModulusPopUp addItemWithTitle: @"16"];
514 [fModulusPopUp addItemWithTitle: @"8"];
515 [fModulusPopUp addItemWithTitle: @"4"];
516 [fModulusPopUp addItemWithTitle: @"2"];
519 [fModulusPopUp selectItemWithTitle: [NSString stringWithFormat:@"%d",job->modulus]];
523 [fModulusPopUp selectItemAtIndex: 0];
527 /* We initially set the previous state of keep ar to on */
528 keepAspectRatioPreviousState = 1;
531 [fCropMatrix selectCellAtRow: 1 column:0];
532 /* If auto, lets set the crop steppers according to current job->crop values */
533 [fCropTopStepper setIntValue: job->crop[0]];
534 [fCropTopField setIntValue: job->crop[0]];
535 [fCropBottomStepper setIntValue: job->crop[1]];
536 [fCropBottomField setIntValue: job->crop[1]];
537 [fCropLeftStepper setIntValue: job->crop[2]];
538 [fCropLeftField setIntValue: job->crop[2]];
539 [fCropRightStepper setIntValue: job->crop[3]];
540 [fCropRightField setIntValue: job->crop[3]];
544 [fCropMatrix selectCellAtRow: 0 column:0];
547 /* Set filters widgets according to the filters struct */
548 [fDetelecinePopUp selectItemAtIndex:fPictureFilterSettings.detelecine];
549 [fDecombPopUp selectItemAtIndex:fPictureFilterSettings.decomb];
550 [fDeinterlacePopUp selectItemAtIndex: fPictureFilterSettings.deinterlace];
551 [fDenoisePopUp selectItemAtIndex: fPictureFilterSettings.denoise];
552 [fDeblockSlider setFloatValue:fPictureFilterSettings.deblock];
553 [fGrayscaleCheck setState:fPictureFilterSettings.grayscale];
555 [self deblockSliderChanged: nil];
558 MaxOutputWidth = title->width - job->crop[2] - job->crop[3];
559 MaxOutputHeight = title->height - job->crop[0] - job->crop[1];
561 titleDarWidth = job->anamorphic.dar_width;
562 titleDarHeight = job->anamorphic.dar_height;
564 titleParWidth = job->anamorphic.par_width;
565 titleParHeight = job->anamorphic.par_height;
567 [self SettingsChanged:nil];
570 - (IBAction) storageLinkChanged: (id) sender
572 /* since we have a tickless slider, make sure we are at 0.0 or 1.0 */
573 if ([fStorageLinkSlider floatValue] < 0.50)
575 [fStorageLinkSlider setFloatValue:0.0];
576 /* set slider labels to reflect choice */
577 [fStorageLinkParLabel setEnabled:YES];
578 [fStorageLinkDisplayLabel setEnabled:NO];
583 [fStorageLinkSlider setFloatValue:1.0];
584 /* set slider labels to reflect choice */
585 [fStorageLinkParLabel setEnabled:NO];
586 [fStorageLinkDisplayLabel setEnabled:YES];
591 - (IBAction) parLinkChanged: (id) sender
593 /* since we have a tickless slider, make sure we are at 0.0 or 1.0 */
594 if ([fParLinkSlider floatValue] < 0.50)
596 [fParLinkSlider setFloatValue:0.0];
597 /* set slider labels to reflect choice */
598 [fParLinkStorageLabel setEnabled:YES];
599 [fParLinkDisplayLabel setEnabled:NO];
603 [fParLinkSlider setFloatValue:1.0];
604 /* set slider labels to reflect choice */
605 [fParLinkStorageLabel setEnabled:NO];
606 [fParLinkDisplayLabel setEnabled:YES];
611 - (IBAction) displayLinkChanged: (id) sender
613 /* since we have a tickless slider, make sure we are at 0.0 or 1.0 */
614 if ([fDisplayLinkSlider floatValue] < 0.50)
616 [fDisplayLinkSlider setFloatValue:0.0];
617 /* set slider labels to reflect choice */
618 [fDisplayLinkStorageLabel setEnabled:YES];
619 [fDisplayLinkParLabel setEnabled:NO];
623 [fDisplayLinkSlider setFloatValue:1.0];
624 /* set slider labels to reflect choice */
625 [fDisplayLinkStorageLabel setEnabled:NO];
626 [fDisplayLinkParLabel setEnabled:YES];
631 - (IBAction) SettingsChanged: (id) sender
633 hb_job_t * job = fTitle->job;
635 /* if we are anything but strict anamorphic */
636 if ([fAnamorphicPopUp indexOfSelectedItem] != 1)
638 [fModulusLabel setHidden:NO];
639 [fModulusPopUp setHidden:NO];
640 if (sender == fModulusPopUp)
642 /* do a dry run with hb_fix aspect to get new modulus */
643 job->modulus = [[fModulusPopUp titleOfSelectedItem] intValue];
645 hb_fix_aspect( job, HB_KEEP_WIDTH );
646 if( job->height > fTitle->height )
648 job->height = fTitle->height;
649 hb_fix_aspect( job, HB_KEEP_HEIGHT );
651 [fWidthStepper setIntValue: job->width];
652 [fWidthField setIntValue: job->width];
653 if( [fAnamorphicPopUp indexOfSelectedItem] != 2) // if we are not loose or custom
655 [fHeightStepper setIntValue: job->height];
656 [fHeightField setIntValue: job->height];
662 /* we are strict so hide the mod popup since libhb uses mod 2 for strict anamorphic*/
663 [fModulusLabel setHidden:YES];
664 [fModulusPopUp setHidden:YES];
667 job->modulus = [[fModulusPopUp titleOfSelectedItem] intValue];
669 [fWidthStepper setIncrement: job->modulus];
670 [fHeightStepper setIncrement: job->modulus];
672 /* Since custom anamorphic allows for a height setting > fTitle->height
673 * check to make sure it is returned to fTitle->height for all other modes
675 [fHeightStepper setMaxValue: fTitle->height];
677 autoCrop = ( [fCropMatrix selectedRow] == 0 );
678 [fCropTopStepper setEnabled: !autoCrop];
679 [fCropBottomStepper setEnabled: !autoCrop];
680 [fCropLeftStepper setEnabled: !autoCrop];
681 [fCropRightStepper setEnabled: !autoCrop];
685 memcpy( job->crop, fTitle->crop, 4 * sizeof( int ) );
689 job->crop[0] = [fCropTopStepper intValue];
690 job->crop[1] = [fCropBottomStepper intValue];
691 job->crop[2] = [fCropLeftStepper intValue];
692 job->crop[3] = [fCropRightStepper intValue];
695 [fRatioCheck setEnabled: YES];
698 [fParWidthField setEnabled: NO];
699 [fParHeightField setEnabled: NO];
700 [fDisplayWidthField setEnabled: NO];
702 /* If we are not custom anamorphic, make sure we retain the orginal par */
703 if( [fAnamorphicPopUp indexOfSelectedItem] != 3 )
705 job->anamorphic.par_width = titleParWidth;
706 job->anamorphic.par_height = titleParHeight;
707 [fRatioLabel setHidden: NO];
710 if( [fAnamorphicPopUp indexOfSelectedItem] > 0 )
712 if ([fAnamorphicPopUp indexOfSelectedItem] == 1) // strict
714 [fWidthStepper setIntValue: fTitle->width-fTitle->job->crop[2]-fTitle->job->crop[3]];
715 [fWidthField setIntValue: fTitle->width-fTitle->job->crop[2]-fTitle->job->crop[3]];
717 /* This will show correct anamorphic height values, but
718 show distorted preview picture ratio */
719 [fHeightStepper setIntValue: fTitle->height-fTitle->job->crop[0]-fTitle->job->crop[1]];
720 [fHeightField setIntValue: fTitle->height-fTitle->job->crop[0]-fTitle->job->crop[1]];
721 job->width = [fWidthStepper intValue];
722 job->height = [fHeightStepper intValue];
724 job->anamorphic.mode = 1;
725 [fWidthStepper setEnabled: NO];
726 [fWidthField setEnabled: NO];
727 [fHeightStepper setEnabled: NO];
728 [fHeightField setEnabled: NO];
729 [fRatioCheck setEnabled: NO];
731 else if ([fAnamorphicPopUp indexOfSelectedItem] == 2) // Loose anamorphic
733 job->anamorphic.mode = 2;
734 [fWidthStepper setEnabled: YES];
735 [fWidthField setEnabled: YES];
736 [fRatioCheck setEnabled: NO];
737 [fHeightStepper setEnabled: NO];
738 [fHeightField setEnabled: NO];
739 /* We set job->width and call hb_set_anamorphic_size in libhb to do a "dry run" to get
740 * the values to be used by libhb for loose anamorphic
742 /* if the sender is the anamorphic popup, then we know that loose anamorphic has just
743 * been turned on, so snap the width to full width for the source.
745 if (sender == fAnamorphicPopUp)
747 [fWidthStepper setIntValue: fTitle->width-fTitle->job->crop[2]-fTitle->job->crop[3]];
748 [fWidthField setIntValue: fTitle->width-fTitle->job->crop[2]-fTitle->job->crop[3]];
750 job->width = [fWidthStepper intValue];
751 hb_set_anamorphic_size(job, &output_width, &output_height, &output_par_width, &output_par_height);
752 [fHeightStepper setIntValue: output_height];
753 [fHeightField setIntValue: output_height];
754 job->height = [fHeightStepper intValue];
757 else if ([fAnamorphicPopUp indexOfSelectedItem] == 3) // custom / power user jamboree
760 #pragma mark - STARTCapuj
762 job->anamorphic.mode = 3;
764 /* Set the status of our custom ana only widgets accordingly */
765 [fModulusPopUp setEnabled:YES];
767 [fWidthStepper setEnabled: YES];
768 [fWidthField setEnabled: YES];
770 [fHeightStepper setEnabled: YES];
771 /* for capuj the storage field is immaterial */
772 [fHeightField setEnabled: YES];
774 [fRatioCheck setEnabled: YES];
775 if (sender == fRatioCheck)
777 if ([fRatioCheck state] == NSOnState)
779 [fParWidthField setEnabled: NO];
780 [fParHeightField setEnabled: NO];
784 [fParWidthField setEnabled: YES];
785 [fParHeightField setEnabled: YES];
789 [fParWidthField setEnabled: YES];
790 [fParHeightField setEnabled: YES];
792 [fDisplayWidthField setEnabled: YES];
795 /* If we are coming into custom anamorphic we reset the par to original
796 * which gives us a way back if things get hosed up.
799 if (sender == fAnamorphicPopUp)
801 /* When entering custom anamorphic, we start with keep ar on */
802 [fRatioCheck setState: NSOnState];
805 Disable editing: PIXEL WIDTH, PIXEL HEIGHT
807 [fParWidthField setEnabled: NO];
808 [fParHeightField setEnabled: NO];
810 job->width = [fWidthStepper intValue];
811 job->height = [fHeightStepper intValue];
813 /* make sure our par is set back to original */
814 job->anamorphic.par_width = titleParWidth;
815 job->anamorphic.par_height = titleParHeight;
817 [fParWidthField setIntValue: titleParWidth];
818 [fParHeightField setIntValue: titleParHeight];
820 /* modify our par dims from our storage dims */
821 hb_set_anamorphic_size(job, &output_width, &output_height, &output_par_width, &output_par_height);
822 float par_display_width = (float)output_width * (float)output_par_width / (float)output_par_height;
824 /* go ahead and mod the display dims */
825 [fDisplayWidthField setStringValue: [NSString stringWithFormat:@"%.2f", par_display_width]];
827 job->anamorphic.dar_width = [fDisplayWidthField floatValue];
828 job->anamorphic.dar_height = (float)[fHeightStepper intValue];
830 /* Set our dar here assuming we are just coming into capuj mode */
831 dar = [fDisplayWidthField floatValue] / (float)[fHeightField intValue];
835 /* For capuj we disable these fields if we are keeping the dispay aspect */
836 if ([fRatioCheck state] == NSOnState)
840 DAR = DISPLAY WIDTH / DISPLAY HEIGHT (cache after every modification) */
841 /*Disable editing: PIXEL WIDTH, PIXEL HEIGHT */
843 [fParWidthField setEnabled: NO];
844 [fParHeightField setEnabled: NO];
846 /* Changing DISPLAY WIDTH: */
847 if (sender == fDisplayWidthField)
849 job->anamorphic.dar_width = [fDisplayWidthField floatValue];
850 /* Changes HEIGHT to keep DAR */
851 /* calculate the height to retain the dar */
852 int raw_calulated_height = (int)((int)[fDisplayWidthField floatValue] / dar);
853 /* now use the modulus to go lower if there is a remainder */
854 /* Note to me, raw_calulated_height % [[fModulusPopUp titleOfSelectedItem] intValue]
855 * gives me the remainder we are not mod (whatever our modulus is) subtract that from
856 * the actual calculated value derived from the dar to round down to the nearest mod value.
857 * This should be desireable over rounding up to the next mod value
859 int modulus_height = raw_calulated_height - (raw_calulated_height % [[fModulusPopUp titleOfSelectedItem] intValue]);
860 if (modulus_height > fTitle->height)
862 [fHeightStepper setMaxValue: modulus_height];
864 [fHeightStepper setIntValue: modulus_height];
865 job->anamorphic.dar_height = (float)[fHeightStepper intValue];
866 job->height = [fHeightStepper intValue];
868 /* Changes PIXEL WIDTH to new DISPLAY WIDTH */
869 [fParWidthField setIntValue: [fDisplayWidthField intValue]];
870 job->anamorphic.par_width = [fParWidthField intValue];
871 /* Changes PIXEL HEIGHT to STORAGE WIDTH */
872 [fParHeightField setIntValue: [fWidthField intValue]];
873 job->anamorphic.par_height = [fParHeightField intValue];
876 /* Changing HEIGHT: */
877 if (sender == fHeightStepper)
879 job->anamorphic.dar_height = (float)[fHeightStepper intValue];
880 job->height = [fHeightStepper intValue];
882 /* Changes DISPLAY WIDTH to keep DAR*/
883 [fDisplayWidthField setStringValue: [NSString stringWithFormat: @"%.2f",[fHeightStepper intValue] * dar]];
884 job->anamorphic.dar_width = [fDisplayWidthField floatValue];
885 /* Changes PIXEL WIDTH to new DISPLAY WIDTH */
886 [fParWidthField setIntValue: [fDisplayWidthField intValue]];
887 job->anamorphic.par_width = [fParWidthField intValue];
888 /* Changes PIXEL HEIGHT to STORAGE WIDTH */
889 [fParHeightField setIntValue: [fWidthField intValue]];
890 job->anamorphic.par_height = [fParHeightField intValue];
892 /* Changing STORAGE_WIDTH: */
893 if (sender == fWidthStepper)
895 job->width = [fWidthStepper intValue];
897 job->anamorphic.dar_width = [fDisplayWidthField floatValue];
898 job->anamorphic.dar_height = [fHeightStepper floatValue];
900 /* Changes PIXEL WIDTH to DISPLAY WIDTH */
901 [fParWidthField setIntValue: [fDisplayWidthField intValue]];
902 job->anamorphic.par_width = [fParWidthField intValue];
903 /* Changes PIXEL HEIGHT to new STORAGE WIDTH */
904 [fParHeightField setIntValue: [fWidthStepper intValue]];
905 job->anamorphic.par_height = [fParHeightField intValue];
908 else if ([fRatioCheck state] == NSOffState)
910 /* Changing STORAGE_WIDTH: */
911 if (sender == fWidthStepper)
913 job->width = [fWidthStepper intValue];
914 /* changes DISPLAY WIDTH to STORAGE WIDTH * PIXEL WIDTH / PIXEL HEIGHT */
915 [fDisplayWidthField setStringValue: [NSString stringWithFormat: @"%.2f",(float)[fWidthStepper intValue] * [fParWidthField intValue] / [fParHeightField intValue]]];
916 job->anamorphic.dar_width = [fDisplayWidthField floatValue];
918 /* Changing PIXEL dimensions */
919 if (sender == fParWidthField || sender == fParHeightField)
921 job->anamorphic.par_width = [fParWidthField intValue];
922 job->anamorphic.par_height = [fParHeightField intValue];
923 /* changes DISPLAY WIDTH to STORAGE WIDTH * PIXEL WIDTH / PIXEL HEIGHT */
924 [fDisplayWidthField setStringValue: [NSString stringWithFormat: @"%.2f",(float)[fWidthStepper intValue] * [fParWidthField intValue] / [fParHeightField intValue]]];
925 job->anamorphic.dar_width = [fDisplayWidthField floatValue];
927 /* Changing DISPLAY WIDTH: */
928 if (sender == fDisplayWidthField)
930 job->anamorphic.dar_width = [fDisplayWidthField floatValue];
931 job->anamorphic.dar_height = (float)[fHeightStepper intValue];
932 /* changes PIXEL WIDTH to DISPLAY WIDTH and PIXEL HEIGHT to STORAGE WIDTH */
933 [fParWidthField setIntValue: [fDisplayWidthField intValue]];
934 job->anamorphic.par_width = [fParWidthField intValue];
936 [fParHeightField setIntValue: [fWidthField intValue]];
937 job->anamorphic.par_height = [fParHeightField intValue];
938 hb_set_anamorphic_size(job, &output_width, &output_height, &output_par_width, &output_par_height);
940 /* Changing HEIGHT: */
941 if (sender == fHeightStepper)
943 /* just....changes the height.*/
944 job->anamorphic.dar_height = [fHeightStepper intValue];
945 job->height = [fHeightStepper intValue];
950 #pragma mark - END Capuj
953 /* if the sender is the Anamorphic checkbox, record the state
954 of KeepAspect Ratio so it can be reset if Anamorphic is unchecked again */
955 if (sender == fAnamorphicPopUp)
957 keepAspectRatioPreviousState = [fRatioCheck state];
959 if ([fAnamorphicPopUp indexOfSelectedItem] != 3)
961 [fRatioCheck setState:NSOffState];
967 job->width = [fWidthStepper intValue];
968 job->height = [fHeightStepper intValue];
969 job->anamorphic.mode = 0;
970 [fWidthStepper setEnabled: YES];
971 [fWidthField setEnabled: YES];
972 [fHeightStepper setEnabled: YES];
973 [fHeightField setEnabled: YES];
974 [fRatioCheck setEnabled: YES];
975 /* if the sender is the Anamorphic checkbox, we return the
976 keep AR checkbox to its previous state */
977 if (sender == fAnamorphicPopUp)
979 [fRatioCheck setState:keepAspectRatioPreviousState];
984 if ([fAnamorphicPopUp indexOfSelectedItem] != 3)
986 job->keep_ratio = ( [fRatioCheck state] == NSOnState );
987 if( job->keep_ratio )
989 if( sender == fWidthStepper || sender == fRatioCheck ||
990 sender == fCropTopStepper || sender == fCropBottomStepper||
991 sender == fCropMatrix || sender == nil )
993 hb_fix_aspect( job, HB_KEEP_WIDTH );
994 if( job->height > fTitle->height )
996 job->height = fTitle->height;
997 hb_fix_aspect( job, HB_KEEP_HEIGHT );
1002 hb_fix_aspect( job, HB_KEEP_HEIGHT );
1003 if( job->width > fTitle->width )
1005 job->width = fTitle->width;
1006 hb_fix_aspect( job, HB_KEEP_WIDTH );
1013 // hb_get_preview can't handle sizes that are larger than the original title
1014 if ([fAnamorphicPopUp indexOfSelectedItem] != 3)
1017 if( job->width > fTitle->width )
1019 job->width = fTitle->width;
1022 if( job->height > fTitle->height )
1024 job->height = fTitle->height;
1028 [fWidthStepper setIntValue: job->width];
1029 [fWidthField setIntValue: job->width];
1030 if( [fAnamorphicPopUp indexOfSelectedItem] != 2) // if we are not loose or custom
1032 [fHeightStepper setIntValue: job->height];
1033 [fHeightField setIntValue: job->height];
1036 [fCropTopStepper setIntValue: job->crop[0]];
1037 [fCropTopField setIntValue: job->crop[0]];
1038 [fCropBottomStepper setIntValue: job->crop[1]];
1039 [fCropBottomField setIntValue: job->crop[1]];
1040 [fCropLeftStepper setIntValue: job->crop[2]];
1041 [fCropLeftField setIntValue: job->crop[2]];
1042 [fCropRightStepper setIntValue: job->crop[3]];
1043 [fCropRightField setIntValue: job->crop[3]];
1045 //[fPreviewController SetTitle:fTitle];
1047 /* Sanity Check Here for < 16 px preview to avoid
1048 crashing hb_get_preview. In fact, just for kicks
1049 lets getting previews at a min limit of 32, since
1050 no human can see any meaningful detail below that */
1051 if (job->width >= 64 && job->height >= 64)
1053 [self reloadStillPreview];
1056 /* we get the sizing info to display from fPreviewController */
1057 [fSizeInfoField setStringValue: [fPreviewController pictureSizeInfoString]];
1061 [fHBController pictureSettingsDidChange];
1064 if ([[self window] isVisible])
1066 [self adjustSizingDisplay:nil];
1071 - (NSString*) getPictureSizeInfoString
1073 return [fSizeInfoField stringValue];
1076 - (void)reloadStillPreview
1078 hb_job_t * job = fTitle->job;
1080 [fPreviewController SetTitle:fTitle];
1081 /* Sanity Check Here for < 16 px preview to avoid
1082 crashing hb_get_preview. In fact, just for kicks
1083 lets getting previews at a min limit of 32, since
1084 no human can see any meaningful detail below that */
1085 if (job->width >= 64 && job->height >= 64)
1088 // Purge the existing picture previews so they get recreated the next time
1090 // [fPreviewController purgeImageCache];
1091 /* We actually call displayPreview now from pictureSliderChanged which keeps
1092 * our picture preview slider in sync with the previews being shown
1095 //[fPreviewController pictureSliderChanged:nil];
1107 - (void) setAutoCrop: (BOOL) setting
1112 - (IBAction)showPreviewPanel: (id)sender forTitle: (hb_title_t *)title
1114 //[self SetTitle:title];
1115 [self showWindow:sender];
1116 //[self adjustSizingDisplay:nil];
1117 //[self adjustFilterDisplay:nil];
1123 /* we use this to setup the initial picture filters upon first launch, after that their states
1124 are maintained across different sources */
1125 - (void) setInitialPictureFilters
1127 /* we use a popup to show the detelecine settings */
1128 [fDetelecinePopUp removeAllItems];
1129 [fDetelecinePopUp addItemWithTitle: @"Off"];
1130 [fDetelecinePopUp addItemWithTitle: @"Custom"];
1131 [fDetelecinePopUp addItemWithTitle: @"Default"];
1132 [fDetelecinePopUp selectItemAtIndex: fPictureFilterSettings.detelecine];
1134 [self modeDecombDeinterlaceSliderChanged:nil];
1135 /* we use a popup to show the decomb settings */
1136 [fDecombPopUp removeAllItems];
1137 [fDecombPopUp addItemWithTitle: @"Off"];
1138 [fDecombPopUp addItemWithTitle: @"Custom"];
1139 [fDecombPopUp addItemWithTitle: @"Default"];
1141 [fDecombPopUp selectItemAtIndex: fPictureFilterSettings.decomb];
1143 /* we use a popup to show the deinterlace settings */
1144 [fDeinterlacePopUp removeAllItems];
1145 [fDeinterlacePopUp addItemWithTitle: @"Off"];
1146 [fDeinterlacePopUp addItemWithTitle: @"Custom"];
1147 [fDeinterlacePopUp addItemWithTitle: @"Fast"];
1148 [fDeinterlacePopUp addItemWithTitle: @"Slow"];
1149 [fDeinterlacePopUp addItemWithTitle: @"Slower"];
1151 /* Set deinterlaces level according to the integer in the main window */
1152 [fDeinterlacePopUp selectItemAtIndex: fPictureFilterSettings.deinterlace];
1154 /* we use a popup to show the denoise settings */
1155 [fDenoisePopUp removeAllItems];
1156 [fDenoisePopUp addItemWithTitle: @"Off"];
1157 [fDenoisePopUp addItemWithTitle: @"Custom"];
1158 [fDenoisePopUp addItemWithTitle: @"Weak"];
1159 [fDenoisePopUp addItemWithTitle: @"Medium"];
1160 [fDenoisePopUp addItemWithTitle: @"Strong"];
1161 /* Set denoises level according to the integer in the main window */
1162 [fDenoisePopUp selectItemAtIndex: fPictureFilterSettings.denoise];
1170 - (IBAction) modeDecombDeinterlaceSliderChanged: (id) sender
1173 /* since its a tickless slider, we have to make sure we are on or off */
1174 if ([fDecombDeinterlaceSlider floatValue] < 0.50)
1176 [fDecombDeinterlaceSlider setFloatValue:0.0];
1180 [fDecombDeinterlaceSlider setFloatValue:1.0];
1184 /* Decomb selected*/
1185 if ([fDecombDeinterlaceSlider floatValue] == 0.0)
1187 [fDecombBox setHidden:NO];
1188 [fDeinterlaceBox setHidden:YES];
1189 fPictureFilterSettings.decomb = [fDecombPopUp indexOfSelectedItem];
1190 fPictureFilterSettings.usedecomb = 1;
1191 fPictureFilterSettings.deinterlace = 0;
1192 [fDecombPopUp selectItemAtIndex:fPictureFilterSettings.decomb];
1193 [self adjustFilterDisplay:fDecombPopUp];
1197 [fDecombBox setHidden:YES];
1198 [fDeinterlaceBox setHidden:NO];
1199 fPictureFilterSettings.usedecomb = 0;
1200 fPictureFilterSettings.decomb = 0;
1201 [fDeinterlacePopUp selectItemAtIndex: fPictureFilterSettings.deinterlace];
1202 [self adjustFilterDisplay:fDeinterlacePopUp];
1204 [self FilterSettingsChanged: fDecombDeinterlaceSlider];
1208 - (IBAction) FilterSettingsChanged: (id) sender
1211 fPictureFilterSettings.detelecine = [fDetelecinePopUp indexOfSelectedItem];
1212 [self adjustFilterDisplay:fDetelecinePopUp];
1214 fPictureFilterSettings.decomb = [fDecombPopUp indexOfSelectedItem];
1215 [self adjustFilterDisplay:fDecombPopUp];
1217 fPictureFilterSettings.deinterlace = [fDeinterlacePopUp indexOfSelectedItem];
1218 [self adjustFilterDisplay:fDeinterlacePopUp];
1220 fPictureFilterSettings.denoise = [fDenoisePopUp indexOfSelectedItem];
1221 [self adjustFilterDisplay:fDenoisePopUp];
1223 if ([fDeblockField stringValue] == @"Off")
1225 fPictureFilterSettings.deblock = 0;
1229 fPictureFilterSettings.deblock = [fDeblockField intValue];
1232 fPictureFilterSettings.grayscale = [fGrayscaleCheck state];
1236 [fHBController pictureSettingsDidChange];
1245 - (IBAction) deblockSliderChanged: (id) sender
1247 if ([fDeblockSlider floatValue] == 4.0)
1249 [fDeblockField setStringValue: [NSString stringWithFormat: @"Off"]];
1253 [fDeblockField setStringValue: [NSString stringWithFormat: @"%.0f", [fDeblockSlider floatValue]]];
1255 [self FilterSettingsChanged: sender];
1261 return fPictureFilterSettings.detelecine;
1264 - (NSString*) detelecineCustomString
1266 return [fDetelecineField stringValue];
1269 - (void) setDetelecine: (int) setting
1271 fPictureFilterSettings.detelecine = setting;
1274 - (void) setDetelecineCustomString: (NSString*) string
1276 [fDetelecineField setStringValue:string];
1281 return fPictureFilterSettings.deinterlace;
1283 - (NSString*) deinterlaceCustomString
1285 return [fDeinterlaceField stringValue];
1288 - (void) setDeinterlaceCustomString: (NSString*) string
1290 [fDeinterlaceField setStringValue:string];
1293 - (void) setDeinterlace: (int) setting
1295 fPictureFilterSettings.deinterlace = setting;
1299 return fPictureFilterSettings.decomb;
1302 - (NSString*) decombCustomString
1304 return [fDecombField stringValue];
1309 return fPictureFilterSettings.usedecomb;
1312 - (void) setUseDecomb: (int) setting
1314 fPictureFilterSettings.usedecomb = setting;
1315 if (fPictureFilterSettings.usedecomb == 1)
1317 [fDecombDeinterlaceSlider setFloatValue:0.0];
1321 [fDecombDeinterlaceSlider setFloatValue:1.0];
1323 [self modeDecombDeinterlaceSliderChanged:nil];
1326 - (void) setDecomb: (int) setting {
1327 fPictureFilterSettings.decomb = setting;
1330 - (void) setDecombCustomString: (NSString*) string
1332 [fDecombField setStringValue:string];
1337 return fPictureFilterSettings.denoise;
1340 - (NSString*) denoiseCustomString
1342 return [fDenoiseField stringValue];
1345 - (void) setDenoiseCustomString: (NSString*) string
1347 [fDenoiseField setStringValue:string];
1350 - (void) setDenoise: (int) setting
1352 fPictureFilterSettings.denoise = setting;
1357 return fPictureFilterSettings.deblock;
1360 - (void) setDeblock: (int) setting
1362 fPictureFilterSettings.deblock = setting;
1367 return fPictureFilterSettings.grayscale;
1370 - (void) setGrayscale: (int) setting
1372 fPictureFilterSettings.grayscale = setting;