Пример #1
0
VOID GetOptionsFromIni( VOID )
{
    int TileSet, Input, Sound, Priority;

    hini = PrfOpenProfile (habMain, "MAKMAN.INI");

    TileSet  = PrfQueryProfileInt(hini,szAppName,"Tile Set", 1);
    Input    = PrfQueryProfileInt(hini,szAppName,"Input Source", 0);
    Sound    = PrfQueryProfileInt(hini,szAppName,"Sound Enabled", 1);
    Priority = PrfQueryProfileInt(hini,szAppName,"Priority", 0);

    if (debOut)
    {
        fprintf(debOut, "TS : %i, Input %i, Sound %i, Prio %i\n", TileSet, Input, Sound, Priority);
        fflush(debOut);
    }

    SetDefault (IDM_T_CLASSIC + TileSet);
    SetDefault (IDM_KEYBOARD + Input);
    if (Sound)
        SetDefault (IDM_SOUND_ON);
    else
        SetDefault (IDM_SOUND_OFF);
    SetDefault (IDM_PRI_NORMAL + Priority);

    PrfCloseProfile(hini);
}
Пример #2
0
VOID nlsQueryCountrySettings(PCOUNTRYSETTINGS2 pcs2)
{
    if (pcs2)
    {
        PCOUNTRYSETTINGS pcs = &pcs2->cs;

        if (   (doshIsWarp4()==3)
            && (!fUniResolved)
           )
        {
            HMODULE hmodUCONV = NULLHANDLE,
                    hmodLIBUNI = NULLHANDLE;

            fUniResolved = TRUE;
            if (   (doshResolveImports("UCONV.DLL",
                                       &hmodUCONV,
                                       G_aResolveFromUCONV,
                                       sizeof(G_aResolveFromUCONV) / sizeof(G_aResolveFromUCONV[0]))
                    == NO_ERROR)
                && (doshResolveImports("LIBUNI.DLL",
                                       &hmodLIBUNI,
                                       G_aResolveFromLIBUNI,
                                       sizeof(G_aResolveFromLIBUNI) / sizeof(G_aResolveFromLIBUNI[0]))
                    == NO_ERROR)
               )
                fUniOK = TRUE;
        }

        if (   (doshIsWarp4()==3)       // V1.0.5 (2006-05-29) [pr]
            && fUniOK
           )
        {
            UconvObject         uconv_object;

            if (G_UniCreateUconvObject((UniChar *)L"",
                                       &uconv_object) == ULS_SUCCESS)
            {
                LocaleObject locale_object;

                if (G_UniCreateLocaleObject(UNI_UCS_STRING_POINTER,
                                            (UniChar *)L"",
                                            &locale_object) == ULS_SUCCESS)
                {
                    int i;
                    struct LOCALE_ITEMLIST
                    {
                        LocaleItem      lclItem;
                        PVOID           vTarget;
                        int             iType;
                    } itemList[] = {
                        { LOCI_iDate, &pcs->ulDateFormat, 1 },
                        { LOCI_iTime, &pcs->ulTimeFormat, 1 },
                        { LOCI_sDate, &pcs->cDateSep, 2 },
                        { LOCI_sTime, &pcs->cTimeSep, 2 },
                        { LOCI_sDecimal, &pcs->cDecimal, 2 },
                        { LOCI_sThousand, &pcs->cThousands, 2 }
                                   };

                    for (i = 0;
                         i < sizeof(itemList) / sizeof(itemList[0]);
                         i++)
                    {
                        UniChar *pItem;

                        if (G_UniQueryLocaleItem(locale_object,
                                                 itemList[i].lclItem,
                                                 &pItem) == ULS_SUCCESS)
                        {
                            int iLen = G_UniStrlen(pItem) + 1;
                            PSZ pszResult = (PSZ)malloc(iLen);

                            if (G_UniStrFromUcs(uconv_object,
                                                pszResult,
                                                pItem,
                                                iLen) == ULS_SUCCESS)
                            {
                                switch(itemList[i].iType)
                                {
                                    case 1:
                                        *((ULONG *) itemList[i].vTarget) = atol(pszResult);
                                        break;

                                    case 2:
                                        *((CHAR *) itemList[i].vTarget) = pszResult[0];
                                        break;

                                    case 3:
                                        strcpy ((PCHAR)(itemList[i].vTarget), pszResult);
                                        break;
                                }
                            }

                            free(pszResult);
                            G_UniFreeMem(pItem);
                        }
                    }

                    G_UniFreeLocaleObject(locale_object);
                }

                G_UniFreeUconvObject(uconv_object);
            }
        }
        else
        {
            pcs->ulDateFormat = PrfQueryProfileInt(HINI_USER,
                                                   (PSZ)PMINIAPP_NATIONAL,
                                                   "iDate",
                                                   0);
            pcs->ulTimeFormat = PrfQueryProfileInt(HINI_USER,
                                                   (PSZ)PMINIAPP_NATIONAL,
                                                   "iTime",
                                                   0);
            pcs->cDateSep = prfhQueryProfileChar(HINI_USER,
                                                 (PSZ)PMINIAPP_NATIONAL,
                                                 "sDate",
                                                 '/');
            pcs->cTimeSep = prfhQueryProfileChar(HINI_USER,
                                                 (PSZ)PMINIAPP_NATIONAL,
                                                 "sTime",
                                                 ':');
            pcs->cDecimal = prfhQueryProfileChar(HINI_USER,
                                                 (PSZ)PMINIAPP_NATIONAL,
                                                 "sDecimal",
                                                 '.');
            pcs->cThousands = prfhQueryProfileChar(HINI_USER,
                                                   (PSZ)PMINIAPP_NATIONAL,
                                                   "sThousand",
                                                   ',');
        }

        nlsGetAMPM(&pcs2->ampm);
    }
}
/* ******************************************************************** */
LONG EXPENTRY _export WAVEENTRY(PVOID pVoid,USHORT usMsg,LONG mp1,LONG mp2)  {
ULONG             lRC=MMIO_ERROR;
PWAVEIF           pWaveIF;
PMMIOINFO         pMMInfo;

PESCWAVEIF_LOCAL  pWaveIFLocal;
ULONG             i;
double            dbValue;
LONG              lSeekPos;

   pMMInfo=(PMMIOINFO)pVoid;

   switch(usMsg)  {
   /* ***************************************************************** */
   /* オープン                                                          */
   /* ***************************************************************** */
   case MMIOM_OPEN:
      if(!pMMInfo ) return MMIO_ERROR;
      pWaveIF=EscAllocMem(sizeof(WAVEIF));   
      if(!pWaveIF)   {
         pMMInfo->pExtraInfoStruct=NULL;
         return MMIO_ERROR;
      }
      memset(pWaveIF,0,sizeof(WAVEIF));
      pWaveIF->cbSize=sizeof(WAVEIF);
      pMMInfo->pExtraInfoStruct=(PVOID)pWaveIF;
      pWaveIFLocal=EscAllocMem(sizeof(ESCWAVEIF_LOCAL));
      if(!pWaveIFLocal)   {
         EscFreeMem(pWaveIF);
         pMMInfo->pExtraInfoStruct=NULL;
         return MMIO_ERROR;
      }
      memset(pWaveIFLocal, 0, sizeof(ESCWAVEIF_LOCAL));
      pWaveIF->pExInfo=pWaveIFLocal;
      pWaveIFLocal->ulReservedBufferSize=0L;
      pWaveIFLocal->lServiceFrontWavePos=0L;
      pWaveIFLocal->lServiceWavePos=0L;

      pWaveIFLocal->ulMaxBufferSize=PrfQueryProfileInt(HINI_USER, "LLWAVEIF", "BUFFER", 4000L); /* 省略時4MB */
      if(pWaveIFLocal->ulMaxBufferSize<100)  pWaveIFLocal->ulMaxBufferSize=100;
      /* 極小バッファ */
      if(mp2&WAVEIF_OPEN_CELBUFFER) {
         pWaveIFLocal->ulMaxBufferSize=200;
      }
      pWaveIFLocal->ulMaxBufferSize*=1000L;
      pWaveIF->mmAudioHdr.mmXWAVHeader.WAVEHeader.ulSamplesPerSec=(mp2&WAVEIF_OPEN_SPS_MASK)>>WAVEIF_OPEN_SPS_SHIFT;
      pWaveIF->mmAudioHdr.mmXWAVHeader.WAVEHeader.usBitsPerSample=(mp2&WAVEIF_OPEN_BIT_MASK)>>WAVEIF_OPEN_BIT_SHIFT;
      pWaveIF->mmAudioHdr.mmXWAVHeader.WAVEHeader.usChannels=(mp2&WAVEIF_OPEN_CH_MASK)>>WAVEIF_OPEN_CH_SHIFT;
      ClcWaveInfoFromBasicInfo(&pWaveIF->mmAudioHdr, 0);

      pWaveIFLocal->usMaxBuffers=2;
      memset ( &pWaveIFLocal->AmpOpenParms, '\0', sizeof ( MCI_AMP_OPEN_PARMS ) );
      pWaveIFLocal->AmpOpenParms.usDeviceID = ( USHORT ) 0;
      pWaveIFLocal->AmpOpenParms.pszDeviceType = ( PSZ ) MCI_DEVTYPE_AUDIO_AMPMIX;
      if(mciSendCommand( 0, MCI_OPEN, MCI_WAIT|MCI_OPEN_TYPE_ID|MCI_OPEN_SHAREABLE,(PVOID)&pWaveIFLocal->AmpOpenParms, 0)) {
         EscFreeMem(pWaveIFLocal);
         EscFreeMem(pWaveIF);
         pMMInfo->pExtraInfoStruct=NULL;
         return 7;
      }
      memset( &pWaveIFLocal->MixSetupParms, '\0', sizeof( MCI_MIXSETUP_PARMS ) );
      pWaveIFLocal->MixSetupParms.ulDeviceType = MCI_DEVTYPE_WAVEFORM_AUDIO;
      pWaveIFLocal->MixSetupParms.ulFormatTag  = 1L;
      pWaveIFLocal->MixSetupParms.ulSamplesPerSec = pWaveIF->mmAudioHdr.mmXWAVHeader.WAVEHeader.ulSamplesPerSec;
      pWaveIFLocal->MixSetupParms.ulBitsPerSample = pWaveIF->mmAudioHdr.mmXWAVHeader.WAVEHeader.usBitsPerSample;
      pWaveIFLocal->MixSetupParms.ulChannels      = pWaveIF->mmAudioHdr.mmXWAVHeader.WAVEHeader.usChannels;
      pWaveIFLocal->MixSetupParms.pmixEvent    = WAVEEVENT;
      pWaveIFLocal->MixSetupParms.ulFormatMode = MCI_PLAY;
      if(mciSendCommand( pWaveIFLocal->AmpOpenParms.usDeviceID, MCI_MIXSETUP, MCI_WAIT|MCI_MIXSETUP_INIT,(PVOID)&pWaveIFLocal->MixSetupParms,0))   {
         EscFreeMem(pWaveIFLocal);
         EscFreeMem(pWaveIF);
         pMMInfo->pExtraInfoStruct=NULL;
         return 8;
      }
      pWaveIFLocal->BufferParms.ulNumBuffers = pWaveIFLocal->usMaxBuffers+2;
      pWaveIFLocal->BufferParms.ulBufferSize = pWaveIFLocal->MixSetupParms.ulBufferSize;
      pWaveIFLocal->BufferParms.pBufList = pWaveIFLocal->MixBuffers;
      if(mciSendCommand( pWaveIFLocal->AmpOpenParms.usDeviceID, MCI_BUFFER, MCI_WAIT|MCI_ALLOCATE_MEMORY,(PVOID)&pWaveIFLocal->BufferParms, 0)) {
         EscFreeMem(pWaveIFLocal);
         EscFreeMem(pWaveIF);
         pMMInfo->pExtraInfoStruct=NULL;
         return 9;
      }
      pWaveIFLocal->Index=0L;

      for(i=0;i<MAX_DATAS;i++)   {
         pWaveIFLocal->pBuffer[i]=NULL;
         pWaveIFLocal->ulBufferSize[i]=0L;
      }
      pWaveIFLocal->ulBufferEnable=0L;
      pWaveIFLocal->ulBufferSelect=0L;
      pWaveIFLocal->ulBufferPos=0L;

      for(i=0L;i<pWaveIFLocal->usMaxBuffers;i++)   {
         pWaveIFLocal->MixBuffers[i].ulUserParm=(ULONG)pWaveIF;
         memset( pWaveIFLocal->MixBuffers[i].pBuffer, 0 , pWaveIFLocal->BufferParms.ulBufferSize );
         pWaveIFLocal->MixBuffers[i].ulBufferLength = pWaveIFLocal->BufferParms.ulBufferSize;
         pWaveIFLocal->lServiceWavePos-=pWaveIFLocal->MixBuffers[i].ulBufferLength;

      }
      pWaveIFLocal->MixBuffers[pWaveIFLocal->BufferParms.ulNumBuffers-1].ulFlags = MIX_BUFFER_EOS;
      pWaveIFLocal->MixSetupParms.pmixWrite( pWaveIFLocal->MixSetupParms.ulMixHandle, pWaveIFLocal->MixBuffers, pWaveIFLocal->usMaxBuffers );

      lRC=MMIO_SUCCESS;
      break;
   /* ***************************************************************** */
   /* クローズ                                                          */
   /* ***************************************************************** */
   case MMIOM_CLOSE:
      if(!pMMInfo || !pMMInfo->pExtraInfoStruct) return MMIO_ERROR;
      pWaveIF=pMMInfo->pExtraInfoStruct;

      if(pWaveIF) {
         pWaveIFLocal=pWaveIF->pExInfo;
         if(pWaveIFLocal) {
            mciSendCommand( pWaveIFLocal->AmpOpenParms.usDeviceID, MCI_STOP,MCI_WAIT, (PVOID)&pWaveIFLocal->GenericParms, 0);
            mciSendCommand( pWaveIFLocal->AmpOpenParms.usDeviceID, MCI_MIXSETUP, MCI_WAIT | MCI_MIXSETUP_DEINIT, (PVOID)&pWaveIFLocal->MixSetupParms, 0);
            pWaveIFLocal->MixSetupParms.ulFormatMode = MCI_PLAY;
            mciSendCommand( pWaveIFLocal->AmpOpenParms.usDeviceID, MCI_MIXSETUP, MCI_WAIT|MCI_MIXSETUP_INIT, (PVOID)&pWaveIFLocal->MixSetupParms, 0);
            mciSendCommand( pWaveIFLocal->AmpOpenParms.usDeviceID, MCI_BUFFER,MCI_WAIT|MCI_DEALLOCATE_MEMORY, (PVOID)&pWaveIFLocal->BufferParms, 0);
            mciSendCommand( pWaveIFLocal->AmpOpenParms.usDeviceID, MCI_CLOSE,MCI_WAIT, (PVOID)&pWaveIFLocal->GenericParms, 0);
            for(i=0;i<MAX_DATAS;i++)   {
               if(pWaveIFLocal->ulBufferSize[i])   {
                  EscFreeMem(pWaveIFLocal->pBuffer[i]);
                  pWaveIFLocal->pBuffer[i]=NULL;
                  pWaveIFLocal->ulBufferSize[i]=0L;
               }
            }
            EscFreeMem(pWaveIFLocal);
         }
         memset(pWaveIF,0,sizeof(WAVEIF));
         EscFreeMem(pWaveIF);
         pMMInfo->pExtraInfoStruct=NULL;
      }
      lRC=MMIO_SUCCESS;
      break;
   /* ***************************************************************** */
   /* CLEAR                                                             */
   /* ***************************************************************** */
   case WAVEIF_CLEAR:
      if(!pMMInfo || !pMMInfo->pExtraInfoStruct) return 0;
      pWaveIF=pMMInfo->pExtraInfoStruct;
      pWaveIFLocal=pWaveIF->pExInfo;
      if(!pWaveIFLocal)   return 0L;
      pWaveIFLocal->fClear=TRUE;

      i=0;
      while(pWaveIFLocal->fClear&&i<40)   {
         DosSleep(100);
         i++;
      }
      
      pWaveIFLocal->fClear=FALSE;
      break;
   /* ***************************************************************** */
   /* GET STATUS                                                        */
   /* ***************************************************************** */
   case WAVEIF_GETSTATUS:
      switch(mp1&0x0000FFFFL) {
      case WAVEIF_STATUS_SELECT_STANDARD:
         lRC=WAVEIF_STATUS;
      }
      break;
   /* ***************************************************************** */
   /* このサービスのフォーマット情報を返す                              */
   /* ***************************************************************** */
   case MMIOM_GETFORMATINFO:
      lRC=EscInsertGetFormatInfo((PMMFORMATINFO)mp1);
      break;
   /* ***************************************************************** */
   /* このサービスのフォーマット名を返す                                */
   /* ***************************************************************** */
   case MMIOM_GETFORMATNAME:
      lRC=EscInsertGetFormatName((PCHAR)mp1,mp2);
      break;
   /* ***************************************************************** */
   /* ヘッダを読みとる                                                  */
   /* ***************************************************************** */
   case MMIOM_GETHEADER:
      lRC=0L;
      break;
   /* ***************************************************************** */
   /* ヘッダを書き込む                                                  */
   /* ***************************************************************** */
   case MMIOM_SETHEADER:
      lRC=0L;
      break;
   /* ***************************************************************** */
   /* ヘッダサイズを返す                                                */
   /* ***************************************************************** */
   case MMIOM_QUERYHEADERLENGTH:
      lRC=sizeof(WAVEIF);
      break;
   /* ***************************************************************** */
   /* 位置収得(転送されたデーターは、すべてメモリ上にあるので収得可能)  */
   /* ***************************************************************** */
   case WAVEIF_GETPOSITION:
      if(!pMMInfo || !pMMInfo->pExtraInfoStruct) return 0;
      pWaveIF=pMMInfo->pExtraInfoStruct;
      pWaveIFLocal=pWaveIF->pExInfo;
      if(!pWaveIFLocal)   return 0L;

      switch(mp2) {
      case SEEK_CUR:
         lSeekPos=pWaveIFLocal->lServiceWavePos+mp2;
         break;
      default:
      case SEEK_SET:
         lSeekPos=mp2;
         break;
      case SEEK_END:
         lSeekPos=pWaveIFLocal->lServiceFrontWavePos-mp2;
         break;
      }
      lRC=lSeekPos;
      break;
   /* ***************************************************************** */
   /* 時間位置収得                                                      */
   /* ***************************************************************** */
   case WAVEIF_GETTIME:
      if(!pMMInfo || !pMMInfo->pExtraInfoStruct) return 0;
      pWaveIF=pMMInfo->pExtraInfoStruct;
      pWaveIFLocal=pWaveIF->pExInfo;
      if(!pWaveIFLocal)   return 0L;

      switch(mp2) {
      case SEEK_CUR:
         lSeekPos=pWaveIFLocal->lServiceWavePos+mp1;
         break;
      default:
      case SEEK_SET:
         lSeekPos=mp1;
         break;
      case SEEK_END:
         lSeekPos=pWaveIFLocal->lServiceFrontWavePos-mp1;
         break;
      }
      if(lSeekPos<0) lSeekPos=0;
      dbValue=(double)
         pWaveIF->mmAudioHdr.mmXWAVHeader.WAVEHeader.ulSamplesPerSec*
         pWaveIF->mmAudioHdr.mmXWAVHeader.WAVEHeader.usBitsPerSample*
         pWaveIF->mmAudioHdr.mmXWAVHeader.WAVEHeader.usChannels/(double)8000;
      if(dbValue<1)  return 0L;
      lSeekPos/=dbValue;

      lRC=lSeekPos;
      break;
   /* ***************************************************************** */
   /* 書き込み(アプリ側からみて)                                        */
   /* ***************************************************************** */
   case MMIOM_WRITE:
      if(!pMMInfo || !pMMInfo->pExtraInfoStruct) return MMIO_ERROR;
      pWaveIF=pMMInfo->pExtraInfoStruct;
      if(!mp1 || !mp2)  return 0L;
      pWaveIFLocal=pWaveIF->pExInfo;
      if(pWaveIFLocal->ulMaxBufferSize<pWaveIFLocal->ulReservedBufferSize) {
         return 0L;
      }
      if(pWaveIFLocal->fClear)   return 0L;

      i=pWaveIFLocal->ulBufferEnable;
      if(i+1>=MAX_DATAS)   {
         if(0==pWaveIFLocal->ulBufferSelect)  {
            return 0L;
         }
      }  else  {
         if(i+1==pWaveIFLocal->ulBufferSelect)  {
            return 0L;
         }
      }
      pWaveIFLocal->pBuffer[i]=(PCHAR)mp1;
      pWaveIFLocal->ulBufferSize[i]=(ULONG)mp2;
      pWaveIFLocal->lServiceFrontWavePos+=pWaveIFLocal->ulBufferSize[i];
      pWaveIFLocal->ulReservedBufferSize+=pWaveIFLocal->ulBufferSize[i];
      i++;
      if(i>=MAX_DATAS)   i=0;
      pWaveIFLocal->ulBufferEnable=i;

      lRC=mp2;
      break;
   /* ***************************************************************** */
   /* その他                                                            */
   /* ***************************************************************** */
   default: 
      lRC=MMIOERR_UNSUPPORTED_MESSAGE;
      break;
   }  /* end of switch */
return lRC; }
/*����������������������������������������������������������������������������*/
BOOL ReadSpyINI(HWND      hFrame,   /* HWND(Agent's frame) */
                LONG      Agent,    /* one-origin "agent" */
                PINI_DATA pIni)     /* INI data to read */
{
  CHAR szAgent[32];

  HINI hINI          = NULLH;
  BOOL bOK           = BOOL_FALSE;

  /*������������������������������������������������������������������������Ŀ*/
  /*� Set the INI data to 'default' values...                                �*/
  /*�                                                                        �*/
  /*�                                                                        �*/
  /*� - list font                                                            �*/
  /*�                                                                        �*/
  /*� - window position:  x  = left edge                                     �*/
  /*�                     y  = above bottom row of icons                     �*/
  /*�                     cX = 6/10 screen width                             �*/
  /*�                     cY = 4/10 screen height                            �*/
  /*��������������������������������������������������������������������������*/
  memset(pIni, 0, sizeof(*pIni) );

  strcpy(pIni->szListFont, szDefFont);
  strcpy(pIni->szLog,      szDefLog);
  strcpy(pIni->szProfile,  szDefProfile);

  pIni->swpAgent.x  = 0;

  pIni->swpAgent.y  = (SHORT)
                      (WinQuerySysValue(HWND_DESKTOP, SV_CYICON)      *2);

  pIni->swpAgent.cx = (SHORT)
                      (WinQuerySysValue(HWND_DESKTOP, SV_CXFULLSCREEN)*6)/10;

  pIni->swpAgent.cy = (SHORT)
                      (WinQuerySysValue(HWND_DESKTOP, SV_CYFULLSCREEN)*4)/10;

  /*������������������������������������������������������������������������Ŀ*/
  /*� Open the PMSPY "profile"                                               �*/
  /*��������������������������������������������������������������������������*/
  if ( (hINI = PrfOpenProfile( WinQueryAnchorBlock(hFrame),
                               szINI)) != NULLH )
  {
    /*����������������������������������������������������������������������Ŀ*/
    /*� Determine which "agent" this data is for                             �*/
    /*������������������������������������������������������������������������*/
    sprintf(szAgent, Strings[IDS_FMT_AGENT], Agent);

    /*����������������������������������������������������������������������Ŀ*/
    /*� Read Agent's previous FONT                                           �*/
    /*������������������������������������������������������������������������*/
    PrfQueryProfileString(hINI,
                          szAgent,
                          szKeyFont,
                          pIni->szListFont,           /* default */
                          pIni->szListFont,           /* target & size */
                          (LONG)sizeof(pIni->szListFont) );

    /*����������������������������������������������������������������������Ŀ*/
    /*� Read Agent's previous LOG                                            �*/
    /*������������������������������������������������������������������������*/
    PrfQueryProfileString(hINI,
                          szAgent,
                          szKeyLog,
                          pIni->szLog,                /* default */
                          pIni->szLog,                /* target & size */
                          (LONG)sizeof(pIni->szLog) );

    /*����������������������������������������������������������������������Ŀ*/
    /*� Read Agent's previous PROfile                                        �*/
    /*������������������������������������������������������������������������*/
    PrfQueryProfileString(hINI,
                          szAgent,
                          szKeyPro,
                          pIni->szProfile,            /* default */
                          pIni->szProfile,            /* target & size */
                          (LONG)sizeof(pIni->szProfile) );

    /*����������������������������������������������������������������������Ŀ*/
    /*� Read Agent's previous WINDOW POSITION                                �*/
    /*������������������������������������������������������������������������*/
    pIni->swpAgent.x  = PrfQueryProfileInt(hINI,
                                           szAgent,
                                           szKeyPosX,
                                           pIni->swpAgent.x);   /* default */

    pIni->swpAgent.y  = PrfQueryProfileInt(hINI,
                                           szAgent,
                                           szKeyPosY,

                                           pIni->swpAgent.y);   /* default */
    pIni->swpAgent.cx = PrfQueryProfileInt(hINI,
                                           szAgent,
                                           szKeySizeCX,
                                           pIni->swpAgent.cx);  /* default */

    pIni->swpAgent.cy = PrfQueryProfileInt(hINI,
                                           szAgent,
                                           szKeySizeCY,
                                           pIni->swpAgent.cy);  /* default */

    /*����������������������������������������������������������������������Ŀ*/
    /*� Close the PMSPY "profile"                                            �*/
    /*������������������������������������������������������������������������*/
    PrfCloseProfile(hINI);

    bOK = BOOL_TRUE;
  }

  return( bOK );
}