int         main( void)

{
    HAB     hab = 0;
    HMQ     hmq = 0;
    HWND    hwnd = 0;
    int     nRtn = 8;
    QMSG    qmsg;

do
{
    Morph();

    hab = WinInitialize( 0);
    if (!hab)
        break;

    hmq = WinCreateMsgQueue( hab, 0);
    if (!hmq)
        break;

    // avoid compatibility problems
    // RWSFULLVERSION for RwsTest v0.80 is 0x08000100
    if (RwsQueryVersion( 0) < RWSFULLVERSION) {
        WinMessageBox( HWND_DESKTOP, 0,
                       "Please use a newer version of the RWS08 dlls",
                       "FPos", 1, MB_OK | MB_ERROR | MB_MOVEABLE);
        break;
    }

    hwnd = WinLoadDlg(
                HWND_DESKTOP,               //  parent-window
                NULLHANDLE,                 //  owner-window
                MainWndProc,                //  dialog proc
                NULLHANDLE,                 //  EXE module handle
                IDD_MAIN,                   //  dialog id
                NULL);                      //  pointer to create params

    if (!hwnd)
        break;

    while (WinGetMsg( hab, &qmsg, NULLHANDLE, 0, 0))
        WinDispatchMsg( hab, &qmsg);

    nRtn = 0;

} while (fFalse);

    if (nRtn)
        DosBeep( 440, 150);

    if (hwnd)
        WinDestroyWindow( hwnd);
    if (hmq)
        WinDestroyMsgQueue( hmq);
    if (hab)
        WinTerminate( hab);

    return (nRtn);
}
//
// Make Warning Beep If Option Is Enabled
//
void WarnBeep(void)
{
	if(UserSetup.WarnBeep)
	{
		DosBeep(750,125);
	}
}
VOID Krnl_Debug_Bzz( VOID )
{
 // Звук.
 DosBeep( 50, 50 );

 // Возврат.
 return;
}
Example #4
0
void shutdown(HFILE com)
{
  HAB		hAnchorBlock;
  ULONG		ulRetCode;
  ULONG		ulSendResult;
  HMQ		hMsgQWindow;
  QMSG		rMsgQWin;
  QMSG		rMsgDESK;
  int 		x;

  if ((hAnchorBlock = WinInitialize(0)) == NULLHANDLE)
    return;
  if ((hMsgQWindow = WinCreateMsgQueue(hAnchorBlock, 0)) == NULLHANDLE)
    return;
  rMsgDESK.hwnd = HWND_DESKTOP;
  rMsgDESK.msg = 0;
  rMsgDESK.mp1 = MPVOID;
  rMsgDESK.mp2 = MPVOID;
  rMsgDESK.time = 0;
  rMsgDESK.reserved = 0;
  ulSendResult = WinBroadcastMsg(HWND_DESKTOP,
				 WM_SYSCOMMAND,
				 MPFROMSHORT(SC_CLOSE),
				 MPFROM2SHORT(CMDSRC_MENU,FALSE),
				 (ULONG) BMSG_FRAMEONLY);

  for (int i=0; i < 60; i++)	// One minute for a clean stop of all programs
  {
    x = CheckState(com);
    if (x != state) state = x;
    if (state == 0) { counter = COUNT_INIT; return; };
    if (state == 2) break;
    DosSleep(1000);
  }

  DosBeep(4000, 100);
  DosBeep(3000, 100);
  DosBeep(2000, 100);
  DosBeep(1000, 100);
  DosShutdown(0);
  UPSPowerOff(com);
  WinDestroyMsgQueue(hMsgQWindow);
  WinTerminate(hAnchorBlock);
  return;
}
Example #5
0
/* --------------------------------------------------------------------------
 Display a menu of choices, returning the ordinal (0 based) of the selected
 choice.
- Parameters -------------------------------------------------------------
 INT iRow      : line position (0 = top of screen, -1 = current position).
 PSZ pszPrompt : prompt message.
 PSZ choices   : array of choice characters (max 5 characters).
 PMENUFN pfunc : optional callback function used when the menu has a
                 'retry' item. When pfunc() returns FALSE the loop is
                 terminated.
 PVOID pparm   : optional pfunc() parameters.
- Return value -----------------------------------------------------------
 ULONG : number of the selected choice.
- Note: ------------------------------------------------------------------
 If pszPrompt is NULL the area where the prompt message is printed is
 cleared and no other action is performed.
-------------------------------------------------------------------------- */
ULONG showMenu(PSZ pszPrompt, PSZ choices) {
   CHAR achscr[1760];
   CHAR achmenu[1760];
   CHAR buf[4];
   ULONG key;
   USHORT row, col, irow, cb;
   PSZ pChoice, pLine, pEnd;

   buf[0] = ' ';
   buf[1] = VIOB_GRAY | VIOF_DARKBLUE;
   DosBeep(220, 50);
   DosBeep(440, 50);
   DosBeep(880, 50);
   cb = sizeof(achscr);
   VioReadCellStr(achscr, &cb, 7, 0, 0);
   VioScrollUp(7, 0, 17, 80, 11, buf, 0);
   sprintf(achmenu, pszPrompt,
           choices[0], choices[1], choices[2], choices[3], choices[4]);
   VioGetCurPos(&row, &col, 0);
   for (pLine = pEnd = achmenu, irow = 8; pEnd; ++irow)
   {
      if (NULL != (pEnd = strchr(pLine, '\r')))
      {
         *pEnd = '\0';
         if (*++pEnd == '\n') ++pEnd;
      }
      // skip empty lines
      if (*pLine)
         VioWrtCharStrAtt(pLine, strlen(pLine), irow, 0, buf + 1, 0);
      pLine = pEnd;
   }
   VioSetCurPos(irow, 0, 0);
//   VioWrtCharStrAtt(pszPrompt, strlen(pszPrompt), 8, 0, buf + 1, 0);
   for (;;)
   {
      key = kbdKeyChar(kbdKey()) & ~0x20;
      if (NULL != (pChoice = strchr(choices, (INT)key)))
         break;
      DosBeep(440, 100);
   }
   VioWrtCellStr(achscr, cb, 7, 0, 0);
   VioSetCurPos(row, col, 0);
   return (ULONG)(pChoice - choices);
}
BOOL MenuSample::OCommand(ULONG msg, MPARAM mp1, MPARAM mp2)
{
 switch(msg)
  {
   case WM_COMMAND:
     switch(SHORT1FROMMP(mp1))
      {
       case MENU_MENU_QUIT:
        WinSendMsg(hwnd, WM_CLOSE, NULL, NULL);
        break;

       case MENU_CHECK:
        if (menu->isChecked(MENU_CHECK))
          {
           menu->checkItem(MENU_CHECK, FALSE);
           menu->setItemText(MENU_CHECK, TEXT_UNCHECKED);
          }  
        else 
          {
           menu->checkItem(MENU_CHECK, TRUE);
           menu->setItemText(MENU_CHECK, TEXT_CHECKED);
          } 
        break; 

       case MENU_DISABLE:
        if (menu->isEnabled(MENU_DISABLE))
          {
           menu->enableItem(MENU_DISABLE, FALSE);
           menu->setItemText(MENU_DISABLE, TEXT_DISABLED);
          }  
        else 
          {
           menu->enableItem(MENU_DISABLE, TRUE);
           menu->setItemText(MENU_DISABLE, TEXT_ENABLED);
          } 
        break; 

       default:
        DosBeep(100, 100);
        break;
      }
     break;

   case WM_CLOSE:
     WinPostMsg(hwnd, WM_QUIT, NULL, NULL);
     break;

   default:
     return(FALSE);
  }
 return(TRUE);
#ifdef __BCPLUSPLUS__
  #pragma warn -par
#endif
}
Example #7
0
void LogEvent( char* format, ... )
{
  char* LogDir;
  va_list ap;
  FILE* f;

  if ( g_CheckedEnvironment )
  {
    if ( g_LogFilePath == NULL )
      /* logging is not enabled */
      return;
  }
  else
  {
    /* check the environment var to see if logging is enabled */
    g_CheckedEnvironment = 1;
    LogDir = getenv( LOG_DIR_VAR );
    if ( LogDir == NULL )
      /* not defined */
      return;
    if ( strlen( LogDir ) == 0 )
      /* defined as blank? */
      return;

    /* allocate space for full path, plus slash, plus terminator */
    g_LogFilePath = malloc( strlen( LogDir ) + strlen( LOG_FILENAME ) + 2 );
    if ( g_LogFilePath == NULL )
      /* out of memory */
      return;

   /* copy path */
    strcpy( g_LogFilePath, LogDir );

    /* add ending slash if needed */
    if ( g_LogFilePath[ strlen( g_LogFilePath ) - 1 ] != '\\' )
      strcat( g_LogFilePath, "\\" );

    /* add filename */
    strcat( g_LogFilePath, LOG_FILENAME );
  }

  f = fopen( g_LogFilePath, "a" );
  if ( f == NULL )
  {
    DosBeep( 2000, 50 );
    printf( "fopen failed, errno %d: %s", errno, strerror( errno ) );
    return;
  }

  va_start( ap, format );
  vfprintf( f, format, ap );
  fprintf( f, "\n" );
  fclose( f );
  va_end( ap );
}
Example #8
0
File: gvpmisc.c Project: 131/gsview
void
play_sound(int num)
{
	if (strlen(sound[num].file)==0)
	    return;
	if (!(pfnMciPlayFile) || (strcmp(sound[num].file,BEEP)==0)) {
	    DosBeep(200,200);
	    return;
	}
	if (isdigit((int)(*sound[num].file)))
	    play_system_sound(sound[num].file);
	else {
	    char buf[MAXSTR];
	    buf[0] = '\042';
	    strcpy(buf+1, sound[num].file);
	    strcat(buf, "\042");
	    if ((*pfnMciPlayFile)(hwnd_frame, (PSZ)buf, 0, 0, 0))
	        DosBeep(200,200);
	}
}
ULONG   User_Error(HWND hwndOwner, ULONG ulWindow, ULONG ulStyle, UCHAR *pucMsg, PSZ pszErrMod, LONG lErrLine)
{
USHORT      usResponse;                 /* Message box return value */

if(!pucMsg) pucMsg="Debug Information"; /* If no special test is given, assume debugging */
                                        /* For query dialogs, don't include the (debugging) module and
                                           linenumber information (note: MB_QUERY equals MB_ICONQUESTION) */
if((ulStyle & MB_INFORMATION)==MB_QUERY)
    strcpy(ErrBuffer, pucMsg);
else
    sprintf(ErrBuffer, "%s\n\nModule: %s\nLinenumber: %ld\n",
        pucMsg, pszErrMod, lErrLine);
memset(Titlebar, ' ', TITLEBAR_LENGTH);
Titlebar[TITLEBAR_LENGTH-1]='\0';
memcpy(Titlebar, "PC/2: User Information", sizeof("PC/2: User Information")-1);
                                        /* If the user requested not to be prompted, don't display the
                                           message if it is just an informational one (in the future we
                                           might log to file) */
if((pHP!=NULL) && (pHP->ulRuntimeFlag & NOPROMPT))
    { 
    if((ulStyle & MB_INFORMATION)==MB_QUERY)
        return(MBID_YES);
    if((ulStyle & MB_INFORMATION)==MB_INFORMATION)
        return(MB_OK);
    }
                                        /* Unfortunately, MB_INFORMATION equals MB_ICONQUESTION|MB_ICONEXCLAMATION,
                                           which is quite a silly */
if((ulStyle & MB_INFORMATION)==MB_INFORMATION)
    {
                                        /* Signal to user via speaker */
    if((pHP!=NULL) && !(pHP->ulRuntimeFlag & NOPROMPT))
        {
        DosBeep(1000,100);
        DosBeep(300,100);
        DosBeep(1000,200);
        }
    }
usResponse=WinMessageBox(HWND_DESKTOP, hwndOwner, (PSZ)ErrBuffer,
    Titlebar, (USHORT)ulWindow, (USHORT)ulStyle);
return(usResponse);
}
Example #10
0
static void DoBeep( void )
/************************/
{
#if defined( __WINDOWS__ ) || defined( __NT__ )
    MessageBeep( 0 );
#elif defined( __OS2__ )
    DosBeep( 750, 250 );
#else
    putchar( 7 );
    fflush( stdout );
#endif
}
Example #11
0
extern void Ring( void )
/**********************/
{
#if defined( __DOS__ )
    DoRingBell();
#elif defined( __WINDOWS__ ) || defined( __NT__ )
    MessageBeep( 0 );
#elif defined( __QNX__ ) || defined( __LINUX__ )
    write( STDOUT_FILENO, "\a", 1 );
#elif defined( __OS2__ )
    DosBeep( 1000, 250 );
#endif
}
Example #12
0
/*
 * main - main entry point for PM
 */
