tvichw32ctl.cpp

《Delphi5企业级解决方案及应用剖析》参考程序 DELPHI 资料集

		GetObject(hbitmap,sizeof(BITMAP),(LPVOID)&bm);

		ptSize.x = bm.bmWidth;
        ptSize.y = bm.bmHeight;
        pdc->DPtoLP(&ptSize,1);    

        ptOrg.x = 0;
		ptOrg.y = 0;
		DPtoLP(hMemDC,&ptOrg,1);

	    BitBlt(pdc->m_hDC,0,0,ptSize.x,ptSize.y,
			        hMemDC,ptOrg.x,ptOrg.y,SRCCOPY);

	    DeleteDC(hMemDC);
	    DeleteObject(hbitmap);

	};

}


/////////////////////////////////////////////////////////////////////////////
// CTVicHW32Ctrl::DoPropExchange - Persistence support

void CTVicHW32Ctrl::DoPropExchange(CPropExchange* pPX)
{
	ExchangeVersion(pPX, MAKELONG(_wVerMinor, _wVerMajor));
	COleControl::DoPropExchange(pPX);

	// TODO: Call PX_ functions for each persistent custom property.

}


/////////////////////////////////////////////////////////////////////////////
// CTVicHW32Ctrl::OnResetState - Reset control to default state

void CTVicHW32Ctrl::OnResetState()
{
	COleControl::OnResetState();  // Resets defaults found in DoPropExchange

	// TODO: Reset any other control state here.
}


/////////////////////////////////////////////////////////////////////////////
// CTVicHW32Ctrl message handlers

BOOL CTVicHW32Ctrl::InstallDriver() 
{
    SC_HANDLE	schService;
	char	    ServiceExe[255];
	BOOL        Result;

	GetWindowsDirectory(ServiceExe, 128);
	strcat(ServiceExe, "\\SYSTEM32\\DRIVERS\\");
	strcat(ServiceExe, DriverName);
    strcat(ServiceExe, ".SYS");
	schService = CreateService( 
		                schSCManager,	    // SCManager database
					    DriverName,			// name of service
					    DriverName,			// name to display
					    SERVICE_ALL_ACCESS,		// desired access
					    SERVICE_KERNEL_DRIVER,	// service type
					    SERVICE_DEMAND_START,	// start type
					    SERVICE_ERROR_NORMAL,	// error control type
					    ServiceExe,				// service's binary
						NULL,                   // no load ordering group
						NULL,                   // no tag identifier
						NULL,                   // no dependencies
						NULL,                   // LocalSystem account
						NULL);                  // no password)

    Result = (schService != 0) || (GetLastError() == ERROR_SERVICE_EXISTS);

    fDebugCode |= Result?DEB_INST_OK:DEB_INST_ERR;


    CloseServiceHandle(schService);
	return Result;

}

BOOL CTVicHW32Ctrl::StartDriver() 
{
	
	SC_HANDLE	schService;
	BOOL		Result = FALSE;
    long        Res;
    
	schService = OpenService (schSCManager, DriverName, SERVICE_ALL_ACCESS);
	if (schService != 0) {
		
		Result = StartService(schService, 0, NULL);
		Res = GetLastError();

		Result |= (Res == ERROR_SERVICE_ALREADY_RUNNING);

		fDebugCode |= Result?DEB_START_OK:DEB_START_ERR;

		CloseServiceHandle (schService);

	}
	return Result;
}

BOOL CTVicHW32Ctrl::StopDriver() 
{
	
	SC_HANDLE schService;
	SERVICE_STATUS serviceStatus;
	BOOL Result = FALSE;

	schService = OpenService (schSCManager, DriverName, SERVICE_ALL_ACCESS);
	if (schService != NULL) {
		Result = ControlService (schService, SERVICE_CONTROL_STOP, &serviceStatus);
		CloseServiceHandle (schService);
	}
	return Result;
}

BOOL CTVicHW32Ctrl::RemoveDriver() 
{

	SC_HANDLE	schService;
	BOOL		Result = FALSE;

	schService = OpenService (schSCManager, DriverName, SERVICE_ALL_ACCESS);
	if (schService != 0) {
		Result = DeleteService (schService);
		CloseServiceHandle (schService);
	}
	return Result;
	
}

