C / C++ / MFC

const BOOL  WAIT_FOR_ANY_EVENT      = FALSE;
const BOOL  WAIT_FOR_ALL_EVENTS     = TRUE;
const DWORD       WAIT_TIMEOUT_VALUE = 5000;
const DWORD       NO_TIMEOUT         =    0;
...
event_detected = WaitForMultipleObjects(
      EVENT_ARRAY_SIZE,
      mp_common_data->event_array,
      WAIT_FOR_ANY_EVENT,
      NO_TIMEOUT );
...
switch( event_detected )
{
     case WAIT_TIMEOUT:  // defined in winerror.h, value = 258L
     {
      mp_common_data->count_of_timeout_events ++;
      BOOL reset_status = ResetEvent( (HANDLE ) WAIT_TIMEOUT );
      if( reset_status == FALSE )
           {
           m_wsa_error = GetLastError();  // error = 6, invalid handle
            }
             ...
	break;
}
...
}

HRESULT ExtIcon::ExtractImpl(UINT nIconIndex, HICON* phiconLarge, HICON* phiconSmall)
{
   phiconLarge = NULL;
   phiconSmall= NULL;
}

STDMETHODIMP ShellFolderImpl::GetUIObjectOf ( HWND , UINT uCount,
                                               LPCITEMIDLIST* pPidl, REFIID riid,
                                               LPUINT, void** ppvReturn )
{

    try
    {

    *ppvReturn = NULL;

    if( uCount != 1 )
       return E_FAIL;

    // IExtractIcon
    if( IsEqualIID(riid, IID_IExtractIconA)|| IsEqualIID(riid, IID_IExtractIconW))
    {
        CComObject<ExtIcon>* pExtractIcon;
        HRESULT hr = CComObject<ExtIcon>::CreateInstance ( &pExtractIcon );
        if (FAILED(hr))
            return hr;
        
    
        // Tight its lifetime with this object (the IShellFolder object)
        pExtractIcon->Init(GetUnknown());
        
        pExtractIcon->AddRef();
        pExtractIcon->SetMyPIDL((LPITEMIDLIST)*pPidl);
        
        // Return the requested interface to the caller
        hr = pExtractIcon->QueryInterface(riid, ppvReturn);
        
        // We do no more need our ref)
        pExtractIcon->Release();
        return hr;
    }
    catch(...){}

    return E_NOINTERFACE;
}

// ExtIcon.h : Declaration of the ExtIcon

#pragma once
#include "resource.h"  
#include "PluginRes.h"// main symbols
#include "pidlmgr.h"
#include "ExplorerPlugIn.h"


// ExtIcon

// IExtractIconA
// Windows XP, Vista: IExtractIconW
// Windows 7: IExtractIconA
// Windows 8: IExtractIconA ?
class ATL_NO_VTABLE ExtIcon :
    public CComObjectRootEx<CComSingleThreadModel>,
    public CComCoClass<ExtIcon, &CLSID_ExtIcon>,
    public IDispatchImpl<IExtIcon, &IID_IExtIcon, &LIBID_ExplorerPlugInLib, /*wMajor =*/ 1, /*wMinor =*/ 0>,
    public IExtractIconA,
    public IExtractIconW
{
public:
    ExtIcon()
    {
    }
    ExtIcon(LPCITEMIDLIST pidl);



DECLARE_REGISTRY_RESOURCEID(IDR_EXTICON)


BEGIN_COM_MAP(ExtIcon)
    COM_INTERFACE_ENTRY_IID(IID_IExtractIconA, IExtractIconA)
    COM_INTERFACE_ENTRY_IID(IID_IExtractIconW, IExtractIconW)
    COM_INTERFACE_ENTRY(IExtIcon)
    COM_INTERFACE_ENTRY(IDispatch)
END_COM_MAP()


    DECLARE_PROTECT_FINAL_CONSTRUCT()

    HRESULT FinalConstruct()
    {
        return S_OK;
    }
    
    void FinalRelease()
    {
    }

public:
    // IExtractIconA
    STDMETHOD(GetIconLocation)(THIS_ UINT, LPSTR, UINT, int* piIndex, UINT* pwFlags)
    {
        return GetIconLocationImpl(piIndex, pwFlags);
    }
    STDMETHOD(Extract)(THIS_ LPCSTR, UINT nIconIndex, HICON* phiconLarge, HICON* phiconSmall, UINT)
    {
        return ExtractImpl(nIconIndex, phiconLarge, phiconSmall);
    }
    // IExtractIconW
    STDMETHOD(GetIconLocation)(THIS_ UINT, LPWSTR, UINT, int* piIndex, UINT* pwFlags)
    {
        return GetIconLocationImpl(piIndex, pwFlags);
    }
    STDMETHOD(Extract)(THIS_ LPCWSTR, UINT nIconIndex, HICON* phiconLarge, HICON* phiconSmall, UINT)
    {
        return ExtractImpl(nIconIndex, phiconLarge, phiconSmall);
    }

    // Ensure the owner object is not freed before this one
    void Init(IUnknown *pUnkOwner);

    void SetMyPIDL(LPITEMIDLIST pidl)
    {
        m_pidl = pidl;
    }
    //CExtIcon( LPCITEMIDLIST /*pidl*/ );
    enum BoxType
    {
        PUBLIC,
        PRIVATE
    };

private:
    HRESULT GetIconLocationImpl(int*, UINT*);
    HRESULT ExtractImpl(UINT, HICON*, HICON*);

    CPidlMgr* m_pPidlMgr;
    LPITEMIDLIST m_pidl;
    BOOL m_bIsOpenIcon;
    protected:
         CComPtr<IUnknown> m_UnkOwnerPtr;
   DWORD m_ObjRefCount;

};

OBJECT_ENTRY_AUTO(__uuidof(ExtIcon), ExtIcon)

void CTouchSoundTrayDlg::OnRawInput(UINT nInputCode, HRAWINPUT hRawInput)
{
    UINT data_size = 0;
    BOOL bGot = FALSE;
    GetRawInputData(hRawInput, RID_INPUT, NULL, &data_size, sizeof(RAWINPUTHEADER));
    vector<BYTE> data;
    data.resize (data_size);

    if(GetRawInputData (hRawInput, RID_INPUT, &data [0], &data_size, sizeof(RAWINPUTHEADER))!=data_size)
    {
		
    }
    RAWINPUT* raw = (RAWINPUT*)(&data [0]);
	
    if (raw->header.dwType == RIM_TYPEHID) 
    {
        RID_DEVICE_INFO device_info;
        UINT info_size = sizeof(RIDI_DEVICEINFO);
        GetRawInputDeviceInfo ( raw->header.hDevice, RIDI_DEVICEINFO, (LPVOID)&device_info,&info_size);
        
        if(device_info.hid.dwVendorId = VENDER_ID)
        {
            g_CurFrameTime = GetTickCount64();
	   if(g_CurFrameTime - g_PreFrameTime > 30)
	   {
		g_PreUsedSize = 0;
		g_CurUsedSize = 0;				  
	   }
			
	   g_PreFrameTime = g_CurFrameTime;
	   DigitizerData* result = (DigitizerData*)(raw->data.hid.bRawData);
	   g_CurUsedSize = result->active_touch_count;

				  
            if(g_CurUsedSize <= 5)
            {
	       if(g_PreUsedSize <  g_CurUsedSize)
	       {
	           PlaySound(m_WavPath, NULL, SND_FILENAME|SND_ASYNC );
	       }
	       bGot = TRUE;
	   }
					
	   if(bGot)
	   {
	       g_PreUsedSize =  g_CurUsedSize;
	   }
         }		
    }	
	Default();
}

IDispatch       *pWordInst;
CApplication    *pWordApp;
CDocument0      *pDoc;
IUnknown        *pUnknown;


  HRESULT res = CoInitialize(NULL);

  CLSID clsid;
  HRESULT hr = CLSIDFromProgID(L"Word.Application", &clsid);

  hr = CoCreateInstance(clsid, NULL, CLSCTX_LOCAL_SERVER, IID_IDispatch, (void **)&pWordInst);

  pUnknown = NULL;
  REFIID iid2 = __uuidof(IUnknown);

  hr = pWordInst->QueryInterface(iid2, (void **)&pUnknown);

<pre lang="c++">

#include <iostream>
#include <string>
using namespace std;
 
const int ILLEGAL_SIZE = 1;
const int OUT_OF_MEMORY = 2;
const int NO_SPACE = 3;
const int ILLEGAL_INDEX = 4;
const int ILLEGAL_REFERNCE = 5;
const int COURSE_LIMIT_REACHED = 6;
 
template <class T>
class ListIterator;
 
template <class T>
class OrderedList {
	
	
	friend class ListIterator<T>;
 
private:
	
	int maxSize;
	int currentSize;
	T *listArray;
	bool removeAt(int index) {  
		
		if(index < 0 || index >= currentSize) throw ILLEGAL_INDEX;
	
		else {
		
			for(int i=index;i<currentSize;i++) 
			
				listArray[i] = listArray[i+1];
			
			currentSize--;
			return true;
		}					
	}
 
public:
 
	OrderedList(int size);
	OrderedList(const OrderedList& copy);
	~OrderedList();
	void setData(T s);
	T getData(int i);
	int getCurrent() { return currentSize; }
	bool isFull();
	bool isEmpty();
	int isPresent(T value);
	void insert(T value);
	bool remove(T value);
	int search(T value);
	void printData();
	const OrderedList& operator = (const OrderedList& assignment);
 
};
 
template <class T>
OrderedList<T>::OrderedList(int size) {
 
	if(size < 0) throw ILLEGAL_SIZE;
 
	maxSize = size;
 
	listArray = new T[maxSize];
	
	if(listArray == NULL) throw OUT_OF_MEMORY;
	
	currentSize = 0;
 
}
 
template <class T>
OrderedList<T>::OrderedList(const OrderedList& copy) {
 
	maxSize = copy.maxSize;
	currentSize = copy.currentSize;
 
	listArray = new T[maxSize];
	for(int i=0;i<currentSize;i++) {
	
		listArray[i] = copy.listArray[i];
	
	}
}
 
template <class T>
const OrderedList<T>& OrderedList<T>::operator= (const OrderedList& assignment) {
 
	if(this != &assignment) {
	
		currentSize = assignment.currentSize;
		delete [] listArray;
		listArray = new T[maxSize];
		
		for(int i=0;i<currentSize;i++) {
		
			listArray[i] = assignment.listArray[i];
		
		}
	}
	
	return *this;
}
 
template <class T>
OrderedList<T>::~OrderedList() {
 
	delete [] listArray;
 
}
 
template <class T>
void OrderedList<T>::setData(T s) {
 
		
		listArray[currentSize] = s ;
		
		currentSize++; 
}
 
template <class T>
T OrderedList<T>::getData(int i) {
 
	return listArray[i];		
}
 
template <class T>
bool OrderedList<T>::isEmpty() {
 
	return (currentSize == 0);
 
}
 
template <class T>
bool OrderedList<T>::isFull() {
 
	return (currentSize == maxSize);
 
}
 
template <class T>
int OrderedList<T>::isPresent(T value) {
 
	return(search(value));
 
}
 
template <class T>
int OrderedList<T>::search(T value) {
 
int low = 0;
int mid;
int high = currentSize-1;
 
	while(low<=high) {
 
		mid = (low + high)/2;
 
		if(value == listArray[mid])
			
			return mid;
		
		else if(value > listArray[mid])
 
			low = mid + 1;
 
		else
			high = mid - 1;
	}	
	return -1;
}
 
template <class T>
void OrderedList<T>::insert(T value) {
 

	if(isFull()) throw NO_SPACE;
 
	else {
	int i = currentSize;
	while(  i > 0 && value < listArray[i-1]) {
	
		listArray[i] = listArray[i-1];
		i--;
	}
	
	listArray[i] = value;
	currentSize++;
	}
 
}
 

template <class T>
bool OrderedList<T>::remove(T value) {
 
	int index = search(value);
	
	if(index == -1) return false;
 
	else {
	
		return removeAt(index);
	}
}
 
template <class T>
void OrderedList<T>::printData() {
 

	for(int i=0;i<currentSize;i++) {
	
		cout << listArray[i] << endl;
	
	}
}
 

class Course {
 
private:
	
	string ID;
	double GPA;
 
public:
 
	Course(): ID(""),GPA(0) {}
	Course(string id,double gpa): ID(id),GPA(gpa) {}
	double getGPA() { return GPA; }
	void printCourse() { cout << "Course ID: " << ID << " " << "GPA: " << GPA << endl;  }
	friend ostream& operator<< (ostream & out, const Course& course) { out << course.ID << " " << course.GPA << endl; return out; }
	bool operator< (Course c) { if (ID < c.ID) return true; else return false; }
	bool operator> (Course c) { if (ID > c.ID) return true; else return false; }
	bool operator== (Course c) { if (ID == c.ID) return true; else return false; }
};
 

class Student {
	
private:	
	
	string name;
	int rNo;
	int noOfCourses;
	double CGPA;
	OrderedList<Course> courseList;
	
	
public:
 
	Student(): name(),rNo(0),CGPA(0),noOfCourses(0),courseList(50) {}
	Student(string n,int r): name(n),rNo(r),CGPA(0),noOfCourses(0),courseList(50) {}
	void printStudent() { cout << "Name : " << name << " " << "Roll No: " << rNo << " " << "CGPA: " << CGPA << endl; if(noOfCourses !=0)  printCourse(); }
	
	int getRoll() { return rNo; }
 
	void addCourse(Course c) {
 
		if(noOfCourses < 50) {
		courseList.insert(c);
		noOfCourses++;
		}
		else throw COURSE_LIMIT_REACHED; 
	}
 
	void removeCourse(Course c) {
	
		if(noOfCourses != 0){
		courseList.remove(c);
		noOfCourses--;
		}
 
		else cout << "There are no Courses to be removed\n" << endl;
	}
 
	void printCourse() { cout << "Courses Taken\n\n"; courseList.printData(); }
	
	double calCGPA() {
	
		Course c;
		double sum = 0;
		for(int i=0;i<noOfCourses;i++){
		
		c = courseList.getData(i);
		sum = sum + c.getGPA();
		
		}
		CGPA = sum/noOfCourses;
		return CGPA;
	}
 

	friend ostream& operator<< (ostream& out, const Student& student) { out << student.name << " " << student.rNo << endl; return out; }
	bool operator <(Student s) { if (rNo < s.rNo) return true; else return false; }
	bool operator >(Student s) { if ( rNo > s.rNo) return true; else return false; }
	bool operator ==(Student s) { return (rNo == s.rNo); }
 
};
 
template <class T>
class ListIterator {
 
private:
 
	OrderedList<T> &list;
	int current;
	ListIterator & operator =(const ListIterator & rhs);
 
public:
 
	ListIterator(OrderedList<T> &l): list(l), current(0) { }
	ListIterator(const ListIterator<T> &li): list(li.list), current(li.current) { }
	void begin(){ current = 0; }
	int getCurrent() { return current; }
	void end() { current = list.currentSize; }
	bool isStart() { return current == 0; }
	bool isDone() { return current == list.currentSize; }
	void next() {
		
		if (!isDone()) current++;
		else throw ILLEGAL_REFERNCE;
}
	bool find(const T key) {
	
	current = list.search(key);
 
	if (current > -1) return true; 
	
	else return false;
}
 
	T getData() { return (list.listArray[current]);	} 
	void setData(const T value) { list.listArray[current];  } 
	void insertData(T value) { list.insert(value); }
	void removeData(T value) { list.remove(value); }
	void getCourse(Student s) { getCourse(s); }
	void printData() { list.printData(); }
 
};
 

 
int main() {
 
/************************************
1. Creating An Empty List Of Students
************************************* */
	OrderedList<Student> studentList(10);
 
	Student s1("Hamza",12105092);
	Student s2("Ahmad",12105081);
	Student s3("Sherlock",12105032);
	Student s4("Watson",12134989);
	Student s5("Gary",12105042);
	Student s6("Ali",3111111);
 
/*****************************
2. Adding Students To The List
****************************** */
	
	ListIterator<Student> studentIterator(studentList);
	
	studentIterator.insertData(s1);
	studentIterator.insertData(s2);
	studentIterator.insertData(s3);
	studentIterator.insertData(s4);
	studentIterator.insertData(s5);
 
	studentIterator.printData();
	cout << endl;
	
 
/**********************************
3. Deleting A Student From The List
*********************************** */
	studentIterator.removeData(s1);
 
	cout << "List After Removing A Student\n" << endl;
	
	studentIterator.printData();
	
	cout << endl;
	
/*************************************
4. Adding A Course For A Given Student
************************************** */
 
	Course c1("CS102",3.44);
	Course c2("CS101",3.11);
	Course c3("MATH101",4);
 
	
	s5.addCourse(c1);
	s5.addCourse(c2);
	s5.addCourse(c3);
 
	studentIterator.setData(s5);
	
	
/*************************************
5. Remove A Course For A Given Student
************************************** */
 
	s5.removeCourse(c2);
 
	cout << "After removing a course\n" << endl;
	s5.printStudent();
 
/****************************************************************
6. Finding If A Student is Present Or Not Through His Roll Number
***************************************************************** */
 
	bool store; 
	string name;
	int rollNo;
	cout << "Enter The Student's Name and Roll Number To Find If He's Present In The List\n";
	cin >> name;
	cin >> rollNo;
	Student s7(name,rollNo);
	store = studentIterator.find(s7);
	
	if(!store) cout << "Student is not present in the list\n" << endl;
	else cout << "Student is present\n" << endl;
	
	
/*************************************************
7. Calculating CGPA For A Given Student's Roll No.
************************************************** */
 
	s5.calCGPA();
	s5.printStudent();
 
/***********************************************************************************************************************
8. Given The Roll Number, List All The Course A Student Has Taken Along With The Awarded Grades And GPA For Each Course.
************************************************************************************************************************ */
	  
	  int index = 0;
	  cout << endl;
	  cout <<"Enter the Student's name and Roll No. Whose Course Details You Want To Know" << endl;
	  cin >> name;
	  cin >> rollNo;
	  Student s9(name,rollNo);
	 store = studentIterator.find(s9);
	 if(store) 
	 cout << studentIterator.getData();
 
	 else
		 cout <<"Entered Roll Number Isn't Present In The List" << endl;
 

/*********************************************************************
9.	List all the students. (complete details – student and his grades)
********************************************************************** */
 
	studentList.printData();
	
 
return 0;
 
}