panel.c

M3355的源代码

#if PNL_CLASS_TV == PNL_MODULE_SIGNAL
/* Data declaration */
#ifdef  PNL_POS_TV_NTSC
const   PNL_POS_TYPE    PnlPosTvNTSC[] =
    {
        PNL_POS_TV_NTSC, PNL_POS_NULL
    };
#else   /* PNL_POS_TV_NTSC undefined */
#define PnlPosTvNTSC    PnlPosNull
#endif

#ifdef  PNL_POS_TV_PAL
const   PNL_POS_TYPE    PnlPosTvPAL[] =
    {
        PNL_POS_TV_PAL, PNL_POS_NULL
    };
#else   /* PNL_POS_TV_PAL undefined */
#define PnlPosTvPAL     PnlPosNull
#endif

#ifdef  PNL_POS_TV_AUTO
const   PNL_POS_TYPE    PnlPosTvAUTO[] =
    {
        PNL_POS_TV_AUTO, PNL_POS_NULL
    };
#else   /* PNL_POS_TV_AUTO undefined */
#define PnlPosTvAUTO    PnlPosNull
#endif

const PNL_POS_TYPE  *mTvSignal[] =
    {
        PnlPosTvNTSC,               /* PNL_HSIG_NTSC        0 */
        PnlPosTvPAL,                /* PNL_HSIG_PAL         1 */
        PnlPosTvAUTO                /* PNL_HSIG_AUTO        2 */
    };

const DWORD mTvAttr[] =
    {
        PNL_ATTR_TV_NTSC,
        PNL_ATTR_TV_PAL,
        PNL_ATTR_TV_AUTO
    };

SIGNAL_FUNCTION
(
    PnlLightTv,
    mTvSignal,
    mTvAttr,
    sizeof(mTvAttr)/sizeof(DWORD)
)

#elif PNL_CLASS_TV == PNL_MODULE_NONE
void PnlLightTv(DWORD hSig)
{}
#endif

/*------------------------------------------------------------------\
|   Function_Name:                                                  |
|       void PnlLightPlayback(DWORD hSig)                           |
|                                                                   |
|   Description: Light Playback Control Signal                      |
|                we now implement PnlLightPlayback with Signal Mod- |
|                ule only                                           |
|                                                                   |
|   Arguments:                                                      |
|           DWORD   hSig : handle of signal or PNL_HSIG_OFF         |
|                                                                   |
|   Return Value:                                                   |
\------------------------------------------------------------------*/
#if PNL_CLASS_PLAYBACK == PNL_MODULE_SIGNAL
/* Data declaration */
#ifdef  PNL_POS_PC_PLAY
const   PNL_POS_TYPE    PnlPosPCPlay[] =
    {
        PNL_POS_PC_PLAY, PNL_POS_NULL
    };
#else   /* PNL_POS_PC_PLAY undefined */
#define PnlPosPCPlay    PnlPosNull
#endif

#ifdef  PNL_POS_PC_PAUSE
const   PNL_POS_TYPE    PnlPosPCPause[] =
    {
        PNL_POS_PC_PAUSE, PNL_POS_NULL
    };
#else   /* PNL_POS_PC_PAUSE undefined */
#define PnlPosPCPause    PnlPosNull
#endif

#ifdef  PNL_POS_PC_STEP
const   PNL_POS_TYPE    PnlPosPCStep[] =
    {
        PNL_POS_PC_STEP, PNL_POS_NULL
    };
#else   /* PNL_POS_PC_STEP undefined */
#define PnlPosPCStep    PnlPosNull
#endif

#ifdef  PNL_POS_PC_FF
const   PNL_POS_TYPE    PnlPosPCFF[] =
    {
        PNL_POS_PC_FF, PNL_POS_NULL
    };
#else   /* PNL_POS_PC_FF undefined */
#define PnlPosPCFF    PnlPosNull
#endif

#ifdef  PNL_POS_PC_FR
const   PNL_POS_TYPE    PnlPosPCFR[] =
    {
        PNL_POS_PC_FR, PNL_POS_NULL
    };
#else   /* PNL_POS_PC_FR undefined */
#define PnlPosPCFR    PnlPosNull
#endif

#ifdef  PNL_POS_PC_SF
const   PNL_POS_TYPE    PnlPosPCSF[] =
    {
        PNL_POS_PC_SF, PNL_POS_NULL
    };
#else   /* PNL_POS_PC_SF undefined */
#define PnlPosPCSF    PnlPosNull
#endif

#ifdef  PNL_POS_PC_SR
const   PNL_POS_TYPE    PnlPosPCSR[] =
    {
        PNL_POS_PC_SR, PNL_POS_NULL
    };