void CTVicHW32Ctrl::CloseStopUnloadDriver() 
{
	CloseHandle(hDrv); 
   if (fWin95)return;

#ifndef DEMOVERSION
   if (fStarted) return;
#endif

	schSCManager = OpenSCManager(0, 0, SC_MANAGER_ALL_ACCESS);
	if  (schSCManager !=0) {
		StopDriver();
#ifndef DEMOVERSION
		if (!fRegistry)
#endif
	    RemoveDriver();
		CloseServiceHandle(schSCManager);
    };
}

void CTVicHW32Ctrl::InstallStartLoadDriver() 
{
  char buffer[255];


  CloseStopUnloadDriver();  // Close before start     


  if (fWin95) { // Windows 95/98
     strcpy(buffer,"\\\\.\\");
	 strcat(buffer,DriverName);
	 strcat(buffer,".VXD");
	 hDrv   = CreateFile(buffer,
						 0,
						 0,
						 NULL,
						 0,
						 FILE_FLAG_DELETE_ON_CLOSE,
						 0
						 );
	 return;
  }; 


  strcpy(buffer,"\\\\.\\");
  strcat(buffer,DriverName);
  
  fDebugCode = DEB_ENTRY;

#ifndef DEMOVERSION

  fRegistry= TRUE; // assume driver already installed to th registry
  fStarted = TRUE; // assume driver already started

  fDebugCode |= DEB_ENTRY_NOT_DEMO;

  hDrv     = CreateFile(
     	                buffer, 
	                  	GENERIC_READ | GENERIC_WRITE, 0, NULL,
                        OPEN_EXISTING, 
						FILE_ATTRIBUTE_NORMAL, 
						0
						);

  if (hDrv != INVALID_HANDLE_VALUE) return;

  fDebugCode |= DEB_NOT_STARTED;

  fStarted = FALSE;

#endif

  schSCManager = OpenSCManager(0, 0, SC_MANAGER_ALL_ACCESS);

  fDebugCode |= DEB_SC_NOT_OPEN;

  if (schSCManager !=0) {

	  fDebugCode |= DEB_SC_OPEN;

#ifndef DEMOVERSION

	  // Driver already installed but not started? Try to start...
	  if (StartDriver()) {

	     hDrv  = CreateFile(
			                buffer, 
		                  	GENERIC_READ | GENERIC_WRITE, 0, NULL,
                            OPEN_EXISTING, 
							FILE_ATTRIBUTE_NORMAL, 
							0
							);
			CloseServiceHandle (schSCManager);

			fDebugCode |= DEB_INSTALLED;

			return; // YES!

          }


		 fRegistry = FALSE; // not installed

		 fDebugCode |= DEB_NOT_INSTALLED;

#endif

		 
		 if (InstallDriver()) {

			 fDebugCode |= DEB_AFTER_INSTALL;

            if (StartDriver()) {

				fDebugCode |= DEB_AFTER_START;

	           hDrv   = CreateFile(
			                buffer, 
		                  	GENERIC_READ | GENERIC_WRITE, 0, NULL,
                            OPEN_EXISTING, 
							FILE_ATTRIBUTE_NORMAL, 
							0
							);
		
			};

		 };

	     CloseServiceHandle (schSCManager);

	};

	return;

}

void CTVicHW32Ctrl::ClearFields() 
{
  	hDrv                = INVALID_HANDLE_VALUE;
	fRegistry           = TRUE;
	fStarted            = TRUE;
    fTerminated         = FALSE;
    
	fInterface      = 0;
    fBus 			= 0;
    fPhysLoPart     = 0;
    fPhysHiPart     = 0;
    fTypeMem        = 0; 
    fMemorySize     = 0;

	fDebugCode      = 0;


    for (int i=0; i<MaxMappedAreas; i++) {
		fMappedPointers[i]  = NULL;
		fMappedSizes[i]  = 0;
	};
	fMappedAreas  = 0;
	
    fHardAccess     = TRUE;

    fIsIRQSet       = (fIRQNumber>0) && (fIRQNumber<16);
    fMasked         = TRUE;
    fOpenDrive      = FALSE;

}

long CTVicHW32Ctrl::CtlCode(long Code) 
{
  if (fWin95)	return Code;
  else   		return (0x80000000L | ((0x0800 + Code) << 2));
}


BOOL CTVicHW32Ctrl::GetHardAccess() 
{
  	return fHardAccess;
}