int main( int argc, char *argv[] )
{
    HMQ         hmq;
    QMSG        qmsg;
    HAB         hab;

    hab = WinInitialize( 0 );
    if(!hab) {
        DosBeep(BEEP_WARN_FREQ, BEEP_WARN_DUR);
        DosExit(EXIT_PROCESS, RETURN_ERROR);
    }

    hmq = WinCreateMsgQueue( hab, 0 );
    if(!hmq) {
        DosBeep(BEEP_WARN_FREQ, BEEP_WARN_DUR);
        WinTerminate(hab);
        DosExit(EXIT_PROCESS, RETURN_ERROR);
    }

    if( !imgEditInit( hab ) ) {
        DosBeep(BEEP_WARN_FREQ, BEEP_WARN_DUR);
        WinTerminate(hab);
        DosExit(EXIT_PROCESS, RETURN_ERROR);
    }

    IEEnableMenuInput( TRUE );

    if( argc > 1 ) {
        parseCmdLine( argc, argv );
    }

    while ( WinGetMsg(hab, &qmsg, 0, 0, 0) ) {
        WinDispatchMsg( hab, &qmsg );
    }

    imgeditFini( hmq );

    return 0;
} /* main */
Example #13
0
//==============================================================================
// APIError -- report an error to the user as returned from an API service.
//             This function is provided mainly as a debugging tool to report
//             API errors to the user during runtime
//==============================================================================
VOID APIError(HWND hwndFrame,HWND hwndClient)
{
      PERRINFO pErrInfoBlk;
      PSZ      pszOffSet;
      void     stdprint(void);
      PSZ      pszErrMsg;

      DosBeep(100,10);
      DosBeep(440,110);
      if ((pErrInfoBlk = WinGetErrorInfo(Main::hab)) != NULL)
      {
        pszOffSet = ((PSZ)pErrInfoBlk) + pErrInfoBlk->offaoffszMsg;
        pszErrMsg = ((PSZ)pErrInfoBlk) + *((PSHORT)pszOffSet);
        if (hwndFrame && hwndClient)
            // if our window made it as far as definition, make the error window
            // owner be our application
            WinMessageBox(HWND_DESKTOP,      // Parent window is desk top
                       hwndFrame,            // Owner window is our frame
                       (PSZ)pszErrMsg,       // PMWIN Error message
                       "API Error Message",  // Title bar message
                       64,                   // Message identifier
                       MB_MOVEABLE | MB_CUACRITICAL | MB_CANCEL ); // Flags
        else
            // if our window errored in the definition part, make the desktop
            // the owner of the error box (since we have no window to own it!)
            WinMessageBox(HWND_DESKTOP,      // Parent window is desk top
                       HWND_DESKTOP,         // Owner window is desktop
                       (PSZ)pszErrMsg,       // PMWIN Error message
                       "API Error Message",  // Title bar message
                       64,                   // Message identifier
                       MB_MOVEABLE | MB_CUACRITICAL | MB_CANCEL ); // Flags
        // Discard the saved error info once we have used it
        WinFreeErrorInfo(pErrInfoBlk);
      }
      // upon fatal error, shutdown our application
      WinPostMsg(hwndClient, WM_QUIT, (ULONG)0, (ULONG)0);
}
Example #14
0
VOID DispErrorMsg(HAB hab, HWND hwndFrame, PCH FileName, LONG LineNum)
{
    PERRINFO  pErrInfoBlk;
    PSZ       pszOffSet, pszErrMsg;
    ERRORID   ErrorId;
    PCH       ErrorStr;
    CHAR      szbuff[125];

    DosBeep(800,10);
#if defined(DEBUG)
    DosBeep(800,10);
    DosBeep(800,10);
    DosBeep(800,10);
    DosBeep(800,10);
    DosBeep(800,10);
#endif   /* defined(DEBUG) */

    if (!hab)
    {                                     /* Non-PM Error */
	WinLoadString( habMain,0, IDS_UNKNOWNMSG, sizeof(szbuff), (PSZ)szbuff);
	ErrorStr = (char*) malloc(strlen(szbuff)+strlen(FileName)+10);
	sprintf(ErrorStr, szbuff, FileName, LineNum);
	WinMessageBox(HWND_DESKTOP,         /* Parent window is desk top */
		      hwndFrame,            /* Owner window is our frame */
		      (PSZ)ErrorStr,        /* PMWIN Error message       */
		      szErrorTitle,         /* Title bar message         */
		      MSGBOXID,             /* Message identifier        */
		      MB_MOVEABLE | MB_CUACRITICAL | MB_CANCEL ); /* Flags */
	free(ErrorStr);
	return;
    }

    ErrorId = WinGetLastError(hab);

    if ((pErrInfoBlk = WinGetErrorInfo(hab)) != (PERRINFO)NULL)
    {
	pszOffSet = ((PSZ)pErrInfoBlk) + pErrInfoBlk->offaoffszMsg;
	pszErrMsg = ((PSZ)pErrInfoBlk) + *((PULONG)pszOffSet);

	WinLoadString( habMain,0, IDS_ERRORMSG, sizeof(szbuff), (PSZ)szbuff);
	ErrorStr = (char *)malloc(strlen(szbuff)+strlen(pszErrMsg)+strlen(FileName)+10);
	sprintf(ErrorStr, szbuff, pszErrMsg, FileName, LineNum);

	WinMessageBox(HWND_DESKTOP,         /* Parent window is desk top */
		      hwndFrame,            /* Owner window is our frame */
		      (PSZ)ErrorStr,        /* PMWIN Error message       */
		      szErrorTitle,         /* Title bar message         */
		      MSGBOXID,             /* Message identifier        */
		      MB_MOVEABLE | MB_CUACRITICAL | MB_CANCEL ); /* Flags */

	free(ErrorStr);

	WinFreeErrorInfo(pErrInfoBlk);
    }


}
void cdecl main(int argc,char **argv)  {
   int         rc;
   rc=VioGlobalReg("GVIOSPY","VIOSERVICE",
                   VR_VIOWRTNCHAR | VR_VIOWRTNATTR | VR_VIOWRTNCELL | VR_VIOWRTTTY |
                   VR_VIOWRTCHARSTR | VR_VIOWRTCHARSTRATT | VR_VIOWRTCELLSTR |
                   VR_VIOSCROLLUP | VR_VIOSCROLLDN | VR_VIOSCROLLLF | VR_VIOSCROLLRT |
                   VR_VIOSETCURPOS | VR_VIOSHOWBUF
                   ,
                   0L,0L);
   if (rc!=0) {
      printf("Register Failed rc=%d\n",rc);
      exit(rc);
      return;
   } else DosBeep(400,50);
}
Example #16
0
int GetKeystroke2( void )
{    
    int code, type;
   for(;;) 
   {
     Kbd_Wait();
     type=Kbd_GetType();
     code=Kbd_GetCode();
     if (type==KBD_ASCII)
     {
         DosBeep(400,400);
         continue;
     }  else break;
   }   
   return code;
}      
int main (int argc, char *argv[])
{
  HAB  hab;
  HMQ  hmq;
  QMSG qmsg;
  char text[CCHMAXPATH];
  char title[CCHMAXPATH];
  short a;
  HWND hwndClient;
  ULONG result;
  ULONG rc;

  /* Create a copy of the args */
  /* argv[0]: progname
     argv[1]: installdir
     argv[2]: 0: query wave, 1: query mp3
     argv[3]: wavefile
   */
  numArgs=argc;
  
  hab=WinInitialize(0);
  if(hab) {
    hmq=WinCreateMsgQueue(hab,0);
    if(hmq) {  
      /* Save installation directory */

      /* Get our ressource dll */  

      WinRegisterClass(hab, CLASS_NAME, newProc,0, SLADDBYTES);
      if( WinDlgBox( HWND_DESKTOP, NULLHANDLE, waveinfoStatusDialogProc, NULLHANDLE, IDDL_PMTST, 0) == DID_ERROR )
        {
          
          WinDestroyMsgQueue( hmq );
          WinTerminate( hab );
          DosBeep(100,600);
          return( 1 );
        }
      
      WinDestroyMsgQueue(hmq);
    }
    WinTerminate(hab);
  }
  return 0;
}
Example #18
0
void  dispmsg(
              union both_scr  *posptr,
              int  msgno)
