home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C++ / Applications / PICSee Dust 1.01 / Primary Source / PICSCompositeDialog.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-16  |  20.5 KB  |  687 lines  |  [TEXT/CWIE]
  1. #include "PICSDialogs.h"
  2. #include "PICSPreferencesDialog.h"
  3. #include "PICSCompositeDialog.h"
  4.  
  5. #include "PICS_Operations.h"
  6. #include "PICS_Composite.h"
  7. #include "PICS_Types.h"
  8. #include "PICS_Utils.h"
  9.  
  10. #include "PICSViewer.h"
  11.  
  12. #include "main.h"                    // For AppInBackground()
  13. #include "DialogUtils.h"
  14. #include "MovableModalDialogs.h"
  15. #include "Monitors.h"                // For Place()
  16. #include "assert_mac.h"
  17. #include "SimpleError.h"
  18. #include "KeyUtils.h"                // To handle key-down events
  19. #include "GrayDraw 3D.h"
  20.  
  21. // ---------------------------------------------------------------------------
  22.  
  23. static struct {
  24.     FSSpec picsFile;
  25.     short fileRefNum;
  26.     short numFrames;
  27.     short oldHelpItem;
  28.     Rect areaToCrop;
  29. } sCompositeData;
  30.  
  31. // ---------------------------------------------------------------------------
  32.  
  33. /*
  34.     Both arguments to SetupPICSFileComposite are optional.
  35.     
  36.     If no <picsFile> is provided, the routine will put up a standard
  37.     get file dialog box.
  38.     
  39.     We may get a crop rect from the PICSViewer window, so we have
  40.     to provide the <areaToCrop> argument here.
  41.     If it is NULL, SetupPICSFileComposite will derive the
  42.     crop rect from the PICS file itself.
  43. */
  44.  
  45. void SetupPICSFileComposite(FSSpec *picsFile, const Rect *areaToCrop) {
  46.     FSSpec    file;
  47.     OSErr myErr;
  48.  
  49.     if (picsFile == NULL) {
  50.         // If we're passed NULL, do a StandardGetFile...
  51.         if (!OpenPICSFile(&file)) return;
  52.     }
  53.     else {
  54.         // Else we already have a file ready for us...
  55.         file = *picsFile;
  56.         
  57.         // Check for correct file type. Although we specified in
  58.         // our app res fork that we wanted all file types for
  59.         // drag and drop ('****') we have to filter it out as
  60.         // follows: for compositing, we don't accept PICT files.
  61.         FInfo fileInfo;
  62.         myErr = FSpGetFInfo(&file, &fileInfo);
  63.         if (myErr == noErr && fileInfo.fdType == kPICTFileType) {
  64.             SimpleError(kAlertErrID, kErrMsgID, kDontAcceptPICTFileErrMsg);
  65.             return;
  66.         }
  67.     }
  68.  
  69.     // Pre-fetch some PICS info
  70.     Rect cropRect;
  71.     short outputDepth;
  72.     short numFrames;
  73.     
  74.     if (areaToCrop != NULL) {
  75.         cropRect = *areaToCrop;
  76.     }
  77.     else {
  78.         if (!FetchPICSFileInfo(&file, &cropRect, &outputDepth, &numFrames)) {
  79.             return;
  80.         }
  81.     }
  82.  
  83.     SetupCompositeDialog(&file, -1, &cropRect, numFrames);
  84. } // END SetupPICSFIleComposite
  85.  
  86. // ---------------------------------------------------------------------------
  87.  
  88. enum {    
  89.     kCompositeDlogID = 128,
  90.  
  91.     kCompositeDlog_CompositeBtn = 1,
  92.     kCompositeDlog_CancelBtn,
  93.  
  94.     kCompositeDlog_CropBtn,
  95.  
  96.     kCompositeDlog_AssembleBtn,
  97.     kCompositeDlog_LeftToRightBtn,
  98.     kCompositeDlog_TopToBottomBtn,
  99.  
  100.     kCompositeDlog_UseAllFramesBtn,
  101.     kCompositeDlog_UseRangeFramesBtn,
  102.     
  103.     kCompositeDlog_UsePICSFileDepthBtn,
  104.     kCompositeDlog_UseMonitorDepthBtn,
  105.     kCompositeDlog_Use32bitBtn,
  106.     kCompositeDlog_Use16bitBtn,
  107.     kCompositeDlog_Use8bitBtn,
  108.     kCompositeDlog_Use4bitBtn,
  109.     kCompositeDlog_Use1bitBtn,
  110.     
  111.     kCompositeDlog_HelpBtn,
  112.  
  113.     kCompositeDlog_LeftCropInput,
  114.     kCompositeDlog_TopCropInput,
  115.     kCompositeDlog_RightCropInput,
  116.     kCompositeDlog_BottomCropInput,
  117.  
  118.     kCompositeDlog_StartFrameInput,
  119.     kCompositeDlog_StopFrameInput,
  120.  
  121.     kCompositeDlog_InputOptionsBox,
  122.     kCompositeDlog_OutputOptionsBox,
  123.     kCompositeDlog_HelpBox,
  124.     
  125.     kCompositeDlog_Line1,
  126.     kCompositeDlog_Line2
  127. };
  128.  
  129. // ---------------------------------------------------------------------------
  130.  
  131. static void DisposeCompositeDialog(DialogPtr compDlog, Boolean doComposite);
  132. static void CompositeDialogHandleHit(DialogPtr compDlog, EventRecord *theEvt, short itemHit);
  133. static Boolean CompositeDialogHandleKey(DialogPtr compDlog, EventRecord *theEvt);
  134. static void CompositeDialogHandleUpdate(DialogPtr compDlog, EventRecord *theEvt, Boolean frontMost);
  135. static void CompositeDialogHandleActivate(DialogPtr compDlog, Boolean activate);
  136. static void CompositeDialogHandleIdle(DialogPtr compDlog);
  137.  
  138. static Boolean GetCropRect(DialogPtr theDlog, short leftCropItem, Rect *cropResult);
  139.  
  140. // ---------------------------------------------------------------------------
  141.  
  142. void SetupCompositeDialog(
  143.     FSSpec *picsFile,
  144.     short fileRefNum,
  145.     const Rect *areaToCrop,
  146.     short numFrames) {
  147.  
  148.     PrefsHandle prefs;
  149.     DialogPtr compDlog;
  150.     Str15 dlogStr;
  151.  
  152.     ASSERT(areaToCrop != NULL);
  153.     if (picsFile == NULL && fileRefNum == -1) {
  154.         ASSERT(true);
  155.     }
  156.  
  157.     prefs = LoadPrefs();
  158.     ASSERT(prefs != NULL);
  159.  
  160.     HLock((Handle)prefs);
  161.  
  162.     // Store parameters in global, since we'll need it after we exit
  163.     // this routine
  164.     if (picsFile != NULL)
  165.         sCompositeData.picsFile = *picsFile;
  166.     sCompositeData.fileRefNum = fileRefNum;
  167.     sCompositeData.areaToCrop = *areaToCrop;
  168.     sCompositeData.numFrames = numFrames;
  169.  
  170.     // Get options...
  171.     compDlog = GetNewDialog(kCompositeDlogID, NULL, (WindowPtr)-1);
  172.     SetPort(compDlog);
  173.     // Because there are edit text items, we have to do the following
  174.     // in addition to calling TextFont() and TextSize()
  175.     TextFont(geneva);
  176.     TextSize(9);
  177.     (**((DialogPeek)compDlog)->textH).txFont = geneva;
  178.     (**((DialogPeek)compDlog)->textH).txSize = 9;
  179.     //(**((DialogPeek)compDlog)->textH).lineHeight = 9;
  180.  
  181.     // Pre-set values in dialog before showing it...
  182.     // Set the crop rect
  183.     SetDlogCtlValue(compDlog, kCompositeDlog_CropBtn, (**prefs).composite.doCrop);
  184.     NumToString(areaToCrop->left, dlogStr);
  185.     SetDItemText(compDlog, kCompositeDlog_LeftCropInput, dlogStr);
  186.     NumToString(areaToCrop->top, dlogStr);
  187.     SetDItemText(compDlog, kCompositeDlog_TopCropInput, dlogStr);
  188.     NumToString(areaToCrop->right, dlogStr);
  189.     SetDItemText(compDlog, kCompositeDlog_RightCropInput, dlogStr);
  190.     NumToString(areaToCrop->bottom, dlogStr);
  191.     SetDItemText(compDlog, kCompositeDlog_BottomCropInput, dlogStr);
  192.     
  193.     // Set the assemble check box
  194.     SetDlogCtlValue(compDlog, kCompositeDlog_AssembleBtn, (**prefs).composite.doAssemble);
  195.     if ((**prefs).composite.assembleLeftToRight)
  196.         SetDlogCtlValue(compDlog, kCompositeDlog_LeftToRightBtn, 1);
  197.     else
  198.         SetDlogCtlValue(compDlog, kCompositeDlog_TopToBottomBtn, 1);
  199.  
  200.     // If not assemble, disable assembling method
  201.     if (!(**prefs).composite.doAssemble) {
  202.         DisableDlogCtl(compDlog, kCompositeDlog_LeftToRightBtn);
  203.         DisableDlogCtl(compDlog, kCompositeDlog_TopToBottomBtn);
  204.     }
  205.  
  206.     // Set output depth radio btn
  207.     switch((**prefs).composite.outputDepthType) {
  208.         case kUseMonitorOutputDepth:
  209.             SetDlogCtlValue(compDlog, kCompositeDlog_UseMonitorDepthBtn, 1);
  210.         break;
  211.         case kUsePICSFileOutputDepth:
  212.             SetDlogCtlValue(compDlog, kCompositeDlog_UsePICSFileDepthBtn, 1);
  213.         break;
  214.         case kUse32bitOutputDepth:
  215.             SetDlogCtlValue(compDlog, kCompositeDlog_Use32bitBtn, 1);
  216.         break;
  217.         case kUse16bitOutputDepth:
  218.             SetDlogCtlValue(compDlog, kCompositeDlog_Use16bitBtn, 1);
  219.         break;
  220.         case kUse8bitOutputDepth:
  221.             SetDlogCtlValue(compDlog, kCompositeDlog_Use8bitBtn, 1);
  222.         break;
  223.         case kUse4bitOutputDepth:
  224.             SetDlogCtlValue(compDlog, kCompositeDlog_Use4bitBtn, 1);
  225.         break;
  226.         case kUse1bitOutputDepth:
  227.             SetDlogCtlValue(compDlog, kCompositeDlog_Use1bitBtn, 1);
  228.         break;
  229.     } // END switch
  230.  
  231.     // Set range start & stop
  232.     /*
  233.     if ((**prefs).composite.frameStart == 0) {
  234.         // Means use all frames
  235.         SetDlogCtlValue(compDlog, kCompositeDlog_UseAllFramesBtn, 1);
  236.         NumToString((**prefs).composite.frameStart+1, dlogStr);
  237.     }
  238.     else {
  239.         SetDlogCtlValue(compDlog, kCompositeDlog_UseRangeFramesBtn, 1);
  240.         dlogStr[0] = 1; dlogStr[1] = '1';
  241.     }
  242.     SetDItemText(compDlog, kCompositeDlog_StartFrameInput, dlogStr);
  243.     if ((**prefs).composite.frameStop > numFrames ||
  244.         (**prefs).composite.frameStop < 1)
  245.         (**prefs).composite.frameStop = numFrames;
  246.     NumToString((**prefs).composite.frameStop, dlogStr);
  247.     SetDItemText(compDlog, kCompositeDlog_StopFrameInput, dlogStr);
  248.     */
  249.     SetDlogCtlValue(compDlog, kCompositeDlog_UseAllFramesBtn, 1);
  250.     dlogStr[0] = 1; dlogStr[1] = '1';
  251.     SetDItemText(compDlog, kCompositeDlog_StartFrameInput, dlogStr);
  252.     NumToString(numFrames, dlogStr);
  253.     SetDItemText(compDlog, kCompositeDlog_StopFrameInput, dlogStr);
  254.  
  255.     RegisterMovableModalDialog(compDlog,
  256.         CompositeDialogHandleHit,
  257.         CompositeDialogHandleKey,
  258.         CompositeDialogHandleUpdate,
  259.         CompositeDialogHandleActivate,
  260.         CompositeDialogHandleIdle);
  261.     
  262.     // Show it and do some extra drawing
  263.     SelIText(compDlog, kCompositeDlog_LeftCropInput, 0, 32767);
  264.  
  265.     HUnlock((Handle)prefs);
  266.     ReleaseResource((Handle)prefs);
  267.     
  268.     sCompositeData.oldHelpItem = 0;
  269.     Place(compDlog, kCenterOnDeepDevice);
  270. } // END SetupCompositeDialog
  271.  
  272. // ---------------------------------------------------------------------------
  273.  
  274. void DisposeCompositeDialog(DialogPtr compDlog, Boolean doComposite) {
  275.     CompositeOptions options;
  276.  
  277.     if (doComposite) {
  278.         long number;
  279.         PrefsHandle prefs = LoadPrefs();
  280.  
  281.         // Get cropping or not
  282.         (**prefs).composite.doCrop = GetDlogCtlValue(compDlog, kCompositeDlog_CropBtn);
  283.         if ((**prefs).composite.doCrop) {
  284.             (void)GetCropRect(compDlog,
  285.                 kCompositeDlog_LeftCropInput, &sCompositeData.areaToCrop);
  286.         }
  287.  
  288.         // Get assembling or not
  289.         (**prefs).composite.doAssemble = GetDlogCtlValue(compDlog,
  290.             kCompositeDlog_AssembleBtn);
  291.         (**prefs).composite.assembleLeftToRight = GetDlogCtlValue(compDlog,
  292.             kCompositeDlog_LeftToRightBtn);
  293.  
  294.         // Get frame range
  295.         (**prefs).composite.frameStart = 0;
  296.         (**prefs).composite.frameStop = sCompositeData.numFrames;
  297.         if (GetDlogCtlValue(compDlog, kCompositeDlog_UseRangeFramesBtn)) {
  298.             (void)CheckValidNumeral(compDlog,
  299.                 kCompositeDlog_StartFrameInput, &number);
  300.             (**prefs).composite.frameStart = number;
  301.             (void)CheckValidNumeral(compDlog,
  302.                 kCompositeDlog_StopFrameInput, &number);
  303.             (**prefs).composite.frameStop = number;
  304.         }        
  305.  
  306.         // Get output depth
  307.         short outputDepthRadio;
  308.         outputDepthRadio = GetRadioBtn(compDlog,
  309.             kCompositeDlog_UsePICSFileDepthBtn, kCompositeDlog_Use1bitBtn);
  310.         switch(outputDepthRadio) {
  311.             case kCompositeDlog_UsePICSFileDepthBtn:
  312.                 (**prefs).composite.outputDepth = 64;  // Special...
  313.                 (**prefs).composite.outputDepthType = kUsePICSFileOutputDepth;
  314.             break;
  315.             case kCompositeDlog_UseMonitorDepthBtn:
  316.                 (**prefs).composite.outputDepth = 0;
  317.                 (**prefs).composite.outputDepthType = kUseMonitorOutputDepth;
  318.             break;
  319.             case kCompositeDlog_Use32bitBtn:
  320.                 (**prefs).composite.outputDepth = 32;
  321.                 (**prefs).composite.outputDepthType = kUse32bitOutputDepth;
  322.             break;
  323.             case kCompositeDlog_Use16bitBtn:
  324.                 (**prefs).composite.outputDepth = 16;
  325.                 (**prefs).composite.outputDepthType = kUse16bitOutputDepth;
  326.             break;
  327.             case kCompositeDlog_Use8bitBtn:
  328.                 (**prefs).composite.outputDepth = 8;
  329.                 (**prefs).composite.outputDepthType = kUse8bitOutputDepth;
  330.             break;
  331.             case kCompositeDlog_Use4bitBtn:
  332.                 (**prefs).composite.outputDepth = 4;
  333.                 (**prefs).composite.outputDepthType = kUse4bitOutputDepth;
  334.             break;
  335.             case kCompositeDlog_Use1bitBtn:
  336.                 (**prefs).composite.outputDepth = 1;
  337.                 (**prefs).composite.outputDepthType = kUse1bitOutputDepth;
  338.             break;
  339.         }
  340.         
  341.         ChangedResource((Handle)prefs);
  342.         WriteResource((Handle)prefs);
  343.         
  344.         options = (**prefs).composite;
  345.         HUnlock((Handle)prefs);
  346.         ReleaseResource((Handle)prefs);
  347.     }
  348.  
  349.     HideWindow(compDlog);
  350.     DisposeDialog(compDlog);
  351.     UnregisterMovableModalDialog(compDlog);
  352.  
  353.     if (doComposite) {
  354.         if (sCompositeData.fileRefNum == -1)
  355.             CompositePICS(&options, &sCompositeData.picsFile, -1,
  356.                 &sCompositeData.areaToCrop);
  357.         else
  358.             CompositePICS(&options, &sCompositeData.picsFile, sCompositeData.fileRefNum,
  359.                 &sCompositeData.areaToCrop);
  360.     }
  361. } // END DisposeCompositeDialog
  362.  
  363. // ---------------------------------------------------------------------------
  364.  
  365. void CompositeDialogHandleHit(DialogPtr compDlog, EventRecord *theEvt, short itemHit) {
  366.     long number;
  367.  
  368.     switch(itemHit) {
  369.         case kCompositeDlog_CropBtn:
  370.             FlipCtlValue(compDlog, itemHit);
  371.         break;
  372.     
  373.         case kCompositeDlog_AssembleBtn:
  374.             FlipCtlValue(compDlog, itemHit);
  375.             if (GetDlogCtlValue(compDlog, itemHit)) {
  376.                 EnableDlogCtl(compDlog, kCompositeDlog_LeftToRightBtn);
  377.                 EnableDlogCtl(compDlog, kCompositeDlog_TopToBottomBtn);
  378.             }
  379.             else {
  380.                 DisableDlogCtl(compDlog, kCompositeDlog_LeftToRightBtn);
  381.                 DisableDlogCtl(compDlog, kCompositeDlog_TopToBottomBtn);
  382.             }
  383.         break;
  384.     
  385.         case kCompositeDlog_LeftToRightBtn:
  386.         case kCompositeDlog_TopToBottomBtn:
  387.             SelectRadioBtn(compDlog, itemHit,
  388.                 kCompositeDlog_LeftToRightBtn,
  389.                 kCompositeDlog_TopToBottomBtn);
  390.         break;
  391.     
  392.         case kCompositeDlog_LeftCropInput:
  393.         case kCompositeDlog_TopCropInput:
  394.         case kCompositeDlog_RightCropInput:
  395.         case kCompositeDlog_BottomCropInput:
  396.             SetDlogCtlValue(compDlog, kCompositeDlog_CropBtn, 1);
  397.             (void)CheckValidNumeral(compDlog, itemHit, &number);
  398.         break;
  399.  
  400.         case kCompositeDlog_UseAllFramesBtn:
  401.         case kCompositeDlog_UseRangeFramesBtn:
  402.             SelectRadioBtn(compDlog, itemHit,
  403.                 kCompositeDlog_UseAllFramesBtn, kCompositeDlog_UseRangeFramesBtn);
  404.         break;
  405.         
  406.         case kCompositeDlog_StartFrameInput:
  407.         case kCompositeDlog_StopFrameInput:
  408.             SelectRadioBtn(compDlog, kCompositeDlog_UseRangeFramesBtn,
  409.                 kCompositeDlog_UseAllFramesBtn, kCompositeDlog_UseRangeFramesBtn);
  410.             (void)CheckValidNumeral(compDlog, itemHit, &number);
  411.         break;
  412.         
  413.         case kCompositeDlog_UsePICSFileDepthBtn:
  414.         case kCompositeDlog_UseMonitorDepthBtn:
  415.         case kCompositeDlog_Use32bitBtn:
  416.         case kCompositeDlog_Use16bitBtn:
  417.         case kCompositeDlog_Use8bitBtn:
  418.         case kCompositeDlog_Use4bitBtn:
  419.         case kCompositeDlog_Use1bitBtn:
  420.             SelectRadioBtn(compDlog, itemHit,
  421.                 kCompositeDlog_UsePICSFileDepthBtn,
  422.                 kCompositeDlog_Use1bitBtn);
  423.         break;
  424.  
  425.         case kCompositeDlog_HelpBtn:
  426.             FlipCtlValue(compDlog, kCompositeDlog_HelpBtn);
  427.         break;
  428.         
  429.         case kCompositeDlog_CompositeBtn:
  430.             // Isn't all this error-checking a pain-in-the-butt? :-p
  431.             // Check crops
  432.             Boolean doCrop, doAssemble, doRange;
  433.             doCrop = GetDlogCtlValue(compDlog,
  434.                 kCompositeDlog_CropBtn);
  435.             doAssemble = GetDlogCtlValue(compDlog,
  436.                 kCompositeDlog_AssembleBtn);
  437.             doRange = GetDlogCtlValue(compDlog,
  438.                 kCompositeDlog_UseRangeFramesBtn);
  439.     
  440.             if (doCrop) {
  441.                 if (!GetCropRect(compDlog,
  442.                     kCompositeDlog_LeftCropInput, &sCompositeData.areaToCrop)) {
  443.                     itemHit = 0;
  444.                 }
  445.             }
  446.     
  447.     
  448.             if (itemHit != 0) {
  449.                 if (!doCrop && !doAssemble) {
  450.                     // No operations!
  451.                     SimpleError(kAlertErrID,
  452.                         kErrMsgID, kNoOperationSelectedErrMsg);
  453.                     itemHit = 0;
  454.                 }
  455.             }
  456.     
  457.             long frameStart, frameStop;
  458.             if (itemHit != 0 && doRange) {
  459.                 if (!CheckValidNumeral(compDlog,
  460.                     kCompositeDlog_StartFrameInput, &frameStart)) {
  461.                     SelectDialogItemText(compDlog, kCompositeDlog_StartFrameInput, 0, 32767);
  462.                     itemHit = 0;
  463.                 }
  464.                 if (itemHit != 0) {
  465.                     if (!CheckValidNumeral(compDlog,
  466.                         kCompositeDlog_StopFrameInput, &frameStop)) {
  467.                         SelectDialogItemText(compDlog, kCompositeDlog_StopFrameInput, 0, 32767);
  468.                         itemHit = 0;
  469.                     }
  470.                     if (itemHit != 0) {
  471.                         if (frameStop < 1) {
  472.                             SimpleError(kAlertErrID, kErrMsgID, kInvalidFrameRangeErrMsg);
  473.                             SelectDialogItemText(compDlog, kCompositeDlog_StopFrameInput, 0, 32767);
  474.                             itemHit = 0;
  475.                         }
  476.                         else if (frameStop > sCompositeData.numFrames) {
  477.                             SimpleError(kAlertErrID, kErrMsgID, kInvalidFrameRangeErrMsg);
  478.                             SelectDialogItemText(compDlog, kCompositeDlog_StopFrameInput, 0, 32767);
  479.                             itemHit = 0;
  480.                         }
  481.                         else if (frameStart < 1) {
  482.                             SimpleError(kAlertErrID, kErrMsgID, kInvalidFrameRangeErrMsg);
  483.                             SelectDialogItemText(compDlog, kCompositeDlog_StartFrameInput, 0, 32767);
  484.                             itemHit = 0;
  485.                         }
  486.                         else if (frameStart > sCompositeData.numFrames) {
  487.                             SimpleError(kAlertErrID, kErrMsgID, kInvalidFrameRangeErrMsg);
  488.                             SelectDialogItemText(compDlog, kCompositeDlog_StartFrameInput, 0, 32767);
  489.                             itemHit = 0;
  490.                         }
  491.                         else if (frameStart > frameStop) {
  492.                             SimpleError(kAlertErrID, kErrMsgID, kInvalidFrameRangeErrMsg);
  493.                             SelectDialogItemText(compDlog, kCompositeDlog_StartFrameInput, 0, 32767);
  494.                             itemHit = 0;
  495.                         }
  496.                     }
  497.                 }
  498.             }
  499.             
  500.             if (itemHit != 0)
  501.                 DisposeCompositeDialog(compDlog, true);
  502.         break;
  503.  
  504.         case kCompositeDlog_CancelBtn:
  505.             DisposeCompositeDialog(compDlog, false);
  506.         break;
  507.         
  508.         default:
  509.         break;
  510.     } // END switch
  511. } // END CompositeDialogHandleHit
  512.  
  513. // ---------------------------------------------------------------------------
  514.  
  515. Boolean CompositeDialogHandleKey(DialogPtr compDlog, EventRecord *theEvt) {
  516.     char key = theEvt->message & charCodeMask;
  517.     Boolean handledIt = false;
  518.  
  519.     switch(key) {
  520.         case kReturn_Key:
  521.             PushButton(compDlog, kCompositeDlog_CompositeBtn);
  522.             DisposeCompositeDialog(compDlog, true);
  523.             handledIt = true;
  524.         break;
  525.         
  526.         case kEscape_Key:
  527.             PushButton(compDlog, kCompositeDlog_CancelBtn);
  528.             DisposeCompositeDialog(compDlog, false);
  529.             handledIt = true;
  530.         break;
  531.         
  532.     }
  533.     
  534.     return(handledIt);
  535. } // END CompositeDialogHandleKey
  536.  
  537. // ---------------------------------------------------------------------------
  538.  
  539. void CompositeDialogHandleUpdate(DialogPtr compDlog, EventRecord *theEvt, Boolean frontMost) {
  540.     Rect boxRect;
  541.     GetDItemRect(compDlog, kCompositeDlog_InputOptionsBox, &boxRect);
  542.     GrayDrawShadowBox(&boxRect, NULL);
  543.     GetDItemRect(compDlog, kCompositeDlog_OutputOptionsBox, &boxRect);
  544.     GrayDrawShadowBox(&boxRect, NULL);
  545.     GetDItemRect(compDlog, kCompositeDlog_HelpBox, &boxRect);
  546.     GrayDrawShadowBox(&boxRect, NULL);
  547.  
  548.     GetDItemRect(compDlog, kCompositeDlog_Line1, &boxRect);
  549.     GrayDrawShadowLine(&boxRect, NULL);
  550.     GetDItemRect(compDlog, kCompositeDlog_Line2, &boxRect);
  551.     GrayDrawShadowLine(&boxRect, NULL);
  552.  
  553.     DrawDefaultBorder(compDlog, kCompositeDlog_CompositeBtn);
  554.     
  555.     if (!frontMost) {
  556.     }
  557. } // END CompositeDialogHandleUpdate
  558.  
  559. // ---------------------------------------------------------------------------
  560.  
  561. void CompositeDialogHandleActivate(DialogPtr compDlog, Boolean activate) {
  562.     short hiliteMode;
  563.     short i;
  564.     
  565.     if (activate)
  566.         hiliteMode = 0;
  567.     else
  568.         hiliteMode = 255;
  569.  
  570.     for (i = kCompositeDlog_CompositeBtn;
  571.         i <= kCompositeDlog_HelpBtn; i++)
  572.         HiliteControl((ControlHandle)GetDItemHdl(compDlog, i), hiliteMode);
  573.  
  574.     PrefsHandle prefs = LoadPrefs();
  575.     ASSERT(prefs != NULL);
  576.     if (prefs != NULL && !(**prefs).composite.doAssemble) {
  577.         DisableDlogCtl(compDlog, kCompositeDlog_LeftToRightBtn);
  578.         DisableDlogCtl(compDlog, kCompositeDlog_TopToBottomBtn);
  579.     }
  580.     if (prefs != NULL)
  581.         ReleaseResource((Handle)prefs);
  582.  
  583.     /*
  584.         We won't even bother with grayishTextOr'ing the static text here,
  585.         because there are edit text items in the dialog. Because of
  586.         this, the Dialog Manager always resets the textmode to srcOr.
  587.         This is the last time I'll be using the Dialog Manager for anything
  588.         more than modal dialogs - it just plain sucks. Inconsistent
  589.         action, resetting and hardwiring port variables such as the
  590.         textfont and textmode. It's just too much for me to take!
  591.     */
  592.  
  593.     DrawDefaultBorder(compDlog, kCompositeDlog_CompositeBtn);
  594. } // END CompositeDialogHandleActivate
  595.  
  596. // ---------------------------------------------------------------------------
  597.  
  598. void CompositeDialogHandleIdle(DialogPtr compDlog) {
  599.     short i, isInside;
  600.     Rect itemRect;
  601.     Str255 helpStr;
  602.     GrafPtr savePort;
  603.     Point mouseLoc;
  604.     
  605.     GetPort(&savePort);
  606.     SetPort(compDlog);
  607.  
  608.     if (!GetDlogCtlValue(compDlog, kCompositeDlog_HelpBtn)) {
  609.         if (sCompositeData.oldHelpItem != 0) {
  610.             GetDItemRect(compDlog, kCompositeDlog_HelpBox, &itemRect);
  611.             InsetRect(&itemRect, 2, 2);
  612.             EraseRect(&itemRect);
  613.             sCompositeData.oldHelpItem = 0;
  614.         }
  615.         SetPort(savePort);
  616.         return;
  617.     }
  618.     
  619.     GetMouse(&mouseLoc);
  620.     isInside = false;
  621.     for (i = kCompositeDlog_CompositeBtn; i <= kCompositeDlog_StopFrameInput; i++) {
  622.         GetDItemRect(compDlog, i, &itemRect);
  623.  
  624.         if (PtInRect(mouseLoc, &itemRect)) {
  625.             // We're inside an item; is it a new item or is mouse still
  626.             // on old item? (If new, write new text)
  627.             if (i != sCompositeData.oldHelpItem) {
  628.                 GetIndString(helpStr, kCompositeDlogID, i);
  629.     
  630.                 GetDItemRect(compDlog, kCompositeDlog_HelpBox, &itemRect);
  631.                 TextFont(geneva);
  632.                 TextSize(9);
  633.                 InsetRect(&itemRect, 5, 4);
  634.                 TextBox(&helpStr[1], helpStr[0], &itemRect, teForceLeft);
  635.                 
  636.                 sCompositeData.oldHelpItem = i;
  637.             }
  638.             isInside = true;
  639.             break;
  640.         }
  641.     }
  642.     
  643.     if (!isInside && sCompositeData.oldHelpItem != 0) {
  644.         GetDItemRect(compDlog, kCompositeDlog_HelpBox, &itemRect);
  645.         InsetRect(&itemRect, 2, 2);
  646.         EraseRect(&itemRect);
  647.         sCompositeData.oldHelpItem = 0;
  648.     }
  649.     
  650.     SetPort(savePort);
  651. } // END CompositeDialogHandleIdle
  652.  
  653. // ---------------------------------------------------------------------------
  654.  
  655. Boolean GetCropRect(DialogPtr theDlog, short leftCropItem, Rect *cropResult) {
  656.     Rect cropRect;
  657.     long number;
  658.     Str15 dlogStr;
  659.  
  660.     ASSERT(cropResult != NULL);
  661.  
  662.     for (short i = leftCropItem; i < leftCropItem+4; i++) {
  663.         GetIText(GetDItemHdl(theDlog, i), dlogStr);
  664.         if (dlogStr[0] == 0) {
  665.             SimpleError(kAlertErrID, kErrMsgID, kInvalidCropRectErrMsg);
  666.             return(false);
  667.         }
  668.     }
  669.  
  670.     if (!CheckValidNumeral(theDlog, leftCropItem++, &number)) return(false);
  671.     cropRect.left = number;
  672.     if (!CheckValidNumeral(theDlog, leftCropItem++, &number)) return(false);
  673.     cropRect.top = number;
  674.     if (!CheckValidNumeral(theDlog, leftCropItem++, &number)) return(false);
  675.     cropRect.right = number;
  676.     if (!CheckValidNumeral(theDlog, leftCropItem, &number)) return(false);
  677.     cropRect.bottom = number;
  678.     
  679.     if (EmptyRect(&cropRect)) {
  680.         SimpleError(kAlertErrID, kErrMsgID, kInvalidCropRectErrMsg);
  681.         return(false);
  682.     }
  683.     else {
  684.         *cropResult = cropRect;
  685.         return(true);
  686.     }
  687. } // END GetCropRect