void CTVicHW32Ctrl::SetHardAccess(BOOL bNewValue) 
{
  DWORD nByte = 0;
  if (!fOpenDrive ) return;

  if (!fWin95) {
  
    if (bNewValue)

			DeviceIoControl(hDrv,
					CtlCode(_DRV_HARD_ACCESS),
					NULL, 0, NULL, 0,
					&nByte, NULL);
	else

        	DeviceIoControl(hDrv,
					CtlCode(_DRV_SOFT_ACCESS),
					NULL, 0, NULL, 0,
					&nByte, NULL);
  } 

  fHardAccess = bNewValue;


	SetModifiedFlag();
}

short CTVicHW32Ctrl::GetLPTNumber() 
{
	return fLPTNumber;
}

void CTVicHW32Ctrl::SetLPTNumber(short nNewValue) 
{
	
	if (fOpenDrive && (nNewValue<=fLPTs)) {
		fLPTBasePort = (short)*(fLPTAddresses+nNewValue-1);
        ((PLockedBuffer)fpLockedMemory)->LPT_BASE_PORT = fLPTBasePort;
		fDataPorts[0] = fDataPorts[1] = fDataPorts[2] =0;
		fLPTNumber = (BYTE)nNewValue;
	};

	SetModifiedFlag();
}

BOOL CTVicHW32Ctrl::GetIRQMasked() 
{
	return fMasked;

}

void CTVicHW32Ctrl::SetIRQMasked(BOOL bNewValue) 
{

	DWORD nByte = 0;

	if (fOpenDrive && fIsIRQSet) {

		if (bNewValue){

			if (!fMasked) {

      	        fMasked = TRUE;
                DeviceIoControl(hDrv,
				    	        CtlCode(_DRV_MASK_INT_VEC),
					            NULL, 0, NULL, 0,
					            &nByte, NULL);

				fTerminated = true;

	            if(fWin95) {
		           SetEvent(fLocEvent);
				} else {
		                ReleaseSemaphore(fLocEvent, 1, NULL);
				};


                WaitForSingleObject(fThreadHandle,INFINITE);

                CloseHandle(fThreadHandle);
				
	            CloseHandle(fLocEvent);
	            fLocEvent = 0;
	
			};
		}
		else {
			if (fMasked) {
                
                ((PLockedBuffer)fpLockedMemory)->LPT_BASE_PORT = fLPTBasePort;
                ((PLockedBuffer)fpLockedMemory)->MAX_BUF_LPT   = MAX_RING_BUFFER;
                ((PLockedBuffer)fpLockedMemory)->L_BUF_LPT     = 0;
                ((PLockedBuffer)fpLockedMemory)->N_ADD_LPT     = 0;
				((PLockedBuffer)fpLockedMemory)->N_SEL_LPT     = 0;
                
                fTerminated = FALSE;

                if (fWin95)
                    fThreadHandle=CreateThread(
					          NULL,
							  0,
							  (LPTHREAD_START_ROUTINE)&IRQProc95,
							  this,
							  0,
							  (LPDWORD)&fThreadId
							                   );
                else
                    fThreadHandle=CreateThread(
					          NULL,
							  0,
							  (LPTHREAD_START_ROUTINE)&IRQProcNT,
							  this,
							  0,
							  (LPDWORD)&fThreadId
    					                       );
			};
		};
	};

	SetModifiedFlag();
}

short CTVicHW32Ctrl::GetIRQNumber() 
{
    return fIRQNumber;
	
}

void CTVicHW32Ctrl::SetIRQNumber(short nNewValue) 
{

   if ((nNewValue>0) && (nNewValue<16)) {

	   if (!fMasked && fOpenDrive) SetIRQMasked(TRUE);
	   fIRQNumber = nNewValue;
	   fIsIRQSet = TRUE;
		
    };

	SetModifiedFlag();
}

void CTVicHW32Ctrl::CloseDriver() 
{
    ULONG nByte;

	if (fOpenDrive) {
		SetHardAccess(TRUE);
		if (!fMasked) SetIRQMasked(TRUE);
		fOpenDrive = FALSE;
		DeviceIoControl(hDrv,
		              CtlCode(_DRV_UNMAP_LPT_AREA),
					  &fLPTAddresses,4,
					  &fLPTAddresses,4,
					  &nByte,NULL);
		DeviceIoControl(hDrv,
			          CtlCode(_DRV_UNLOCK_MEMORY),
					  &fMdl,4,
					  &fMdl,4,
					  &nByte,NULL);
		for (int i=0; i<fMappedAreas; i++)