/**********************************************************************/
/*                                                                    */
/* Display a message on the message line and optionally ring the      */
/* bell.  Error messages starting with ! ring the bell.               */
/*                                                                    */
/**********************************************************************/
/*                                                                    */
/* This is ZEDIT source material.                                     */
/*                                                                    */
/* ZEDIT Source Materials are intellectual property                   */
/*     (c) Copyright 1987,2001 by Clyde Thomas Zuber.                 */
/*                                                                    */
/**********************************************************************/
{
extern unsigned int  graphic;
extern char  msgtext[MSGMAX][80];

int  ln;


if (!posptr)
    return;

if (msgtext[msgno][0] == '!')
#ifdef OS2
    DosBeep(500, 75);
#else
    printf("%c", BELL);
#endif

if (graphic & CGA)
    ln = 0;
else
    ln = 24;

dsp8lin(posptr, &msgtext[msgno][0], ln);
revline(posptr, ln);
if (graphic & XGA)
    xga8514(posptr, ln, RDSPLIN);

} /* end dispmsg */
// Insert a Server Object
int Container::insert(char *name,char *user,char *pass,ULONG arg1,ULONG arg2)
{
    UserData *ud;
    UserData *parent = NULL;
    
    ud = allocateRecords(1);
    if (ud)
    {
        last_insert = ud;
        
        num_objects++;
        
        // set all the stuff in our record
        ud->setName(name);
        ud->setUsername(user);
        ud->setPassword(pass);
        ud->setType(TYPE_SERVER);
        ud->setIcons(icon_server,icon_server);
        ud->setCull(arg1);
        ud->setStart(arg2);
        
        // Build up insertion information
        RECORDINSERT ri;   
        memset(&ri,0,sizeof(RECORDINSERT));
        ri.cb = sizeof(RECORDINSERT);
        ri.zOrder = CMA_END;                    // add on top of siblings
        if (!parent || !parent->getCollapsed())
            ri.fInvalidateRecord = TRUE;            // re-arrange after insert
        ri.pRecordParent = (PRECORDCORE)parent; // set tree hierarchy
        ri.cRecordsInsert = 1;                  // number of records to insert
        ri.pRecordOrder = (RECORDCORE*)CMA_END; // add to end of list

        MRESULT rc = WinSendMsg(cont,CM_INSERTRECORD,MPFROMP((PRECORDCORE)ud),MPFROMP(&ri));
        if (rc == 0)
            message("CM_INSERTRECORD returned %d",rc);
        
        return 1;
    }
    else
    {
        DosBeep(100,100);
        return 0;
    }
}
VOID main(VOID)
{
   USHORT usReturn_Code;           /*  Dos function Return Code              */

   PSZ    pszName = SHARENAME;              /*  Shareable memory block name  */
   SEL    selMem_Selector;                  /*  Receive Segment selector     */

   PSZ     pszSemName = SEMNAME;            /*  System semaphore name        */
   HSEM    hsemSemHandle;                   /*  System semaphore Handle      */

   WATCH FAR * Watch_Ptr;          /*  WATCH pointer                         */

                                   /* Get Access to Shareable memory Block   */
   usReturn_Code = DosGetShrSeg(pszName, & selMem_Selector);

   if (usReturn_Code == 0) {
      Watch_Ptr = (WATCH FAR *) MAKEP(selMem_Selector,0);

      DosOpenSem( & hsemSemHandle,          /*  Open System semaphore        */
                  pszSemName);

      DosSemRequest(hsemSemHandle,          /*  Waits for shared resources   */
                    SEM_INDEFINITE_WAIT);

                            /* Restore Init value count if WATCHDOG enabled  */
      if (Watch_Ptr->Flag & ENABLE_MASK)
         Watch_Ptr->Counter = Watch_Ptr->Counter_Init_Value ;

      DosSemClear(hsemSemHandle);             /*  Release  shared resources  */

      DosFreeSeg(selMem_Selector);            /*  Freeing Shared memory      */

   } else {
      DosBeep(262,250);DosBeep(330,250);DosBeep(392,250);DosBeep(494,250);
      DosBeep(392,250);DosBeep(330,250);DosBeep(262,250);

#ifdef DEBUG
      printf("\n -*-*- STARTTPS Error Code %04x -*-*-\n",usReturn_Code);
      printf("  -*-    WatchDog not Started    -*-\n");
#endif

   } /* endif */

   DosExit((USHORT) 0,usReturn_Code);         /*  Exit Process              */

} /* end of main program */
Example #21
0
static errr Term_xtra_pipe_emx(int n, int v)
{
	termPipe *tp=(termPipe*)Term;

	switch (n)
	{
		case TERM_XTRA_NOISE:
		DosBeep(440, 50);
		return (0);

		case TERM_XTRA_SHAPE:
		return (0);

		case TERM_XTRA_EVENT:
		return (CheckEvents(FALSE));
	}

	return (1);
}
Example #22
0
LONG loadFile (char *fn)
{
HFILE file;   /* handle */
ULONG ac;   /* action code (from DosOpen) */
APIRET rc;   /* return code (from API functions) */
ULONG rd;   /* bytes actually read */
ULONG cbSize;   /* file size in bytes */
ULONG dummy;   /* used when seeking back to beginning of file */

/* try to open existing file --  access */
rc = DosOpen (fn, &file, &ac, 0, 0,
	      OPEN_ACTION_OPEN_IF_EXISTS,
	      OPEN_FLAGS_SEQUENTIAL |
	      OPEN_SHARE_DENYNONE |
	      OPEN_ACCESS_READONLY,
	      0);
if (rc != 0)    /* failed */
   return (0);

DosChgFilePtr (file, 0L, 2, &cbSize);   /* determine file size */
if (cbSize > 30000L)
   {
   DosBeep(3700, 100);
   DosClose (file);
   return (-1);
   }

DosChgFilePtr (file, 0L, 0, &dummy);   /* reset pointer to beginning */
rc = DosAllocMem(&iobuf,               /* Allocate memory object         */
		 (INT)cbSize,          /* Size of memory object          */
		 PAG_COMMIT |          /* Commit memory immediately      */
		 PAG_READ   |          /* Allow read access              */
		 PAG_WRITE);           /* Allow write access             */

if (rc != 0)
   return (0);

/* read entire file into buffer */
DosRead (file, iobuf, cbSize, &rd);
DosClose (file);
return (LONG)cbSize;
}
VOID MainUpdateMsg(HWND hwnd,
                   CHAR PipeMsgs[MAX_MESSAGES][MESSAGE_LEN],
                   unsigned int index,
                   SHORT sTotalMsgs)
{
   RECTL rclInvalid;

   /* if it will fit in the window */
   if (sTotalMsgs <= cyClient/cyChar + sVscrollPos + 1)
   {
      rclInvalid.yBottom = max(0, cyClient - sTotalMsgs * cyChar);
      rclInvalid.yTop = (cyClient - (sTotalMsgs - sVscrollPos - 1) * cyChar);
      rclInvalid.xLeft = 0;
      rclInvalid.xRight = cxClient;
      WinInvalidateRect(hwnd, &rclInvalid, FALSE);
      MainPaint(hwnd, PipeMsgs, index, sTotalMsgs);
   }

   /* if lines exceed window */
   if (sTotalMsgs > cyClient/cyChar)
   {
      WinEnableWindow (hwndVscroll, TRUE) ;
      sVscrollMax = sTotalMsgs - cyClient / cyChar;
      sVscrollPos = min (sVscrollPos, sVscrollMax) ;

      WinSendMsg (hwndVscroll, SBM_SETSCROLLBAR,
                               MPFROM2SHORT (sVscrollPos, 0),
                               MPFROM2SHORT (0, sVscrollMax)) ;

      /* if new msg is just off screen */
      if (sTotalMsgs == cyClient/cyChar + sVscrollPos + 1)
      {
         MainVertScroll(hwnd, MPFROM2SHORT(0, SB_LINEDOWN));
      }

      /* tell user message was received */
      else
      {
         DosBeep(1000, 100);
      }
   }
}
//------------
// MsgConnect \
//---------------------------------------------------------------------------
// Event:	PM_CONNECT
// Cause:	Issued by the connection thread when a connection has been
//			established
//
void *C_WINDOW_MAIN::MsgConnect( void *mp1, void *mp2 )
{
	// Tell the user he is connected
	pxcStatus->Text( "Connected to %s...", ServerAddress() );

	// Enable menu options so the user can select information
	pxcMenu->EnableItem( DM_WINDOWS );

	// Enable the toolbar buttons
	pxcTBar->ButtonEnable( DB_WND_GRP, TRUE );
	pxcTBar->ButtonEnable( DB_WND_SUB, TRUE );

	// Give the user some audible feedback to say that we've connected
	DosBeep( 100, 100 );

	// since we are now connected, open the subscription window and tell
	// it to update.
	SendMsg( WM_COMMAND, (void *)DM_SUBSCRIPTIONS, 0 );

	return FALSE;
}
/**************************************************************************
 *
 *  Name       : AbortHello
 *
 *  Description: Report an error returned from an API service
 *
 *  Concepts   :  use of message box to display information
 *
 *  API's      :  DosBeep
 *                WinGetErrorInfo
 *                WinMessageBox
 *                WinFreeErrorInfo
 *                WinPostMsg
 *
 *  Parameters :  hwndFrame = frame window handle
 *                hwndClient = client window handle
 *
 *  Return     :  [none]
 *
 *************************************************************************/
