开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多显示器编程 > 查看源码
INPUTSET.C
资源名称：RGBEASY.ZIP　[点击查看]
上传用户：guoxiu1214
上传日期：2019-02-27
资源大小：876k
文件大小：40k
源码类别：

多显示器编程

开发平台：

Visual C++

INPUTSET.C：源码内容
  1. /*******************************************************************************
  3. Copyright Datapath Ltd. 2007.
  5. File:    InputSet.c
  7. Purpose: Implements the Input Settings dialog.
  9. History:
  10.          20 DEC 07    SB   Created.
  12. *******************************************************************************/
  14. #include <windows.h>
  15. #include <commctrl.h>
  16. #include <stdio.h>
  17. #include <tchar.h>
  19. #include <rgb.h>
  20. #include <rgbapi.h>
  21. #include <rgbdefs.h>
  23. #include "sample3.h"
  24. #include "resource.h"
  26. /******************************************************************************/
  28. static const TCHAR Property[] = TEXT("pWindow");
  30. /******************************************************************************/
  32. #define BLANK_MODE_IMAGE   0
  33. #define CURRENT_MODE_IMAGE 1
  35. #define PROP_SETFOCUS         ( WM_USER + 1 )
  36. #define WM_MODECHANGEUPDATE   ( WM_USER + 2 )
  37. #define WM_NOSIGNALUPDATE     ( WM_USER + 3 )
  38. #define WM_INVALIDSIGUPDATE   ( WM_USER + 4 )
  39. #define WM_VALUECHANGED       ( WM_USER + 5 )
  40. #define WM_RECORDERSTARTED    ( WM_USER + 6 )
  41. #define WM_RECORDERSTOPPED    ( WM_USER + 7 )
  44. typedef enum 
  45. {
  46.    VALIDSIGSTATE     = RGB_STATE_CAPTURING,
  47.    NOSIGNALSTATE     = RGB_STATE_NOSIGNAL,
  48.    INVALIDSIGSTATE   = RGB_STATE_INVALIDSIGNAL,
  50.    CAPTURENOTRUNNING = RGB_STATE_PAUSED,
  51.    ERRORSTATE        = RGB_STATE_ERROR,
  52. }  SIGNALSTATE;
  55. RGBMODECHANGEDFN  ModeChangeFn;
  56. RGBNOSIGNALFN     NoSignalFn;
  57. RGBINVALIDSIGNALFN InvalidSignalFn;
  59. typedef struct
  60. {
  61.    HINSTANCE   HInstance;
  62.    HWND        HWndParent;
  63.    HRGB        HRGB;
  64.    BOOL        BProgram;
  65.    BOOL        HCurrentMode;
  66. }  WINDOW, *PWINDOW;
  69. /******************************************************************************/
  71. BOOL
  72. GetDlgItemIntInRange (
  73.    HWND  hDlg,
  74.    int   iEditId,
  75.    int   iMin,
  76.    int   iMax,
  77.    BOOL  bSigned,
  78.    int   *pValue )
  79. {
  80.    BOOL  bTranslated;
  82.    *pValue = GetDlgItemInt ( hDlg, iEditId, &bTranslated, bSigned );
  83.    if ( bTranslated )
  84.    {
  85.       if ( bSigned )
  86.       {
  87.          if ( ( (int)*pValue < iMin ) || ( (int)*pValue > iMax ) )
  88.          {
  89.             return FALSE;
  90.          }
  91.       }
  92.       else
  93.       {
  94.          if ( ( (unsigned int)*pValue < (unsigned int)iMin ) ||
  95.               ( (unsigned int)*pValue > (unsigned int)iMax ) )
  96.          {
  97.             return FALSE;
  98.          }
  99.       }
  100.       return TRUE;
  101.    }
  102.    return FALSE;
  103. }
  105. /******************************************************************************/
  107. #define USE_SCROLL_BARS 1
  109. void
  110. SetTrackBarRange (
  111.    HWND  hCtl,
  112.    LONG  min,
  113.    LONG  max,
  114.    BOOL  bRedraw )
  115. {
  116. #if USE_SCROLL_BARS
  117.    SetScrollRange ( hCtl, SB_CTL, (int)min, (int)max, bRedraw );
  118. #else
  119.    SendMessage ( hCtl, TBM_SETRANGEMIN, 0, min );
  120.    SendMessage ( hCtl, TBM_SETRANGEMAX, 0, max );
  121. #endif
  122. }
  124. /******************************************************************************/
  126. void
  127. GetTrackBarRange (
  128.    HWND     hCtl,
  129.    LPLONG   min,
  130.    LPLONG   max )
  131. {
  132. #if USE_SCROLL_BARS
  133.    {
  134.       int   iMin, iMax;
  136.       GetScrollRange ( hCtl, SB_CTL, &iMin, &iMax );
  137.       *min = (long)iMin;
  138.       *max = (long)iMax;
  139.    }
  140. #else
  141.    *min = SendMessage( hCtl, TBM_GETRANGEMIN, 0, 0 );
  142.    *max = SendMessage( hCtl, TBM_GETRANGEMAX, 0, 0 );
  143. #endif
  144. }
  146. /******************************************************************************/
  148. void
  149. SetTrackBarPos (
  150.    HWND  hCtl,
  151.    LONG  pos,
  152.    BOOL  bRedraw )
  153. {
  154. #if USE_SCROLL_BARS
  155.    SetScrollPos ( hCtl, SB_CTL, (int)pos, bRedraw );
  156. #else
  157.    SendMessage ( hCtl, TBM_SETPOS, bRedraw, pos );
  158. #endif
  159. }
  161. /******************************************************************************/
  163. LONG
  164. GetTrackBarPos (
  165.    HWND  hCtl )
  166. {
  167. #if USE_SCROLL_BARS
  168.    return GetScrollPos ( hCtl, SB_CTL );
  169. #else
  170.    return SendMessage ( hCtl, TBM_GETPOS, 0, 0 );
  171. #endif
  172. }
  174. /******************************************************************************/
  176. BOOL
  177. Cropping (
  178.    HWND           hDlg,
  179.    PWINDOW        pWindow,
  180.    unsigned long  hCurrentMode,
  181.    BOOL           bMessage )
  182. {
  183.    static const struct
  184.    {
  185.       int   EditId;
  186.       int   SpinId;
  187.       BOOL  BSigned;
  188.    } ctl[] =
  189.    {
  190.       { IDC_TOP,      IDC_TOPSPIN,      TRUE },
  191.       { IDC_LEFT,     IDC_LEFTSPIN,     TRUE },
  192.       { IDC_WIDTH,    IDC_WIDTHSPIN,    FALSE },
  193.       { IDC_HEIGHT,   IDC_HEIGHTSPIN,   FALSE },
  194.    };
  195.    long           top, left;
  196.    unsigned long  width, height;
  197.    int   *cropping[] =
  198.    {
  199.       { &top },
  200.       { &left },
  201.       { &width },
  202.       { &height },
  203.    };
  204.    int            i, iMin, iMax;
  205.    unsigned long  error;
  206.    BOOL           bEnabled;
  208.    for ( i = 0; i < sizeof ( ctl ) / sizeof ( ctl[0] ); i++ )
  209.    {
  210.       iMin = iMax = 0;
  211.       SendMessage ( GetDlgItem ( hDlg, ctl[i].SpinId ), UDM_GETRANGE32, 
  212.             (WPARAM)&iMin, (LPARAM)&iMax );
  214.       if ( GetDlgItemIntInRange ( hDlg, ctl[i].EditId, iMin, iMax,
  215.             ctl[i].BSigned, cropping[i] ) == FALSE )
  216.       {
  217.          if ( bMessage )
  218.          {
  219.             PostMessage ( hDlg, PROP_SETFOCUS, 0, ctl[i].EditId );
  220.          }
  221.          return FALSE;
  222.       }
  223.    }
  224.    bEnabled = IsDlgButtonChecked ( hDlg, IDC_CROPPINGON ) == BST_CHECKED;
  225.       
  226.    /* TODO: Get a more meaningful error number back. */
  227.    error = RGBSetCropping ( pWindow->HRGB, top, left, width, height );
  228.    if ( error == 0 )
  229.    {
  230.       error = RGBEnableCropping ( pWindow->HRGB, bEnabled );
  231.       if ( error )
  232.       {
  233.          return FALSE;
  234.       }
  235.    }
  237.    return TRUE;
  238. }
  240. /******************************************************************************/
  242. unsigned long
  243. IncreaseHorizontalScale (
  244.    HWND           hDlg,
  245.    unsigned long  width )
  246. {
  247.    unsigned long  horScale, horStart;
  248.    BOOL           bTranslated;
  250.    horScale = GetDlgItemInt ( hDlg, IDC_HORSCALEVALUE, &bTranslated, FALSE );
  251.    if ( bTranslated )
  252.    {
  253.       horStart = GetDlgItemInt( hDlg, IDC_HOROFFSETVALUE, &bTranslated, FALSE );
  254.       if ( bTranslated )
  255.       {
  256.          unsigned long scale;
  258.          scale = horStart + width;
  259.          if ( scale > horScale )
  260.          {
  261.             return scale;
  262.          }
  263.       }
  264.    }
  265.    return 0;
  266. }
  268. /******************************************************************************/
  270. BOOL
  271. AddrWidth ( 
  272.    HWND     hDlg,
  273.    PWINDOW  pWindow, 
  274.    BOOL     bMessage )
  275. {
  276.    unsigned long  error, width;
  277.    int            iMin, iMax;
  279.    iMin = iMax = 0;
  280.    SendMessage ( GetDlgItem ( hDlg, IDC_ADDRWIDTHSPIN ), UDM_GETRANGE32, 
  281.          (WPARAM)&iMin, (LPARAM)&iMax );
  283.    if ( GetDlgItemIntInRange ( hDlg, IDC_ADDRWIDTH, iMin, iMax,
  284.          FALSE, &width ) == FALSE )
  285.    {
  286.       return FALSE;
  287.    }
  288.    {
  289.       /* Increase the horizontal scale if needed. */
  290.       unsigned long horizontalScale;
  292.       horizontalScale = IncreaseHorizontalScale ( hDlg, width );
  294.       if ( horizontalScale )
  295.       {
  296.          if ( RGBSetHorScale ( pWindow->HRGB, horizontalScale ) == 0 )
  297.          {
  298.             SetTrackBarPos ( GetDlgItem ( hDlg, IDC_HORSCALE ), 
  299.                   horizontalScale, TRUE );
  300.             SetDlgItemInt ( hDlg, IDC_HORSCALEVALUE, horizontalScale, TRUE );
  301.          }
  302.       }
  303.    }
  304.    error = RGBSetCaptureWidth ( pWindow->HRGB, width );
  306.    if ( error )
  307.    {
  308.       return FALSE;
  309.    }
  311.    return TRUE;
  312. }
  314. /******************************************************************************/
  316. BOOL
  317. AddrHeight ( 
  318.    HWND     hDlg,
  319.    PWINDOW  pWindow,
  320.    BOOL     bMessage )
  321. {
  322.    unsigned long  error, height;
  323.    int            iMin, iMax;
  325.    iMin = iMax = 0;
  326.    SendMessage ( GetDlgItem ( hDlg, IDC_ADDRHEIGHTSPIN ), UDM_GETRANGE32, 
  327.          (WPARAM)&iMin, (LPARAM)&iMax );
  329.    if ( GetDlgItemIntInRange ( hDlg, IDC_ADDRHEIGHT, iMin, iMax,
  330.          FALSE, &height ) == FALSE )
  331.    {
  332.       return FALSE;
  333.    }
  335.    error = RGBSetCaptureHeight ( pWindow->HRGB, height );
  337.    if ( error )
  338.    {
  339.       return FALSE;
  340.    }
  342.    return TRUE;
  343. }
  345. /******************************************************************************/
  347. static void
  348. SetValueFromSlider (
  349.    HWND           hDlg,
  350.    PWINDOW        pWindow,
  351.    int            ctlID,
  352.    unsigned long  position )
  353. {
  354.    int nIDDlgItem;
  356.    switch ( ctlID )
  357.    {
  358.       case IDC_BRIGHTNESS:
  359.       {
  360.          RGBSetBrightness ( pWindow->HRGB, position );
  361.          nIDDlgItem = IDC_BRIGHTNESSVALUE;
  362.          break;
  363.       }
  365.       case IDC_CONTRAST:
  366.       {
  367.          RGBSetContrast ( pWindow->HRGB, position );
  368.          nIDDlgItem = IDC_CONTRASTVALUE;
  369.          break;
  370.       }
  372.       case IDC_BLACKLEVEL:
  373.       {
  374.          RGBSetBlackLevel ( pWindow->HRGB, position );
  375.          nIDDlgItem = IDC_BLACKLEVELVALUE;
  376.          break;
  377.       }
  379.       case IDC_PHASE:
  380.       {
  381.          RGBSetPhase ( pWindow->HRGB, position );
  382.          nIDDlgItem = IDC_PHASEVALUE;
  383.          break;
  384.       }
  386.       case IDC_HOROFFSET:
  387.       {
  388.          RGBSetHorPosition ( pWindow->HRGB, position );
  389.          nIDDlgItem = IDC_HOROFFSETVALUE;
  390.          break;
  391.       }
  393.       case IDC_VEROFFSET:
  394.       {
  395.          RGBSetVerPosition ( pWindow->HRGB, position );
  396.          nIDDlgItem = IDC_VEROFFSETVALUE;
  397.          break;
  398.       }
  400.       case IDC_HORSCALE:
  401.       {
  402.          RGBSetHorScale ( pWindow->HRGB, position );
  403.          nIDDlgItem = IDC_HORSCALEVALUE;
  404.          break;
  405.       }
  406.       default:
  407.          return;
  408.    }
  410.    SetDlgItemInt ( hDlg, nIDDlgItem, position, TRUE );
  411. }
  413. /******************************************************************************/
  415. unsigned long
  416. GetMinimumValueForSlider (
  417.    PWINDOW        pWindow,
  418.    int            ctlID,
  419.    unsigned long  *pValue )
  420. {
  421.    unsigned long  error;
  423.    switch ( ctlID )
  424.    {
  425.       case IDC_BRIGHTNESS:
  426.          error = RGBGetBrightnessMinimum ( pWindow->HRGB, pValue );
  427.          break;
  428.       case IDC_CONTRAST:
  429.          error = RGBGetContrastMinimum ( pWindow->HRGB, pValue );
  430.          break;
  431.       case IDC_BLACKLEVEL:
  432.          error = RGBGetBlackLevelMinimum ( pWindow->HRGB, pValue );
  433.          break;
  434.       case IDC_PHASE:
  435.          error = RGBGetPhaseMinimum ( pWindow->HRGB, pValue );
  436.          break;
  437.       case IDC_HOROFFSET:
  438.          error = RGBGetHorPositionMinimum ( pWindow->HRGB, pValue );
  439.          break;
  440.       case IDC_VEROFFSET:
  441.          error = RGBGetVerPositionMinimum ( pWindow->HRGB, pValue );
  442.          break;
  443.       case IDC_HORSCALE:
  444.          error = RGBGetHorScaleMinimum ( pWindow->HRGB, pValue );
  445.          break;
  446.    }
  448.    return error;
  449. }
  451. /******************************************************************************/
  453. unsigned long
  454. GetCurrentValueForSlider (
  455.    PWINDOW        pWindow,
  456.    int            ctlID,
  457.    unsigned long  *pValue )
  458. {
  459.    unsigned long  error;
  461.    switch ( ctlID )
  462.    {
  463.       case IDC_BRIGHTNESS:
  464.          error = RGBGetBrightness ( pWindow->HRGB, pValue );
  465.          break;
  466.       case IDC_CONTRAST:
  467.          error = RGBGetContrast ( pWindow->HRGB, pValue );
  468.          break;
  469.       case IDC_BLACKLEVEL:
  470.          error = RGBGetBlackLevel ( pWindow->HRGB, pValue );
  471.          break;
  472.       case IDC_PHASE:
  473.          error = RGBGetPhase ( pWindow->HRGB, pValue );
  474.          break;
  475.       case IDC_HOROFFSET:
  476.          error = RGBGetHorPosition ( pWindow->HRGB, pValue );
  477.          break;
  478.       case IDC_VEROFFSET:
  479.          error = RGBGetVerPosition ( pWindow->HRGB, pValue );
  480.          break;
  481.       case IDC_HORSCALE:
  482.          error = RGBGetHorScale ( pWindow->HRGB, pValue );
  483.          break;
  484.    }
  486.    return error;
  487. }
  489. /******************************************************************************/
  491. unsigned long
  492. GetMaximumValueForSlider (
  493.    PWINDOW        pWindow,
  494.    int            ctlID,
  495.    unsigned long  *pValue )
  496. {
  497.    unsigned long  error;
  499.    switch ( ctlID )
  500.    {
  501.       case IDC_BRIGHTNESS:
  502.          error = RGBGetBrightnessMaximum ( pWindow->HRGB, pValue );
  503.          break;
  504.       case IDC_CONTRAST:
  505.          error = RGBGetContrastMaximum ( pWindow->HRGB, pValue );
  506.          break;
  507.       case IDC_BLACKLEVEL:
  508.          error = RGBGetBlackLevelMaximum ( pWindow->HRGB, pValue );
  509.          break;
  510.       case IDC_PHASE:
  511.          error = RGBGetPhaseMaximum ( pWindow->HRGB, pValue );
  512.          break;
  513.       case IDC_HOROFFSET:
  514.          error = RGBGetHorPositionMaximum ( pWindow->HRGB, pValue );
  515.          break;
  516.       case IDC_VEROFFSET:
  517.          error = RGBGetVerPositionMaximum ( pWindow->HRGB, pValue );
  518.          break;
  519.       case IDC_HORSCALE:
  520.          error = RGBGetHorScaleMaximum ( pWindow->HRGB, pValue );
  521.          break;
  522.    }
  524.    return error;
  525. }
  527. /******************************************************************************/
  529. static unsigned long
  530. InintialiseInputSource (
  531.    HWND     hDlg,
  532.    PWINDOW  pWindow )
  533. {
  534.    unsigned long  error, inputs, current;
  535.    HWND           hCtl;
  537.    hCtl = GetDlgItem ( hDlg, IDC_INPUTSOURCE );
  539.    /* Find out how many input sources are available. */
  540.    error = RGBGetNumberOfInputs ( &inputs );
  541.    if ( error == 0 )
  542.    {
  543.       unsigned long i;
  545.       /* Add numeric values to the control. */
  546.       for ( i = 0; i < inputs; i++ )
  547.       {
  548.          TCHAR  text[32];
  550.          wsprintf ( text, TEXT("%d"), i+1 );
  551.          SendMessage ( hCtl, CB_ADDSTRING, (WPARAM)0, (LPARAM)text );
  552.          SendMessage ( hCtl, CB_SETITEMDATA , i, (LPARAM)i );
  553.       }
  555.       error = RGBGetInput ( pWindow->HRGB, &current );
  556.       if ( error == 0 )
  557.       {
  558.          SendMessage ( hCtl, CB_SETCURSEL, (WPARAM)current, (LPARAM)0 );
  559.       }
  560.    }
  562.    return error;
  563. }
  565. /******************************************************************************/
  567. static unsigned long
  568. SetInputSource (
  569.    HWND     hDlg,
  570.    PWINDOW  pWindow )
  571. {
  572.    LRESULT        itemIndex, input;
  573.    unsigned long  error;
  574.    HWND           hCtl;
  576.    hCtl = GetDlgItem ( hDlg, IDC_INPUTSOURCE );
  578.    itemIndex = SendMessage ( hCtl, CB_GETCURSEL, 0, 0 );
  579.    input = SendMessage ( hCtl, CB_GETITEMDATA, (WPARAM)itemIndex, (LPARAM)0 );
  581.    error = RGBSetInput ( pWindow->HRGB, input );
  582.    if ( error )
  583.    {
  584.       PostMessage ( hDlg, PROP_SETFOCUS, 0, IDC_INPUTSOURCE );
  585.    }
  586.    return error;
  587. }
  589. /******************************************************************************/
  591. unsigned long
  592. UpdateAddrWidth (
  593.    HWND     hDlg,
  594.    PWINDOW  pWindow )
  595. {
  596.    unsigned long  error;
  597.    HWND           hCtl;
  598.    unsigned long  maximum, minimum, current;
  600.    if ( error = RGBGetCaptureWidthMaximum ( pWindow->HRGB, &maximum ) )
  601.    {
  602.       return error;
  603.    }
  605.    if ( error = RGBGetCaptureWidth ( pWindow->HRGB, &current ) )
  606.    {
  607.       return error;
  608.    }
  610.    if ( error = RGBGetCaptureWidthMinimum ( pWindow->HRGB, &minimum ) )
  611.    {
  612.       return error;
  613.    }
  615.    SetDlgItemInt ( hDlg, IDC_ADDRWIDTH, current, FALSE );
  617.    hCtl = GetDlgItem ( hDlg, IDC_ADDRWIDTHSPIN );
  619.    if ( hCtl )
  620.    {
  621.       SendMessage ( hCtl, UDM_SETRANGE32, minimum, maximum );
  622.       SendMessage ( hCtl, UDM_SETPOS32, 0, current );
  623.    }
  625.    return error;
  626. }
  628. /******************************************************************************/
  630. unsigned long
  631. UpdateAddrHeight (
  632.    HWND     hDlg,
  633.    PWINDOW  pWindow )
  634. {
  635.    unsigned long  error;
  636.    HWND           hCtl;
  637.    unsigned long  maximum, minimum, current;
  639.    if ( error = RGBGetCaptureHeightMaximum ( pWindow->HRGB, &maximum ) )
  640.    {
  641.       return error;
  642.    }
  644.    if ( error = RGBGetCaptureHeight ( pWindow->HRGB, &current ) )
  645.    {
  646.       return error;
  647.    }
  649.    if ( error = RGBGetCaptureHeightMinimum ( pWindow->HRGB, &minimum ) )
  650.    {
  651.       return error;
  652.    }
  654.    SetDlgItemInt ( hDlg, IDC_ADDRHEIGHT, current, FALSE );
  656.    hCtl = GetDlgItem ( hDlg, IDC_ADDRHEIGHTSPIN );
  658.    if ( hCtl )
  659.    {
  660.       SendMessage ( hCtl, UDM_SETRANGE32, minimum, maximum );
  661.       SendMessage ( hCtl, UDM_SETPOS32, 0, current );
  662.    }
  664.    return error;
  665. }
  667. /******************************************************************************/
  669. unsigned long
  670. UpdateCroppingControls (
  671.    HWND           hDlg,
  672.    PWINDOW        pWindow )
  673. {
  674.    unsigned long  count;
  675.    unsigned long  bEnable;
  677.    struct Control
  678.    {
  679.       DWORD editCtrl;
  680.       DWORD spinCtrl;
  681.       long  minimum;
  682.       long  current;
  683.       long  maximum;
  684.       BOOL  sign;
  685.    }  controls[] = 
  686.       {
  687.          { IDC_TOP,     IDC_TOPSPIN,      0, 0, 0, TRUE },
  688.          { IDC_LEFT,    IDC_LEFTSPIN,     0, 0, 0, TRUE },
  689.          { IDC_WIDTH,   IDC_WIDTHSPIN,    0, 0, 0, FALSE },
  690.          { IDC_HEIGHT,  IDC_HEIGHTSPIN,   0, 0, 0, FALSE },
  691.       };
  693.    /* TODO: error reporting. */
  694.    RGBGetCroppingMaximum ( pWindow->HRGB,
  695.          &controls[0].maximum, &controls[1].maximum, 
  696.          &controls[2].maximum, &controls[3].maximum );
  698.    RGBGetCroppingMinimum ( pWindow->HRGB,
  699.          &controls[0].minimum, &controls[1].minimum, 
  700.          &controls[2].minimum, &controls[3].minimum );
  702.    /* Current comes last because we're interested in the current bEnable value.
  703.     */
  704.    RGBGetCropping (pWindow->HRGB,
  705.          &controls[0].current, &controls[1].current, 
  706.          &controls[2].current, &controls[3].current );
  708.    RGBIsCroppingEnabled ( pWindow->HRGB, &bEnable );
  709.    
  710.    CheckRadioButton ( hDlg, IDC_CROPPINGON, IDC_CROPPINGOFF,
  711.          ( bEnable ) ? IDC_CROPPINGON : IDC_CROPPINGOFF );
  713.    for ( count = 0;
  714.          count < sizeof ( controls ) / sizeof ( struct Control );
  715.          count++ )
  716.    {
  717.       HWND hCtl;
  719.       SetDlgItemInt ( hDlg, controls[count].editCtrl, 
  720.             controls[count].current, 
  721.             controls[count].sign );
  723.       hCtl = GetDlgItem ( hDlg, controls[count].spinCtrl );
  725.       if ( hCtl )
  726.       {
  727.          SendMessage ( hCtl, UDM_SETRANGE32, 
  728.             controls[count].minimum, 
  729.             controls[count].maximum );
  730.       
  731.          SendMessage ( hCtl, UDM_SETPOS32, 
  732.             0, controls[count].current );
  733.       }
  734.    }
  736.    return 0;
  737. }
  739. /******************************************************************************/
  741. void
  742. UpdateControls (
  743.    HWND           hDlg,
  744.    PWINDOW        pWindow )
  745. {
  746.    pWindow->BProgram = FALSE;
  748.    /* Initialise the addressable width and height. */
  749.    UpdateAddrWidth ( hDlg, pWindow );
  750.    UpdateAddrHeight ( hDlg, pWindow );
  752.    /* Initialise cropping controls. */
  753.    UpdateCroppingControls ( hDlg, pWindow );
  755.    /* Initialise the slider bars. */
  756.    {
  757.       struct Control
  758.       {
  759.          int   ScrollID;
  760.          int   ValueID;
  761.          long  Current;
  762.       }  control[] =
  763.       {
  764.          { IDC_HOROFFSET,  IDC_HOROFFSETVALUE,  0 },
  765.          { IDC_HORSCALE,   IDC_HORSCALEVALUE,   0 },
  766.          { IDC_PHASE,      IDC_PHASEVALUE,      0 },
  767.          { IDC_VEROFFSET,  IDC_VEROFFSETVALUE,  0 },
  768.          { IDC_BLACKLEVEL, IDC_BLACKLEVELVALUE, 0 },
  769.          { IDC_BRIGHTNESS, IDC_BRIGHTNESSVALUE, 0 },
  770.          { IDC_CONTRAST,   IDC_CONTRASTVALUE,   0 },
  771.       };
  772.       int i;
  774.       for ( i = 0; i < ( sizeof ( control ) / sizeof ( control[0] )); i++ )
  775.       {
  776.          HWND  hCtl;
  777.          unsigned long  error, minimum, maximum;
  779.          hCtl = GetDlgItem ( hDlg, control[i].ScrollID );
  781.          error = GetMinimumValueForSlider ( pWindow, control[i].ScrollID, &minimum );
  782.          if ( error == 0 )
  783.          {
  784.             GetMaximumValueForSlider ( pWindow, control[i].ScrollID, &maximum );
  785.             GetCurrentValueForSlider ( pWindow, control[i].ScrollID, &control[i].Current );
  787.             SetTrackBarRange ( hCtl, minimum, maximum, TRUE );
  788.             SetTrackBarPos ( hCtl, control[i].Current, TRUE );
  790.             SetDlgItemInt ( hDlg, control[i].ValueID, control[i].Current, 
  791.                   TRUE );
  792.          }
  793.          else
  794.          {
  795.             EnableWindow ( hCtl, FALSE );
  796.          }
  797.       }
  798.    }
  800.    /* Initialise the Capture format. */
  803.    pWindow->BProgram = TRUE;
  805.    return;
  806. }
  808. /******************************************************************************/
  810. unsigned long
  811. UpdateCroppingState (
  812.    HWND     hDlg,
  813.    PWINDOW  pWindow,
  814.    BOOL     bValidMode )
  815. {
  816.    static const struct
  817.    {
  818.       int   ScrollID;
  819.       int   ValueID;
  820.       int   StaticID;
  821.    } control[] =
  822.       {
  823.          { IDC_TOPSPIN,    IDC_TOP,    IDC_TOPSTATIC },
  824.          { IDC_LEFTSPIN,   IDC_LEFT,   IDC_LEFTSTATIC },
  825.          { IDC_WIDTHSPIN,  IDC_WIDTH,  IDC_WIDTHSTATIC },
  826.          { IDC_HEIGHTSPIN, IDC_HEIGHT, IDC_HEIGHTSTATIC },
  827.       };
  828.    HWND  hCtl;
  829.    int   bEnable, i;
  831.    bEnable = bValidMode ? TRUE : FALSE;
  832.    hCtl = GetDlgItem ( hDlg, IDC_CROPPINGON );
  833.    EnableWindow ( hCtl, bEnable );
  834.    hCtl = GetDlgItem ( hDlg, IDC_CROPPINGOFF );
  835.    EnableWindow ( hCtl, bEnable );
  836.    
  837.    bEnable = ( ( IsDlgButtonChecked ( hDlg, IDC_CROPPINGON ) == BST_CHECKED ) &&
  838.          bValidMode );
  839.    for ( i = 0; i < ( sizeof ( control ) / sizeof ( control[0] )); i++ )
  840.    {
  841.       hCtl = GetDlgItem ( hDlg, control[i].ScrollID );
  842.       EnableWindow ( hCtl, bEnable );
  844.       hCtl = GetDlgItem ( hDlg, control[i].ValueID );
  845.       EnableWindow ( hCtl, bEnable );
  847.       hCtl = GetDlgItem ( hDlg, control[i].StaticID );
  848.       EnableWindow ( hCtl, bEnable );
  849.    }
  851.    return 0;
  852. }
  854. /******************************************************************************/
  856. unsigned long
  857. UpdateControlState (
  858.    HWND     hDlg,
  859.    PWINDOW  pWindow,
  860.    BOOL     bValidMode )
  861. {
  862.    static const struct
  863.    {
  864.       int   ScrollID;
  865.       int   ValueID;
  866.       int   StaticID;
  868.       BOOL  BHideValue;
  869.    } control[] =
  870.       {
  871.          { IDC_ADDRWIDTHSPIN, IDC_ADDRWIDTH,       IDC_ADDRWIDTHSTATIC,  FALSE },
  872.          { IDC_ADDRHEIGHTSPIN,IDC_ADDRHEIGHT,      IDC_ADDRHEIGHTSTATIC, FALSE },
  874.          { IDC_HOROFFSET,     IDC_HOROFFSETVALUE,  IDC_HOROFFSETSTATIC,  TRUE },
  875.          { IDC_HORSCALE,      IDC_HORSCALEVALUE,   IDC_HORSCALESTATIC,   TRUE },
  876.          { IDC_PHASE,         IDC_PHASEVALUE,      IDC_PHASESTATIC,      TRUE },
  877.          { IDC_VEROFFSET,     IDC_VEROFFSETVALUE,  IDC_VEROFFSETSTATIC,  TRUE },
  878.          { IDC_BLACKLEVEL,    IDC_BLACKLEVELVALUE, IDC_BLACKLEVELSTATIC, TRUE },
  879.          { IDC_BRIGHTNESS,    IDC_BRIGHTNESSVALUE, IDC_BRIGHTNESSSTATIC, TRUE },
  880.          { IDC_CONTRAST,      IDC_CONTRASTVALUE,   IDC_CONTRASTSTATIC,   TRUE },
  881.       };
  882.    int   i;
  884.    UpdateCroppingState ( hDlg, pWindow, bValidMode );
  886.    for ( i = 0; i < ( sizeof ( control ) / sizeof ( control[0] )); i++ )
  887.    {
  888.       HWND  hCtl;
  890.       hCtl = GetDlgItem ( hDlg, control[i].ScrollID );
  891.       EnableWindow ( hCtl, ( bValidMode ) ? TRUE : FALSE );
  893.       hCtl = GetDlgItem ( hDlg, control[i].StaticID );
  894.       EnableWindow ( hCtl, ( bValidMode ) ? TRUE : FALSE );
  896.       hCtl = GetDlgItem ( hDlg, control[i].ValueID );
  897.       if ( control[i].BHideValue )
  898.          ShowWindow ( hCtl, ( bValidMode ) ? SW_NORMAL : SW_HIDE );
  899.       else
  900.          EnableWindow ( hCtl, ( bValidMode ) ? TRUE : FALSE );
  901.    }
  903.    return 0;
  904. }
  906. /******************************************************************************/
  908. unsigned long
  909. UpdateRedetectState (
  910.    HWND           hDlg,
  911.    unsigned long  signalState )
  912. {
  913.    HWND  hCtl;
  915.    hCtl = GetDlgItem ( hDlg, IDC_RESET );
  916.    switch ( signalState )
  917.    {
  918.       case VALIDSIGSTATE:
  919.       case INVALIDSIGSTATE:
  920.       {
  921.          EnableWindow ( hCtl, TRUE );
  922.          break;
  923.       }
  924.       case NOSIGNALSTATE:
  925.       case CAPTURENOTRUNNING:
  926.       {
  927.          EnableWindow ( hCtl, FALSE );
  928.          break;
  929.       }
  931.       /* TODO : Could we make the redetect try and restart the capture? */      
  932.       case ERRORSTATE:
  933.       {
  934.          EnableWindow ( hCtl, FALSE );
  935.          break;
  936.       }
  938.       default:
  939.       {
  940.          /* It's probably better to enable the window when we get a strange 
  941.           * signal state. */
  942.          EnableWindow ( hCtl, TRUE );
  943.          return ERROR_INVALID_STATE;
  944.       }
  945.    }
  947.    return 0;
  948. }
  950. /******************************************************************************/
  952. unsigned long
  953. UpdateInputState (
  954.    HWND           hDlg,
  955.    unsigned long  signalState )
  956. {
  957.    HWND  hCtl;
  959.    hCtl = GetDlgItem ( hDlg, IDC_INPUTSOURCE );
  961.    switch ( signalState )
  962.    {
  963.       case VALIDSIGSTATE:
  964.       case INVALIDSIGSTATE:
  965.       case NOSIGNALSTATE:
  966.       {
  967.          EnableWindow ( hCtl, TRUE );
  968.          break;
  969.       }
  970.       
  971.       case CAPTURENOTRUNNING:
  972.       case ERRORSTATE:
  973.       {
  974.          EnableWindow ( hCtl, FALSE );
  975.          break;
  976.       }
  978.       default:
  979.       {
  980.          /* It's probably better to enable the window when we get a strange 
  981.           * signal state. */
  982.          EnableWindow ( hCtl, TRUE );
  983.          return ERROR_INVALID_STATE;
  984.       }
  985.    }
  987.    return 0;
  988. }
  990. /******************************************************************************/
  992. unsigned long RGBCBKAPI
  993. ModeChangeFn (
  994.    HWND                 hWnd,
  995.    HRGB                 hRGB,
  996.    PRGBMODECHANGEDINFO  pModeChangedInfo,
  997.    unsigned long        userData )
  998. {
  999.    HWND  hDlg = (HWND)userData;
  1001.    if ( hDlg )
  1002.    {
  1003.       SendMessage ( hDlg, WM_MODECHANGEUPDATE, (WPARAM) NULL, (LPARAM) NULL );
  1004.    }
  1006.    return 0;
  1007. }
  1009. /******************************************************************************/
  1011. unsigned long RGBCBKAPI
  1012. NoSignalFn (
  1013.    HWND           hWnd,
  1014.    HRGB           hRGB,
  1015.    unsigned long  userData )
  1016. {
  1017.    HWND  hDlg = (HWND)userData;
  1019.    if ( hDlg )
  1020.    {
  1021.       SendMessage ( hDlg, WM_NOSIGNALUPDATE, (WPARAM) NULL, (LPARAM) NULL );
  1022.    }
  1024.    RGBNoSignal ( hRGB );
  1026.    return 0;
  1027. }
  1029. /******************************************************************************/
  1031. unsigned long RGBCBKAPI
  1032. InvalidSignalFn (
  1033.    HWND           hWnd,
  1034.    HRGB           hRGB,
  1035.    unsigned long  horClock,
  1036.    unsigned long  verClock,
  1037.    unsigned long  userData )
  1038. {
  1039.    HWND  hDlg = (HWND)userData;
  1041.    if ( hDlg )
  1042.    {
  1043.       SendMessage ( hDlg, WM_INVALIDSIGUPDATE, (WPARAM) NULL, (LPARAM) NULL );
  1044.    }
  1046.    RGBInvalidSignal ( hRGB, horClock, verClock );
  1048.    return 0;
  1049. }
  1051. /******************************************************************************/
  1053. BOOL APIENTRY
  1054. InputSettingsDlgProc (
  1055.    HWND hDlg,
  1056.    UINT message,
  1057.    UINT wParam,
  1058.    LONG lParam )
  1059. {
  1060.    BOOL  bReturn = FALSE;
  1062.    switch ( message )
  1063.    {
  1064.       case PROP_SETFOCUS:
  1065.       {
  1066.          HWND hCtrl;
  1068.          hCtrl = GetDlgItem ( hDlg, (int)lParam );
  1069.          if ( hCtrl )
  1070.             SetFocus ( hCtrl );
  1071.          break;
  1072.       }
  1073.       case WM_HSCROLL:
  1074.       {
  1075.          int   nScrollCode;
  1076.          HWND  hCtl;
  1077.          long  minimum, maximum, position;
  1079.          nScrollCode = LOWORD ( wParam );
  1080.          if ( nScrollCode == SB_ENDSCROLL )
  1081.          {
  1082.             break;
  1083.          }
  1085.          hCtl = (HWND)lParam;
  1086.          GetTrackBarRange ( hCtl, &minimum, &maximum );
  1087.          position = GetTrackBarPos ( hCtl );
  1089.          switch ( nScrollCode )
  1090.          {
  1091.             case SB_LINELEFT:
  1092.                if ( position > minimum )
  1093.                {
  1094.                   position--;
  1095.                }
  1096.                break;
  1098.             case SB_LINERIGHT:
  1099.                if ( position < maximum )
  1100.                {
  1101.                   position++;
  1102.                }
  1103.                break;
  1105.             case SB_PAGELEFT:
  1106.                position -= 5;
  1107.                if ( position < minimum )
  1108.                {
  1109.                   position = minimum;
  1110.                }
  1111.                break;
  1113.             case SB_PAGERIGHT:
  1114.                position += 5;
  1115.                if ( position > maximum )
  1116.                {
  1117.                   position = maximum;
  1118.                }
  1119.                break;
  1121.             case SB_THUMBTRACK:
  1122.             case SB_THUMBPOSITION:
  1123.                position = (signed short)HIWORD ( wParam );
  1124.                break;
  1126.             case SB_LEFT:
  1127.                position = minimum;
  1128.                break;
  1130.             case SB_RIGHT:
  1131.                position = maximum;
  1132.                break;
  1133.          }
  1135.          {
  1136.             PWINDOW  pWindow;
  1138.             pWindow = GetProp ( hDlg, Property );
  1139.             if ( pWindow )
  1140.             {
  1141.                int   nScrollId;
  1143.                nScrollId = GetDlgCtrlID ( hCtl );
  1145.                SetValueFromSlider ( hDlg, pWindow, nScrollId, position );
  1147.                if ( ( nScrollId == IDC_HOROFFSET ) ||
  1148.                     ( nScrollId == IDC_VEROFFSET ) ||
  1149.                     ( nScrollId == IDC_HORSCALE ) )
  1150.                {
  1151.                   /* The cropping regions are related to the three capture 
  1152.                    * parameters above, update the cropping limits. */
  1153.                   UpdateCroppingControls ( hDlg, pWindow );
  1154.                }
  1155.             }
  1156.          }
  1158.          if ( nScrollCode != SB_THUMBTRACK )
  1159.          {
  1160.             SetTrackBarPos ( hCtl, position, TRUE );
  1161.          }
  1163.          bReturn = TRUE;
  1164.          break;
  1165.       }
  1167.       case WM_COMMAND:
  1168.       {
  1169.          PWINDOW     pWindow;
  1171.          /* WM_COMMAND messages are received before we have a chance to set the
  1172.           * property in response to the WM_INITDIALOG message. */
  1173.          pWindow = GetProp ( hDlg, Property );
  1174.          if ( ( pWindow == 0 ) || ( pWindow->BProgram == FALSE ) )
  1175.          {
  1176.             break;
  1177.          }
  1179.          switch ( LOWORD ( wParam ))
  1180.          {
  1181.             case IDC_TOP:
  1182.             case IDC_LEFT:
  1183.             case IDC_WIDTH:
  1184.             case IDC_HEIGHT:
  1185.                if ( HIWORD  ( wParam ) == EN_CHANGE )
  1186.                {
  1187.                   Cropping ( hDlg, pWindow, pWindow->HCurrentMode, FALSE );
  1188.                }
  1189.                bReturn = TRUE;
  1190.                break;
  1192.             case IDC_INPUTSOURCE:
  1193.             {
  1194.                HWND  hCtl;
  1196.                hCtl = (HWND)lParam;
  1197.                if ( HIWORD ( wParam ) == CBN_SELCHANGE )
  1198.                {
  1199.                   SetInputSource ( hDlg, pWindow );
  1200.                }
  1201.                bReturn = TRUE;
  1202.                break;
  1203.             }
  1205.             case IDC_ADDRWIDTH:
  1206.                if ( HIWORD  ( wParam ) == EN_CHANGE )
  1207.                {
  1208.                   AddrWidth ( hDlg, pWindow, FALSE );
  1209.                }
  1210.                bReturn = TRUE;
  1211.                break;
  1213.             case IDC_ADDRHEIGHT:
  1214.                if ( HIWORD  ( wParam ) == EN_CHANGE )
  1215.                {
  1216.                   AddrHeight ( hDlg, pWindow, FALSE );
  1217.                }
  1218.                bReturn = TRUE;
  1219.                break;
  1221.             case IDC_CROPPINGON:
  1222.             case IDC_CROPPINGOFF:
  1223.             {
  1224.                unsigned long  bEnable;
  1225.                
  1226.                bEnable = ( IsDlgButtonChecked ( hDlg, IDC_CROPPINGON ) == 
  1227.                      BST_CHECKED );
  1229.                RGBEnableCropping ( pWindow->HRGB, bEnable );
  1230.                
  1231.                UpdateCroppingState ( hDlg, pWindow, 
  1232.                      ( pWindow->HCurrentMode ) ? TRUE : FALSE );
  1234.                bReturn = TRUE;
  1235.                break;
  1236.             }
  1238.             case IDC_RESET:
  1239.             {
  1240.                RGBReset ( pWindow->HRGB );
  1241.                break;
  1242.             }
  1243.          }
  1244.          break;
  1245.       }
  1247.       case WM_NOTIFY:
  1248.       {
  1249.          LPPSHNOTIFY lpPSHNotify = (LPPSHNOTIFY)lParam;
  1251.          switch ( lpPSHNotify->hdr.code )
  1252.          {
  1253.             case PSN_APPLY: /* The OK or Apply button was pressed. */
  1254.             {
  1255.                LONG     result = PSNRET_NOERROR;
  1256.                PWINDOW  pWindow;
  1258.                pWindow = GetProp ( hDlg, Property );
  1259.                if ( !pWindow )
  1260.                {
  1261.                   /* TODO: What should we do in these circumstances? */
  1262.                   break;
  1263.                }
  1265.                /* Check the input is valid. */
  1266.                {
  1267.                   unsigned long  error;
  1269.                   error = SetInputSource ( hDlg, pWindow );
  1270.                   if ( error )
  1271.                   {
  1272.                      PostMessage ( hDlg, PROP_SETFOCUS, 0, IDC_INPUTSOURCE );
  1273.                      result = PSNRET_INVALID;
  1274.                   }
  1275.                }
  1277.                /* These values cannot be set if there is no signal */
  1278.                if ( pWindow->HCurrentMode )
  1279.                {
  1280.                   if ( IsDlgButtonChecked ( hDlg, IDC_CROPPINGON ) == 
  1281.                         BST_CHECKED )
  1282.                   {
  1283.                      if (( result == PSNRET_NOERROR ) && 
  1284.                            !Cropping ( hDlg, pWindow, pWindow->HCurrentMode, 
  1285.                            TRUE ))
  1286.                      {
  1287.                         result = PSNRET_INVALID;
  1288.                      }
  1289.                   }
  1291.                   if (( result == PSNRET_NOERROR ) && 
  1292.                            !AddrWidth ( hDlg, pWindow, TRUE ))
  1293.                   {
  1294.                      result = PSNRET_INVALID;
  1295.                   }
  1297.                   if (( result == PSNRET_NOERROR ) && 
  1298.                            !AddrHeight ( hDlg, pWindow, TRUE ))
  1299.                   {
  1300.                      result = PSNRET_INVALID;
  1301.                   }
  1302.                }
  1303.                
  1304.                /* If no error occurred and the OK button was pressed, free the
  1305.                 * resources allocated for this page. */
  1306.                if (( result == PSNRET_NOERROR ) && ( lpPSHNotify->lParam ))
  1307.                {
  1308.                   RGBSetModeChangedFn ( pWindow->HRGB, NULL, 0 );
  1309.                   RGBSetNoSignalFn ( pWindow->HRGB, NULL, 0 );
  1310.                   RGBSetInvalidSignalFn ( pWindow->HRGB, NULL, 0 );
  1312.                   RemoveProp ( hDlg, Property );
  1313.                }
  1314.                /* Indicate whether or not property sheet can be destroyed. */
  1315.                SetWindowLong ( hDlg, DWL_MSGRESULT, result );
  1316.                return TRUE;
  1317.             }
  1319.             case PSN_QUERYCANCEL: /* The Cancel button was pressed. */
  1320.                /* Tell Windows it can destroy the property sheet. */
  1321.                SetWindowLong ( hDlg, DWL_MSGRESULT, FALSE );
  1322.                return TRUE;
  1324.             case PSN_KILLACTIVE: /* Page is about to lose activation. */
  1325.                /* Set FALSE because want to allow page to lose activation. */
  1326.                SetWindowLong ( hDlg, DWL_MSGRESULT, FALSE );
  1327.                return TRUE;
  1328.          
  1329.             case UDN_DELTAPOS:
  1330.             {
  1331.                LPNMUPDOWN  lpUpDown = ( LPNMUPDOWN ) lParam;
  1332.                PWINDOW     pWindow;
  1334.                pWindow = GetProp ( hDlg, Property );
  1336.                switch ( lpUpDown->hdr.idFrom )
  1337.                {
  1338.                   /* We test the cropping width using the standard 
  1339.                    * TestAddrWidth. If it is successful it will be a legitimate
  1340.                    * cropping width. */
  1341.                   case IDC_ADDRWIDTHSPIN:
  1342.                   case IDC_WIDTHSPIN:
  1343.                   {
  1344.                      unsigned long  value;
  1345.                      unsigned long  result;
  1347.                      value = lpUpDown->iPos;
  1349.                      do
  1350.                      {
  1351.                         value += lpUpDown->iDelta;
  1352.                         result = RGBTestCaptureWidth ( pWindow->HRGB, value );
  1353.                      }
  1354.                      while ( ( result == RGBERROR_HORADDRTIME_NOT_DWORD_DIVISIBLE ) ||
  1355.                              ( result == RGBERROR_HORADDRTIME_NOT_WORD_DIVISIBLE ) ||
  1356.                              ( result == RGBERROR_HORADDRTIME_NOT_WORD_DIVISIBLE ) );
  1358.                      if ( result == 0 )
  1359.                      {
  1360.                         /* Calculate the legal delta. */
  1361.                         lpUpDown->iDelta = value - lpUpDown->iPos;
  1362.                      }
  1363.                   }
  1364.                   break;
  1365.                }
  1367.                /* TODO : Do we need to do this for any of the other controls? */
  1368.             }
  1370.             default:
  1371.                return FALSE;
  1372.          }
  1373.          break;
  1374.       }  /* End of case WM_NOTIFY. */
  1376.       case WM_INITDIALOG:
  1377.       {
  1378.          LPPROPSHEETPAGE   pPage = (LPPROPSHEETPAGE)lParam;
  1379.          PWINDOW           pWindow = (PWINDOW)pPage->lParam;
  1380.          unsigned long     state;
  1381.          unsigned long     error;
  1382.          
  1383.          /* Save pWindow. */
  1384.          SetProp ( hDlg, Property, pWindow );
  1386.          /* Set our callbacks. */
  1388.          RGBSetModeChangedFn ( pWindow->HRGB, ModeChangeFn, (unsigned long)hDlg );
  1389.          RGBSetNoSignalFn ( pWindow->HRGB, NoSignalFn, (unsigned long)hDlg );
  1390.          RGBSetInvalidSignalFn ( pWindow->HRGB, InvalidSignalFn, (unsigned long)hDlg );
  1392.          InintialiseInputSource ( hDlg, pWindow );
  1394.          error = RGBGetCaptureState ( pWindow->HRGB, &state );
  1395.          if ( error == 0 )
  1396.          {
  1397.             if ( state == RGB_STATE_CAPTURING )
  1398.             {
  1399.                pWindow->HCurrentMode = TRUE;
  1400.                UpdateControls ( hDlg, pWindow );
  1401.                UpdateControlState ( hDlg, pWindow, TRUE );
  1402.             }
  1403.             else
  1404.             {
  1405.                pWindow->HCurrentMode = 0;
  1406.                UpdateControlState ( hDlg, pWindow, FALSE );
  1407.             }
  1409.             UpdateInputState ( hDlg, state );
  1410.             UpdateRedetectState ( hDlg, state );
  1411.          }
  1412.          else
  1413.          {
  1414.             /* TODO : Error... */
  1415.          }
  1417.          break;
  1418.       }  /* End of case WM_INITDIALOG. */
  1420.       case WM_MODECHANGEUPDATE:
  1421.       {
  1422.          PWINDOW pWindow = GetProp ( hDlg, Property );
  1424.          pWindow->HCurrentMode = TRUE;
  1426.          UpdateControls ( hDlg, pWindow );
  1427.          UpdateControlState ( hDlg, pWindow, TRUE );
  1428.          UpdateRedetectState ( hDlg, VALIDSIGSTATE );
  1429.          break;
  1430.       }
  1432.       case WM_NOSIGNALUPDATE:
  1433.       {
  1434.          PWINDOW pWindow = GetProp ( hDlg, Property );
  1436.          pWindow->HCurrentMode = 0;
  1438.          UpdateControlState ( hDlg, pWindow, FALSE );
  1439.          UpdateRedetectState ( hDlg, NOSIGNALSTATE );
  1440.          break;
  1441.       }
  1443.       case WM_INVALIDSIGUPDATE:
  1444.       {
  1445.          PWINDOW pWindow = GetProp ( hDlg, Property );
  1447.          pWindow->HCurrentMode = 0;
  1449.          UpdateControlState ( hDlg, pWindow, FALSE );
  1450.          UpdateRedetectState ( hDlg, INVALIDSIGSTATE );
  1451.          break;
  1452.       }
  1454.       default:
  1455.          break;
  1456.    }
  1458.    return bReturn;
  1459. }
  1461. /******************************************************************************/
  1463. DWORD WINAPI
  1464. CreatePropertiesDialog (
  1465.    LPVOID   lpParam )
  1466. {
  1467.    unsigned long     error = 0;
  1468.    PWINDOW           pWindow = (PWINDOW)lpParam;
  1469.    int               i;
  1470.    PROPSHEETPAGE     psp[1];
  1471.    PROPSHEETHEADER   psh;
  1473.    /* The pages... */   
  1474.    i = 0;
  1476.    memset ( &psp[i], 0, sizeof ( PROPSHEETPAGE ));
  1477.    psp[i].dwSize = sizeof ( PROPSHEETPAGE );
  1478.    psp[i].dwFlags = PSP_DEFAULT | PSP_HASHELP;
  1479.    psp[i].hInstance = pWindow->HInstance;
  1480.    psp[i].pszTemplate = (LPTSTR) IDD_DISPLAY;
  1481.    psp[i].pszIcon = NULL;
  1482.    psp[i].pfnDlgProc = InputSettingsDlgProc;
  1483.    psp[i].pszTitle = NULL;
  1484.    psp[i].lParam = (LPARAM)pWindow;
  1485.    i++;
  1487.    memset ( &psh, 0, sizeof ( PROPSHEETHEADER ));
  1488.    psh.dwSize = sizeof ( PROPSHEETHEADER );
  1489.    psh.dwFlags = PSH_PROPSHEETPAGE | PSH_HASHELP | PSH_NOCONTEXTHELP;
  1490.    psh.hwndParent = pWindow->HWndParent;
  1491.    psh.hInstance = pWindow->HInstance;
  1492.    psh.pszIcon = NULL;
  1493.    psh.pszCaption = TEXT("Input Settings");
  1494.    
  1495.    psh.nPages = i;
  1496.    psh.nStartPage = 0;
  1497.    psh.ppsp = psp;
  1498.    psh.pszbmWatermark = NULL;
  1499.    
  1500.    if ( PropertySheet ( &psh ) == -1 )
  1501.    {
  1502.       error = GetLastError ( );
  1503.    }
  1505.    return error;
  1506. }
  1508. /******************************************************************************/
  1510. unsigned long
  1511. DoProperties (
  1512.    HINSTANCE      hInstance,
  1513.    HWND           hWndParent,
  1514.    HRGB           hRGB,
  1515.    int            nStartPage )
  1516. {
  1517.    unsigned long  error = 0;
  1518.    PWINDOW        pWindow;
  1519.    HANDLE         thread;
  1521.    pWindow = (PWINDOW)malloc ( sizeof (WINDOW ));
  1522.    if ( pWindow )
  1523.    {
  1524.       pWindow->HInstance = hInstance;
  1525.       pWindow->HWndParent = hWndParent;
  1526.       pWindow->HRGB = hRGB;
  1527.       pWindow->BProgram = FALSE;
  1528.       pWindow->HCurrentMode = TRUE;
  1530.       thread = CreateThread ( NULL, 0, CreatePropertiesDialog, pWindow, 0, NULL );
  1531.       if ( thread )
  1532.       {
  1533.          CloseHandle ( thread );
  1534.          return 0;
  1535.       }
  1536.    }
  1538.    return GetLastError();;
  1539. }