#else   /* PNL_POS_PC_SR undefined */
#define PnlPosPCSR    PnlPosNull
#endif

/* added by ShenZhen start here . 08/25/2000 */
#ifdef PNL_POS_PC_STOP
const   PNL_POS_TYPE    PnlPosPCSTOP[] =
    {
        PNL_POS_PC_STOP, PNL_POS_NULL
    };
#else   /* PNL_POS_PC_SR undefined */
#define PnlPosPCSTOP    PnlPosNull
#endif
#ifdef PNL_POS_PC_DVIEW
const   PNL_POS_TYPE    PnlPosPCDVIEW[] =
    {
        PNL_POS_PC_DVIEW, PNL_POS_NULL
    };
#else   /* PNL_POS_PC_SR undefined */
#define PnlPosPCDVIEW    PnlPosNull
#endif
/* Added by ShenZhen End here .  08/25/2000   */

const PNL_POS_TYPE  *mPlaybackSignal[] =
    {
        PnlPosPCPlay,               /* PNL_HSIG_PLAY        0 */
        PnlPosPCPause,              /* PNL_HSIG_PAUSE       1 */
        PnlPosPCStep,               /* PNL_HSIG_STEP        2 */
        PnlPosPCFF,                 /* PNL_HSIG_FF          3 */
        PnlPosPCFR,                 /* PNL_HSIG_FR          4 */
        PnlPosPCSF,                 /* PNL_HSIG_SF          5 */
        PnlPosPCSR
        /* added by ShenZhen start here . 08/25/2000 */
#ifdef PNL_POS_PC_STOP          /* PNL_HSIG_SR          7 */
        ,PnlPosPCSTOP
#endif
#ifdef PNL_POS_PC_DVIEW         /* PNL_HSIG_SR           8*/
        ,PnlPosPCDVIEW
#endif
        /* Added by ShenZhen End here .  08/25/2000   */
    };

const DWORD mPlaybackAttr[] =
    {
        PNL_ATTR_PC_PLAY,
        PNL_ATTR_PC_PAUSE,
        PNL_ATTR_PC_STEP,
        PNL_ATTR_PC_FF,
        PNL_ATTR_PC_FR,
        PNL_ATTR_PC_SF,
        PNL_ATTR_PC_SR
        /* added by ShenZhen start here . 08/25/2000 */
#ifdef PNL_POS_PC_STOP
        ,
        PNL_ATTR_PC_STOP
#endif
#ifdef PNL_POS_PC_DVIEW
        ,
        PNL_ATTR_PC_DVIEW
#endif
        /* Added by ShenZhen End here .  08/25/2000   */
    };

SIGNAL_FUNCTION
(
    PnlLightPlayback,
    mPlaybackSignal,
    mPlaybackAttr,
    sizeof(mPlaybackAttr)/sizeof(DWORD)
)

#elif PNL_CLASS_PLAYBACK == PNL_MODULE_NONE
void PnlLightPlayback(DWORD hSig)
{}
#endif

/*------------------------------------------------------------------\
|   Function_Name:                                                  |
|       void PnlLightRepeat(DWORD hSig)                             |
|                                                                   |
|   Description: Light Repeat Control Signal                        |
|                we now implement PnlLightRepeat with Signal Modul- |
|                e only                                             |
|                                                                   |
|   Arguments:                                                      |
|           DWORD   hSig : handle of signal or PNL_HSIG_OFF         |
|                                                                   |
|   Return Value:                                                   |
\------------------------------------------------------------------*/
#if PNL_CLASS_REPEAT == PNL_MODULE_SIGNAL
/* Data declaration */
#ifdef  PNL_POS_RC_REPEAT
const   PNL_POS_TYPE    PnlPosRCRepeat[] =
    {
        PNL_POS_RC_REPEAT, PNL_POS_NULL
    };
#else   /* PNL_POS_RC_REPEAT undefined */
#define PnlPosRCRepeat      PnlPosNull
#endif

#ifdef  PNL_POS_RC_REPEAT1
const   PNL_POS_TYPE    PnlPosRCRepeat1[] =
    {
        PNL_POS_RC_REPEAT1, PNL_POS_NULL
    };
#else   /* PNL_POS_RC_REPEAT1 undefined */
#define PnlPosRCRepeat1     PnlPosNull
#endif

#ifdef  PNL_POS_RC_REPEATA
const   PNL_POS_TYPE    PnlPosRCRepeatA[] =
    {
        PNL_POS_RC_REPEATA, PNL_POS_NULL
    };