VOID AbortHello(HWND hwndFrame, HWND hwndClient)
{
   PERRINFO  pErrInfoBlk;
   PSZ       pszOffSet;
   void      stdprint(void);

   DosBeep(100,10);
   if ((pErrInfoBlk = WinGetErrorInfo(hab)) != (PERRINFO)NULL)
   {
      pszOffSet = ((PSZ)pErrInfoBlk) + pErrInfoBlk->offaoffszMsg;
      pszErrMsg = ((PSZ)pErrInfoBlk) + *((PSHORT)pszOffSet);
      if((INT)hwndFrame && (INT)hwndClient)
         WinMessageBox(HWND_DESKTOP,         /* Parent window is desk top */
                       hwndFrame,            /* Owner window is our frame */
                       (PSZ)pszErrMsg,       /* PMWIN Error message       */
                       "Error Msg",          /* Title bar message         */
                       MSGBOXID,             /* Message identifier        */
                       MB_MOVEABLE | MB_CUACRITICAL | MB_CANCEL ); /* Flags */
      WinFreeErrorInfo(pErrInfoBlk);
   }
   WinPostMsg(hwndClient, WM_QUIT, (MPARAM)NULL, (MPARAM)NULL);
} /* End of AbortHello */
Example #26
0
// manages changes in size
VOID WndResize( const HWND hwnd )
{
    wcprintf("WndResize");
    RECTL rWindow;
    LONG cyHeight, cxWidth;
    BITMAPINFOHEADER bmp;

    if( (hbmGlob = GpiSetBitmap( hpsBufferGlob, NULLHANDLE )) != NULLHANDLE ){
	wcprintf("wndresize: there was an old bitmap");
	GpiDeleteBitmap( hbmGlob );        // delete old stuff
    } else 
	wcprintf("wndresize: there was no old bitmap");

    // build the bitmap:
    WinQueryWindowRect( hwnd, &rWindow );
    cxWidth = rWindow.xRight - rWindow.xLeft;// - 2;
    cyHeight = rWindow.yTop - rWindow.yBottom; // - 2;
    wcprintf("wndResize: Breite: %d, H”he: %d", rWindow.xRight, rWindow.yTop );

    memset(&bmp, 0, sizeof(BITMAPINFOHEADER));
    bmp.cbFix = sizeof(BITMAPINFOHEADER);
    bmp.cx = (SHORT)cxWidth;
    bmp.cy = (SHORT)cyHeight;
    bmp.cPlanes = (SHORT)cColorPlanes;
    bmp.cBitCount = (SHORT)cColorBitCount;
    hbmGlob = GpiCreateBitmap(hpsBufferGlob, (PBITMAPINFOHEADER2)&bmp, 
			      0L, NULL, NULL); 
    if( hbmGlob == GPI_ERROR )
	DosBeep( 100, 500);
    GpiSetBitmap( hpsBufferGlob, hbmGlob);

    // calculate the size

//    if( !GpiSetPageViewport(hpsGlob, &rWindow) )
//	wcprintf("error 1");
return;
    if( !GpiSetPageViewport(hpsBufferGlob, &rWindow) )
	wcprintf("error 2");
}
Example #27
0
static VOID AbortLocker( HWND hwndFrame, HWND hwndClient )
{
   PERRINFO     pErrInfoBlk;
   PSZ          pszOffSet;
   PSZ          pszErrMsg;

   DosBeep( 100, 10 );
   if( ( pErrInfoBlk = WinGetErrorInfo(Hab) ) != (PERRINFO)NULL ) {
      pszOffSet = ((PSZ)pErrInfoBlk) + pErrInfoBlk->offaoffszMsg;
      pszErrMsg = ((PSZ)pErrInfoBlk) + *((PSHORT)pszOffSet);
      if( (INT)hwndFrame && (INT)hwndClient ) {
         WinMessageBox(HWND_DESKTOP,         /* Parent window is desk top */
                       hwndFrame,            /* Owner window is our frame */
                       (PSZ)pszErrMsg,       /* PMWIN Error message       */
                       TRP_The_WATCOM_Debugger,      /* Title bar message         */
                       MSGBOXID,             /* Message identifier        */
                       MB_MOVEABLE | MB_CUACRITICAL | MB_CANCEL ); /* Flags */
      }
      WinFreeErrorInfo( pErrInfoBlk );
   }
   WinPostMsg( hwndClient, WM_QUIT, (MPARAM)NULL, (MPARAM)NULL );
}
Example #28
0
void Ring_Bell( void )
{
    DosBeep( 1000, 250 );
}
/****************************************************************\
 *  Main routine
 *--------------------------------------------------------------
 *
 *  Name:   main()
 *
 *  Purpose: Initializes the PM environment, calls the
 *              initialization routine, creates the main
 *              window,  and polls the message queue
 *
 *  Usage:
 *
 *  Method:
 *          - obtains anchor block handle and creates message
 *              queue
 *          - calls the initialization routine
 *          - creates the main frame window which creates the
 *              main client window
 *          - polls the message queue via Get/Dispatch Msg loop
 *          - upon exiting the loop, exits
 *
 *  Returns:
 *          0 - if successful execution completed
 *          1 - if error
\****************************************************************/
INT main(int argc, char *argv[])
{
   QMSG        qmsg;          /* message structure */
   static int  iTimeOut = THRD_EXIT_TIMEOUT;

   hab = WinInitialize(0UL);

   if(!hab)
   {
      DosBeep(BEEP_WARN_FREQ, BEEP_WARN_DUR);
      return RETURN_ERROR;
   }

   hmq = WinCreateMsgQueue(hab, 0L);

   if(!hmq)
   {
      DosBeep(BEEP_WARN_FREQ, BEEP_WARN_DUR);
      WinTerminate(hab);
      return RETURN_ERROR;
   }

   if(!Init(argc, argv))
   {
      if(hwndMainFrame == NULLHANDLE)
      {
          MessageBox(HWND_DESKTOP,
                     IDMSG_MAINWINCREATEFAILED,
                     MB_OK | MB_ERROR,
                     TRUE);
      }

      else
      {
         MessageBox(HWND_DESKTOP,
                    IDMSG_INITFAILED,
                    MB_OK | MB_ERROR,
                    TRUE);

      }

      DosBeep(BEEP_WARN_FREQ, BEEP_WARN_DUR);
      if (WinIsWindow(hab, hwndMainFrame))
      {
         WinDestroyWindow(hwndMainFrame);
      }
      WinDestroyMsgQueue(hmq);
      WinTerminate(hab);
      return RETURN_ERROR;
   }

   /* Get-Dispatch Message loop */
   while(WinGetMsg(hab, &qmsg, NULLHANDLE, 0UL, 0UL))
      WinDispatchMsg(hab, &qmsg);


   /* destroy the help instance */
   DestroyHelpInstance();

   if (WinIsWindow(hab, hwndMainFrame))
      WinDestroyWindow(hwndMainFrame);
   WinDestroyMsgQueue(hmq);

   /* give other thread a chance to exit */
   while (!fThrdsDead && iTimeOut--)
   {
      DosSleep(0UL);
   }

   WinTerminate(hab);
   return RETURN_SUCCESS;

}   /* main() */
/*
 * Method: Horn::Beep
 *
 * Description:
 *
 *    Beeps the horn using the data stored in the object.
 */
VOID Horn::Beep(VOID)
{
  DosBeep(QueryHighTone(), QueryDuration());
  DosSleep(100);
  DosBeep(QueryLowTone(), QueryDuration());
}