#else   /* PNL_POS_RC_REPEATA undefined */
#define PnlPosRCRepeatA     PnlPosNull
#endif

#ifdef  PNL_POS_RC_REPEATAB
const   PNL_POS_TYPE    PnlPosRCRepeatAB[] =
    {
        PNL_POS_RC_REPEATAB, PNL_POS_NULL
    };
#else   /* PNL_POS_RC_REPEATAB undefined */
#define PnlPosRCRepeatAB    PnlPosNull
#endif

#ifdef  PNL_POS_RC_REPEATALL
const   PNL_POS_TYPE    PnlPosRCRepeatALL[] =
    {
        PNL_POS_RC_REPEATALL, PNL_POS_NULL
    };
#else   /* PNL_POS_RC_REPEATALL undefined */
#define PnlPosRCRepeatALL   PnlPosNull
#endif

const PNL_POS_TYPE  *mRepeatSignal[] =
    {
        PnlPosRCRepeat,             /* PNL_HSIG_REPEAT      0 */
        PnlPosRCRepeat1,            /* PNL_HSIG_REPEAT1     1 */
        PnlPosRCRepeatA,            /* PNL_HSIG_REPEATA     2 */
        PnlPosRCRepeatAB,           /* PNL_HSIG_REPEATAB    3 */
        PnlPosRCRepeatALL,          /* PNL_HSIG_REPEATALL   4 */
  //      PnlPosRCRandom,             /* PNL_HSIG_RANDOM      5 */
  //      PnlPosRCProgram             /* PNL_HSIG_PROGRAM     6 */
    };

const DWORD mRepeatAttr[] =
    {
        PNL_ATTR_RC_REPEAT,
        PNL_ATTR_RC_REPEAT1,
        PNL_ATTR_RC_REPEATA,
        PNL_ATTR_RC_REPEATAB,
        PNL_ATTR_RC_REPEATALL,
//        PNL_ATTR_RC_RANDOM,
//        PNL_ATTR_RC_PROGRAM
    };

SIGNAL_FUNCTION
(
    PnlLightRepeat,
    mRepeatSignal,
    mRepeatAttr,
    sizeof(mRepeatAttr)/sizeof(DWORD)
)

#elif PNL_CLASS_REPEAT == PNL_MODULE_NONE
void PnlLightRepeat(DWORD hSig)
{}
#endif


//#if(_CUSTOM == CYBERHOME)
// add by sidney start
#if PNL_CLASS_PROGRAM == PNL_MODULE_SIGNAL
/* Data declaration */
#ifdef  PNL_POS_RC_PROGRAM
const   PNL_POS_TYPE    PnlPosRCProgram[] =
    {
        PNL_POS_RC_PROGRAM, PNL_POS_NULL
    };
#else   /* PNL_POS_RC_PROGRAM undefined */
#define PnlPosRCProgram  PnlPosNull
#endif

const PNL_POS_TYPE *mProgramSignal[] =
    {
        PnlPosRCProgram             /* PNL_HSIG_PROGRAM     6 */
    };

const DWORD mProgramAttr[] =
    {
        PNL_ATTR_RC_PROGRAM
    };

SIGNAL_FUNCTION
(
    PnlLightProgram,
    mProgramSignal,
    mProgramAttr,
    sizeof(mProgramAttr) / sizeof(DWORD)
)

#elif PNL_CLASS_PROGRAM == PNL_MODULE_NONE
void PnlLightProgram(DWORD hSig)
{}
#endif
// add by sidney end
//#endif

#if PNL_CLASS_RANDOM == PNL_MODULE_SIGNAL
/* Data declaration */
#ifdef  PNL_POS_RC_RANDOM
const   PNL_POS_TYPE    PnlPosRCRandom[] =
    {
        PNL_POS_RC_RANDOM, PNL_POS_NULL
    };
#else   /* PNL_POS_RC_RANDOM undefined */
#define PnlPosRCRandom  PnlPosNull
#endif

const PNL_POS_TYPE *mRandomSignal[] =
    {
        PnlPosRCRandom             /* PNL_HSIG_PROGRAM     6 */
    };

const DWORD mRandomAttr[] =
    {
        PNL_ATTR_RC_RANDOM
    };

SIGNAL_FUNCTION
(
    PnlLightRandom,
    mRandomSignal,
    mRandomAttr,
    sizeof(mRandomAttr) / sizeof(DWORD)
)

#elif PNL_CLASS_RANDOM == PNL_MODULE_NONE
void PnlLightRandom(DWORD hSig)
{}
#endif

/*------------------------------------------------------------------\
|   Function_Name:                                                  |
|       void PnlLightKaraok(DWORD hSig)