Discussion :

[antow42]

Bonjour � tous,

Dans une application en C++, d�velopp�e � l'aide de Visual Studio C++, j'utilise le code suivant :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
 
AutomationExcel * Autom1;
[...]
Autom1->demarrerExcel("Résultats1");
plage.Format( "$A$2:$A$%u", 1001);
Autom1->creerDonnees( "C (Vo/s)", "$A$1",tab,plage,1000,(short)1);
[...]

Je souhaiterais pouvoir mettre un nom au fichier Excel, j'ai essay� mais je n'arrive pas � trouver ! "demarrerExcel("R�sultats1")" ne me sert qu'� appeler mon premier onglet Excel. Mais comment nommer le fichier Excel � sa cr�ation ? Avez-vous des id�es ?

Deuxi�me probl�me, que je pense plus complexe.
Dans mon logiciel d�velopp�, j'ai un tronc commun o� je peux cr�er une simulation qui va donner � la fin un fichier Excel. Je cr�e donc une AutomationExcel (une AutomationExcel "globale") dans le tronc commun, et une variable "vide" se met � "true".
Lorsque je cr�e une simulation, un fichier Excel est cr��, et la variable "vide" est mise � "false".
Cela me permet de g�rer le fait que si l'utilisateur souhaite cr�er une autre simulation et qu'il n'a pas ferm� le fichier Excel, un message avertit l'utilisateur que s'il ne sauvegarde pas manuellement le fichier Excel, ce dernier va se fermer et la nouvelle simulation va commencer. Tout ceci est g�r� gr�ce � la variable "vide", car lorsque le fichier Excel est ouvert, "vide" est � "false". Il suffit donc de tester cette variable pour voir si un fichier Excel est ouvert ...
Mon probl�me est donc le suivant : lorsque l'application ferme automatiquement Excel, la variable passe � "true" et il n'y a aucun soucis ! Mais si l'utilisateur ferme manuellement le fichier Excel, cette variable ne se modifie pas. Donc l'application crois toujours qu'un fichier Excel est ouvert !!! Et tous les tests deviennent donc faux !!!
Help ! Avez-vous une solution � ce probl�me ? Avez-vous des pistes ?

Je vous remercie !!!

Cordialement,

Anthony

[antow42]

J'ai essay� de travailler sur le probl�me de Excel tout le matin, mais je n'y arrive pas ...

En cherchant sur Internet, je n'ai pas trouv� pour donner un nom � un fichier Excel cr�� par l'application C++.

Et je ne sais pas non plus quel moyen je peux utiliser pour savoir si un fichier Excel est ouvert ou non ...


Merci beaucoup � ceux qui sont int�ress�s par mes interrogations !


Anthony

[Gabrielly]

Il faut que tu obtiennes l'objet classeur et tu utilises sa m�thode d'enregistrement sous un nom donn�.

[antow42]

Merci de m'avoir r�pondu !

Mais comment obtenir un objet classeur ?

Pourriez-vous me donner un exemple ?


Merci bcp !!!

[Gabrielly]

Je vais te pr�senter l'organisation g�n�rale des objets d'Excel

1. D'abord tu as l'objet application d'Excel avec ses m�thodes au niveau de l'objet application d'Excel. L'objet application maintient une collection des classeurs qui sont ouverts par ton application. C'est le conteneur des classeurs Excel ouverts. Il est judicieux de passer par l'objet application avant d'atteindre ton classeur.

2. L'objet conteneur des classeurs Excel te perment d'acc�der au classeur individuel soit � partir d'un indexe dans la collection soit � partir de son nom. C'est un conteneur au sens propre du terme avec ses m�thodes appropri�s pour un conteneur des workbooks.

3. Ensuite tu as l'objet classeur Excel le workbook qui est ton fichier excel proprement dit avec ses m�thodes au niveau du workbook.

4. Le classeur excel donc le workbook contient un conteneur des feuilles excel qui sont les worksheets. Tu acc�des � ces sheets � partir de leurs indexes ou de leurs noms dans la collection avec ses m�thodes appropri�s pour un conteneur des worksheets.

5. L'objet feuille d'Excel donc le worksheet contient ses m�thodes au niveau de la feuille d'Excel.

6. A partir de la feuille Excel tu obtiens les objets Range ie les rang�s sur ta feuille et sur lesquels tu places tes donn�es, tes formules, tes mises en formes.

7. Et tu as tout plein d'autres objets Excel comme les Chart et consort, ils sont tr�s nombreux.

Et donc tu as l'objet application, la collection des classeurs, le classeur, la collection des feuilles, la feuille, les rang�es et les autres objets d'Excel.

[antow42]

D'accord, je viens de comprendre, mais bon, je ne sais pas encore ce qu'il faut faire exactement.

Quelqu'un aurait-il une solution, qui s'est confront� � ce probl�me ?


Merci beaucoup !

[komis]

Salut antow42
d�sol� j'ai �galement les m�mes soucis sauf que moi quand j'int�gre la classe excel dans mon projet MFC, il y'a beaucoup d'erreurs qui apr�s r�vision se transforment en erreurs de link externe......... �a fait une semaine que j'essaie de le faire y'a pas moyen. sinon peux tu me passer tes classes pour que je puisse y jeter un coup d'oeil( si �a ne te d�range pas bien sur...)
merci

[Gabrielly]

D'accord, je viens de comprendre, mais bon, je ne sais pas encore ce qu'il faut faire exactement.

Quelqu'un aurait-il une solution, qui s'est confront� � ce probl�me ?


Merci beaucoup !

Bon, je peux t'aider mais mais ca risque d'etre un peu long.
Ma la solution est efficace.

1. La premiere chose est de savoir avec quel version de Excel tu va travailler.
Excel 1997, Excel 2000, Excel 2002, Excel 2003 ou Excel 2007. Nous pouvons jouer avec la directive import du compilo pour mapper la bonne version.

2. Ensuite il faut chercher un moyen efficace d'avoir une ecriture C++ souple avec les variants ( en d'autres termes par exemple d'affecter directement un CString dans une cellule Excel et vis versa en effectuant une conversion implicite) Je te montrerai ma classe CMcnVariant

3. Ensuite definir des classes derivant des principaux objets d'Excel
4. Et tu les empaquete dans une bonne DLL d'Extension MFC pour exportation dans toute application MFC.

Je vais te montrer la procedure...

[Gabrielly]

Voici un d�but [FAQ][VC++]Comment d�terminer la bonne version d'Excel pour l'automation

A partir du lien ci-haut, la directive import du compilo nous g�n�re les fichiers excel.tlh et excel.tli dans notre namespace "Excel", mso.tlh et mso.tli dans notre namespace "Office", et vbe6ext.tlh et vbe6ext.tli dans notre namespace "VBA".
Vous pouvez vous apercevoir que c'est plein d'�num�ration, de d�claration d'interfaces, et de pointeurs intelligents. Mais nous employerons pas directements ces composants comme tels.

Ce que nous allons faire c'est de pr�parer ces composants Excel en leur rajoutant une surcouche par la d�finition d'une classe sp�ciale, une classe template d'un pointeur intelligent comme classe de base d�finit � l'aide d'une macro. La d�finition de cette classe de base va nous �viter d'utiliser ces composants de fa�on brute. Elle a pour objective de produire une syntaxe C++ tr�s souple, propre et puissante.
Cette classe n'est pas non plus pr�vu d'�tre utiliser directement dans notre code. Elle sert plut�t � pr�parer nos divers classes enfants MFC qui repr�senteront chaque entit� de nos composants Excel principaux.

[Gabrielly]

Sans plus tarder voici cette classe d�finit dans le fichier McnComPtrT.h

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
#pragma once
 
#include <comdef.h>
#include <comdefsp.h>
 
 
#define MCN_CONSTRUCT_COM_PTR_T(theClass, theBaseClass) \
	public: \
		theClass() \
		{ \
		} \
		explicit theClass( \
			const CLSID& clsid,	IUnknown* pOuter = NULL, DWORD dwClsContext = CLSCTX_ALL) \
			:CMcnComPtrT<theBaseClass>(clsid, pOuter, dwClsContext) \
		{ \
		} \
		explicit theClass(  \
			LPCWSTR str, IUnknown* pOuter = NULL, DWORD dwClsContext = CLSCTX_ALL) \
			:CMcnComPtrT<theBaseClass>(str, pOuter, dwClsContext) \
		{ \
		} \
		explicit theClass(  \
			LPCSTR str, IUnknown* pOuter = NULL, DWORD dwClsContext = CLSCTX_ALL) \
			:CMcnComPtrT<theBaseClass>(str, pOuter, dwClsContext) \
		{ \
		} \
		theClass(const theBaseClass& sp) throw() \
			:CMcnComPtrT<theBaseClass>(sp) \
		{ \
		} \
		theClass& operator=(theBaseClass p) \
		{ \
			HRESULT hr = _QueryInterface(p); \
			if (FAILED(hr) && (hr != E_NOINTERFACE)) { \
				_com_issue_error(hr); \
			} \
			return *this; \
		}
 
// T class must inherit directly of indirectly from _com_ptr_t
 
	template< class T >
	class CMcnComPtrT : public T
	{
	public:
		typedef T baseType;
		typedef CMcnComPtrT<T> thisType;
 
		CMcnComPtrT()
		{
		}
 
		explicit CMcnComPtrT(
			const CLSID& clsid,	IUnknown* pOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)
			:T(clsid, pOuter, dwClsContext)
		{
		}
 
		explicit CMcnComPtrT(
			LPCWSTR str, IUnknown* pOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)
			:T(str, pOuter, dwClsContext)
		{
		}
 
		explicit CMcnComPtrT( 
			LPCSTR str, IUnknown* pOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)
			:T(str, pOuter, dwClsContext)
		{
		}
 
		CMcnComPtrT(const T& sp) throw()
			:T(sp)
		{
		}
 
	protected:
		template<typename _InterfacePtr>
		HRESULT _QueryInterface(_InterfacePtr p) throw()
		{
			HRESULT hr;
			if (p != NULL)
			{
				Interface* pInterface;
				hr = p->QueryInterface(GetIID(), reinterpret_cast<void**>(&pInterface));
				baseType::Attach(SUCCEEDED(hr)? pInterface: NULL);
			}
			else
			{
				baseType::operator=(static_cast<Interface*>(NULL));
				hr = E_NOINTERFACE;
			}
			return hr;
		}
 
	}; // class CMcnComPtrT

La classe template CMcnComPtrT est un pointeur intelligent dont l'argument de son mod�le T est une interface d'Excel quelconque g�n�r�e par la directive import.

Soit l'interface de l'objet application d'Excel tel que g�n�r�e

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
 
Excel::_Application   // qui est l'interface brute
Excel::_ApplicationPtr  // qui est l'interface prise en charge par le smart pointeur _com_ptr_t
CMcnComPtrT<Excel::_ApplicationPtr> // qui est la nouvelle interface qui améliore le smart pointeur _com_ptr_t tel qu'au niveau de l'opérateur d'affection et des constructeurs.

Pour l'interface de la collection des classeurs Excel on a :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
 
Excel::Workbooks
Excel::WorkbooksPtr
CMcnComPtrT<Excel::WorkbooksPtr>

Pour l'interface du classeur Excel on a :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
 
Excel::_Workbook
Excel::_WorkbookPtr
CMcnComPtrT<Excel::_WorkbookPtr>

Pour l'interface de la collection des feuilles d'un classeur Excel on a:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
 
Excel::Sheets
Excel::SheetsPtr
CMcnComPtrT<Excel::SheetsPtr>

Pour l'interface d'une feuille Excel on a:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
 
Excel::_Worksheet
Excel::_WorksheetPtr
CMcnComPtrT<Excel::_WorksheetPtr>

Pour l'interface d'une rang�e de cellules Excel on a:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
 
Excel::Range
Excel::RangePtr
CMcnComPtrT<Excel::RangePtr>

[Gabrielly]

Ensuite j'ai mes classes MFC dans une DLL d'extension.
Pour l'objet application d'Excel :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
 
class AFX_EXT_CLASS CMcnExcelApp : public CMcnComPtrT<Excel::_ApplicationPtr>
{
        MCN_CONSTRUCT_COM_PTR_T(CMcnExcelApp, Excel::_ApplicationPtr)
        public:  
//... tes méthodes personnelles pour l'objet application
};

Pour l'objet collection des classeurs Excel :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
 
class AFX_EXT_CLASS CMcnWorkBooks : public CMcnComPtrT<Excel::WorkbooksPtr>
{
        MCN_CONSTRUCT_COM_PTR_T(CMcnWorkBooks, Excel::WorkbooksPtr)
        public: 
//...  tes méthodes personnelles pour la collection des classeurs
};

Pour l'objet classeur Excel :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
 
class AFX_EXT_CLASS CMcnWorkBook : public CMcnComPtrT<Excel::_WorkbookPtr>
{
        MCN_CONSTRUCT_COM_PTR_T(CMcnWorkBook, Excel::_WorkbookPtr)
        public: 
//... tes méthodes personnelles pour le classeur
};

Pour l'objet collection des feuilles du classeur Excel :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
 
class AFX_EXT_CLASS CMcnWorkSheets : public CMcnComPtrT<Excel::SheetsPtr>
{
        MCN_CONSTRUCT_COM_PTR_T(CMcnWorkSheets, Excel::SheetsPtr)
        public:
//...  tes méthodes personnelles pour la collection des feuilles
};

Pour l'objet feuille Excel :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
 
class AFX_EXT_CLASS CMcnWorkSheet : public CMcnComPtrT<Excel::_WorksheetPtr>
{
        MCN_CONSTRUCT_COM_PTR_T(CMcnWorkSheet, Excel::_WorksheetPtr)
        public:
//...  tes méthodes personnelles pour la feuille
};

Pour l'objet rang�e de cellules Excel :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
 
class AFX_EXT_CLASS CMcnRange : public CMcnComPtrT<Excel::RangePtr>
{
        MCN_CONSTRUCT_COM_PTR_T(CMcnRange, Excel::RangePtr)
        public:
//...  tes méthodes personnelles pour la rangée
};

[Gabrielly]

Maintenant je vais te pr�senter une fa�on d'acc�der aux diff�rents objets d'Excel.

Voici un simple code.

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
MCN::Automation::McnExcel::CMcnExcelApp spExcelApp;  // je commence avec l'objet application
HRESULT hr = spExcelApp.CreateInstance(EXCEL_APPLICATION);  // mappe vers la bonne version
if (FAILED(hr))
{
	CString strError("Echec de chargement de Microsoft Excel");
	return;
}
 
MCN::Automation::McnExcel::CMcnWorkBook spWorkBook = spExcelApp.CreateWorkBook();  // je crée un classeur
spWorkBook.SaveAs("C:\\fichier.xls");
 
CString strFullName = spWorkBook.GetFullName();  // C:\\fichier.xls
 
MCN::Automation::McnExcel::CMcnWorkSheet spWorkSheet = spWorkBook.CreateWorkSheet();  // j'ajoute une feuille
spWorkSheet.PutName("Test");
 
MCN::Automation::McnExcel::CMcnRange spRange = spWorkSheet.GetRange("A1", "G10");  // j'obtiens une rangée
spRange.PutItem(3, 4, "Salut");
 
CString strText = spRange.GetItem(3, 4);  // Salut

la suite

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
MCN::Automation::McnExcel::CMcnWorkBooks spWorkBooks = spExcelApp.GetWorkBookCollection();
spWorkBook = spWorkBooks.GetItem("C:\\fichier.xls", true); // recherche par le nom complet
spWorkBook.Show("Test"); // affiche le classeur avec la feuille Test par défaut
 
MCN::Automation::McnExcel::CMcnWorkSheets spWorkSheets = spWorkBook.GetWorkSheetCollection();
spWorkSheet = spWorkSheets.GetItem("Test"); // recherche la feuille par son nom
 
long nRows = 100;
long nCols = 10
spRange = spWorkSheet.GetRange("H12", nRows, nCols);  // une rangée de 100 lignes et 10 colonnes à partir de H12
 
spRange.AutoFitColumns();  // ajustement automatique des colonnes
MCN::Automation::McnExcel::CMcnRange spColRange = spRange.GetColAt(4); // 4ième colonne
 
double dValue = 14.3;
long nRowFound = -1;
long nColFound = -1;
spColRange.FindData(dValue, nRowFound, nColFound); // cherche la valeur 14.3 dans cette colonne
 
//...

Ces objets Excel permettent d'utiliser ses propres m�thodes en faisant objet.PersonalMember() ou d'acc�der aux m�thodes existantes d'Excel en faisant objet->ExcelMember().
Mais avant d'en arriver l�. Excel transit toujours ses donn�es par des variants.
Nous avons la classe COleVariant ou CComVariant pour travailler avec, mais de fa�on brute Excel utilise la classe _variant_t de <comutil.h>

Ainsi nous voulons que _variant_t soit capable de recevoir presque tout type de donn�es m�me celle des MFC comme des CString ou des COleDateTime. Nous voulons �galement que _variant_t soit capable de les restituer automatiquement dans le type souhait� sans que nos yeux puissent aper�evoir un cast explicite.

Voici la classe CMcnVariant :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
 
#pragma once
 
#include <comutil.h>
 
	template<typename T>
	class CCastingVariant : public _variant_t
	{
	public:
		typedef CCastingVariant<T> ThisType;
		typedef _variant_t BaseType;
 
		// Constructors
		//
		inline CCastingVariant() throw()
			:_variant_t()
		{
			m_vtOperation = vt;
		}
 
		inline CCastingVariant(const VARIANT& varSrc)
			:_variant_t(varSrc)
		{
			m_vtOperation = vt;
		}
 
		inline CCastingVariant(const VARIANT* pSrc)
			:_variant_t(pSrc)
		{
			m_vtOperation = vt;
		}
 
		inline CCastingVariant(const _variant_t& varSrc)
			:_variant_t(varSrc)
		{
			m_vtOperation = vt;
		}
 
		inline CCastingVariant(const ThisType& varSrc)
			:_variant_t()
		{
			*this = varSrc;
			m_vtOperation = vt;
		}
 
		inline CCastingVariant(VARIANT& varSrc, bool fCopy) // Attach VARIANT if !fCopy
			:_variant_t(varSrc, fCopy)
		{
			m_vtOperation = vt;
		}          
 
		inline CCastingVariant(short sSrc, VARTYPE vtSrc = VT_I2)    // Creates a VT_I2, or a VT_BOOL
			:_variant_t(sSrc, vtSrc)
		{
			m_vtOperation = vt;
		}
 
		inline CCastingVariant(long lSrc, VARTYPE vtSrc = VT_I4)     // Creates a VT_I4, a VT_ERROR, or a VT_BOOL
			:_variant_t(lSrc, vtSrc)
		{
			m_vtOperation = vt;
		} 
 
		inline CCastingVariant(float fltSrc) throw()                                   // Creates a VT_R4
			:_variant_t(fltSrc)
		{
			m_vtOperation = vt;
		} 
 
		inline CCastingVariant(double dblSrc, VARTYPE vtSrc = VT_R8)					// Creates a VT_R8, or a VT_DATE
			:_variant_t(dblSrc, vtSrc)
		{
			m_vtOperation = vt;
		}  
 
		inline CCastingVariant(COleDateTime dateSrc)									// Creates a VT_DATE
			:_variant_t((DATE)dateSrc, VT_DATE)
		{
			m_vtOperation = vt;
		}
 
		inline CCastingVariant(const CY& cySrc) throw()                                // Creates a VT_CY
			:_variant_t(cySrc)
		{
			m_vtOperation = vt;
		} 
 
		inline CCastingVariant(const _bstr_t& bstrSrc)                // Creates a VT_BSTR
			:_variant_t(bstrSrc)
		{
			m_vtOperation = vt;
		} 
 
		inline CCastingVariant(const wchar_t *pSrc)                   // Creates a VT_BSTR
			:_variant_t(pSrc)
		{
			m_vtOperation = vt;
		}  
 
		inline CCastingVariant(const char* pSrc)                     // Creates a VT_BSTR
			:_variant_t(pSrc)
		{
			m_vtOperation = vt;
		}  
 
		inline CCastingVariant(const CString& rSrc)                     // Creates a VT_BSTR
			:_variant_t(rSrc.GetString())
		{
			m_vtOperation = vt;
		}
 
		inline CCastingVariant(IDispatch* pSrc, bool fAddRef = true) throw()           // Creates a VT_DISPATCH
			:_variant_t(pSrc, fAddRef)
		{
			m_vtOperation = vt;
		}  
 
		inline CCastingVariant(bool boolSrc) throw()                                  // Creates a VT_BOOL
			:_variant_t(boolSrc)
		{
			m_vtOperation = vt;
		}  
 
		inline CCastingVariant(IUnknown* pSrc, bool fAddRef = true) throw()            // Creates a VT_UNKNOWN
			:_variant_t(pSrc, fAddRef)
		{
			m_vtOperation = vt;
		}
 
		inline CCastingVariant(const DECIMAL& decSrc) throw()                          // Creates a VT_DECIMAL
			:_variant_t(decSrc)
		{
			m_vtOperation = vt;
		}  
 
		inline CCastingVariant(BYTE bSrc) throw()                                      // Creates a VT_UI1
			:_variant_t(bSrc)
		{
			m_vtOperation = vt;
		}          
 
		inline CCastingVariant(char cSrc) throw()                                      // Creates a VT_I1
			:_variant_t(cSrc)
		{
			m_vtOperation = vt;
		}  
 
		inline CCastingVariant(unsigned short usSrc) throw()                           // Creates a VT_UI2
			:_variant_t(usSrc)
		{
			m_vtOperation = vt;
		}   
 
		inline CCastingVariant(unsigned long ulSrc) throw()                            // Creates a VT_UI4
			:_variant_t(ulSrc)
		{
			m_vtOperation = vt;
		}  
 
		inline CCastingVariant(int iSrc) throw()                                       // Creates a VT_INT
			:_variant_t(iSrc)
		{
			m_vtOperation = vt;
		} 
 
		inline CCastingVariant(unsigned int uiSrc) throw()                             // Creates a VT_UINT
			:_variant_t(uiSrc)
		{
			m_vtOperation = vt;
		} 
 
#if (_WIN32_WINNT >= 0x0501)
		inline CCastingVariant(__int64 i8Src) throw()                                  // Creates a VT_I8
			:_variant_t(i8Src)
		{
			m_vtOperation = vt;
		}  
 
		inline CCastingVariant(unsigned __int64 ui8Src) throw()                        // Creates a VT_UI8
			:_variant_t(ui8Src)
		{
			m_vtOperation = vt;
		}          
#endif
 
		// Destructor
		//
		~CCastingVariant() throw()
		{
		}
 
		// MCN Extractors
		//
 
		inline operator BaseType() const throw()
		{
			return *(BaseType*) this;
		}
 
		inline operator CString() const throw() // Extracts as CString object
		{
			_bstr_t bstr = *this;
			return CString(bstr.GetBSTR());
		}
 
		// base class doesn't extract a double as date so CMcnVariant do it itseft
		inline operator double() const // Extracts a double from a VT_R8 or a VT_DATE
		{
			if (V_VT(this) == VT_R8) {
				return V_R8(this); 
			}
			else if (V_VT(this) == VT_DATE) {
				return V_DATE(this); 
			}
 
			BaseType varDest;
			varDest.ChangeType(VT_R8, this);
 
			return V_R8(&varDest);
		}
 
		inline ThisType& operator=(const ThisType& varSrc)
		{
			const BaseType& varBaseSrc = varSrc;
			BaseType::operator=(varBaseSrc);
			m_vtOperation = varSrc.m_vtOperation;
			return *this;
		}
 
		inline ThisType& operator=(const CString& strSrc)    // Assign a CString
		{
			BaseType::operator=(strSrc);
			return *this;
		}
 
		inline ThisType& operator=(double dblSrc)			// Assign a double
		{
			BaseType::operator=(dblSrc);
			return *this;
		}
 
		inline ThisType& operator=(const COleDateTime& dateSrc)    // Assign a COleDateTime
		{
			BaseType::operator=((DATE)dateSrc);
			return *this;
		}
 
		// Comparison operations
		//
		VARTYPE m_vtOperation;
 
		inline bool operator<(const ThisType& varValue2) const throw()
		{
			const BaseType& Value2 = varValue2;
			const BaseType& Value1 = *this;
 
			switch(m_vtOperation)
			{
			case VT_I1:			return ((char)Value1 < (char)Value2)? true: false;
			case VT_I2:			return ((short)Value1 < (short)Value2)? true: false;
			case VT_I4:			return ((long)Value1 < (long)Value2)? true: false;
 
			case VT_CY:			return (((CY)Value1).int64 < ((CY)Value2).int64)? true: false;
			case VT_DECIMAL:	return (((DECIMAL)Value1).Lo64 < ((DECIMAL)Value2).Lo64)? true: false;
 
			case VT_UI1:		return ((BYTE)Value1 < (BYTE)Value2)? true: false;
			case VT_UI2:		return ((unsigned short)Value1 < (unsigned short)Value2)? true: false;
			case VT_UI4:		return ((unsigned long)Value1 < (unsigned long)Value2)? true: false;
 
			case VT_INT:		return ((int)Value1 < (int)Value2)? true: false;
			case VT_UINT:		return ((unsigned int)Value1 < (unsigned int)Value2)? true: false;
 
#if (_WIN32_WINNT >= 0x0501)
			case VT_I8:			return ((__int64)Value1 < (__int64)Value2)? true: false;
			case VT_UI8:		return ((unsigned __int64)Value1 < (unsigned __int64)Value2)? true: false;
#endif
 
			case VT_R4:			return ((float)Value1 < (float)Value2)? true: false;
			case VT_R8:			return ((double)Value1 < (double)Value2)? true: false;
			case VT_DATE:		return ((double)Value1 < (double)Value2)? true: false;
 
			case VT_BSTR:		return ((_bstr_t)Value1 < (_bstr_t)Value2)? true: false;
 
			default:
				ATLASSERT(FALSE);
				return false;
			}
		}
 
		inline bool operator>(const ThisType& varValue2) const throw()
		{
			const BaseType& Value2 = varValue2;
			const BaseType& Value1 = *this;
 
			switch(m_vtOperation)
			{
			case VT_I1:			return ((char)Value1 > (char)Value2)? true: false;
			case VT_I2:			return ((short)Value1 > (short)Value2)? true: false;
			case VT_I4:			return ((long)Value1 > (long)Value2)? true: false;
 
			case VT_CY:			return (((CY)Value1).int64 > ((CY)Value2).int64)? true: false;
			case VT_DECIMAL:	return (((DECIMAL)Value1).Lo64 > ((DECIMAL)Value2).Lo64)? true: false;
 
			case VT_UI1:		return ((BYTE)Value1 > (BYTE)Value2)? true: false;
			case VT_UI2:		return ((unsigned short)Value1 > (unsigned short)Value2)? true: false;
			case VT_UI4:		return ((unsigned long)Value1 > (unsigned long)Value2)? true: false;
 
			case VT_INT:		return ((int)Value1 > (int)Value2)? true: false;
			case VT_UINT:		return ((unsigned int)Value1 > (unsigned int)Value2)? true: false;
 
#if (_WIN32_WINNT >= 0x0501)
			case VT_I8:			return ((__int64)Value1 > (__int64)Value2)? true: false;
			case VT_UI8:		return ((unsigned __int64)Value1 > (unsigned __int64)Value2)? true: false;
#endif
 
			case VT_R4:			return ((float)Value1 > (float)Value2)? true: false;
			case VT_R8:			return ((double)Value1 > (double)Value2)? true: false;
			case VT_DATE:		return ((double)Value1 > (double)Value2)? true: false;
 
			case VT_BSTR:		return ((_bstr_t)Value1 > (_bstr_t)Value2)? true: false;
 
			default:
				ATLASSERT(FALSE);
				return false;
			}
		}
 
		inline bool operator<=(const ThisType& varValue2) const throw()
		{
			const BaseType& Value2 = varValue2;
			const BaseType& Value1 = *this;
 
			switch(m_vtOperation)
			{
			case VT_I1:			return ((char)Value1 <= (char)Value2)? true: false;
			case VT_I2:			return ((short)Value1 <= (short)Value2)? true: false;
			case VT_I4:			return ((long)Value1 <= (long)Value2)? true: false;
 
			case VT_CY:			return (((CY)Value1).int64 <= ((CY)Value2).int64)? true: false;
			case VT_DECIMAL:	return (((DECIMAL)Value1).Lo64 <= ((DECIMAL)Value2).Lo64)? true: false;
 
			case VT_UI1:		return ((BYTE)Value1 <= (BYTE)Value2)? true: false;
			case VT_UI2:		return ((unsigned short)Value1 <= (unsigned short)Value2)? true: false;
			case VT_UI4:		return ((unsigned long)Value1 <= (unsigned long)Value2)? true: false;
 
			case VT_INT:		return ((int)Value1 <= (int)Value2)? true: false;
			case VT_UINT:		return ((unsigned int)Value1 <= (unsigned int)Value2)? true: false;
 
#if (_WIN32_WINNT >= 0x0501)
			case VT_I8:			return ((__int64)Value1 <= (__int64)Value2)? true: false;
			case VT_UI8:		return ((unsigned __int64)Value1 <= (unsigned __int64)Value2)? true: false;
#endif
 
			case VT_R4:			return ((float)Value1 <= (float)Value2)? true: false;
			case VT_R8:			return ((double)Value1 <= (double)Value2)? true: false;
			case VT_DATE:		return ((double)Value1 <= (double)Value2)? true: false;
 
			case VT_BSTR:		return ((_bstr_t)Value1 <= (_bstr_t)Value2)? true: false;
 
			default:
				ATLASSERT(FALSE);
				return false;
			}
		}
 
		inline bool operator>=(const ThisType& varValue2) const throw()
		{
			const BaseType& Value2 = varValue2;
			const BaseType& Value1 = *this;
 
			switch(m_vtOperation)
			{
			case VT_I1:			return ((char)Value1 >= (char)Value2)? true: false;
			case VT_I2:			return ((short)Value1 >= (short)Value2)? true: false;
			case VT_I4:			return ((long)Value1 >= (long)Value2)? true: false;
 
			case VT_CY:			return (((CY)Value1).int64 >= ((CY)Value2).int64)? true: false;
			case VT_DECIMAL:	return (((DECIMAL)Value1).Lo64 >= ((DECIMAL)Value2).Lo64)? true: false;
 
			case VT_UI1:		return ((BYTE)Value1 >= (BYTE)Value2)? true: false;
			case VT_UI2:		return ((unsigned short)Value1 >= (unsigned short)Value2)? true: false;
			case VT_UI4:		return ((unsigned long)Value1 >= (unsigned long)Value2)? true: false;
 
			case VT_INT:		return ((int)Value1 >= (int)Value2)? true: false;
			case VT_UINT:		return ((unsigned int)Value1 >= (unsigned int)Value2)? true: false;
 
#if (_WIN32_WINNT >= 0x0501)
			case VT_I8:			return ((__int64)Value1 >= (__int64)Value2)? true: false;
			case VT_UI8:		return ((unsigned __int64)Value1 >= (unsigned __int64)Value2)? true: false;
#endif
 
			case VT_R4:			return ((float)Value1 >= (float)Value2)? true: false;
			case VT_R8:			return ((double)Value1 >= (double)Value2)? true: false;
			case VT_DATE:		return ((double)Value1 >= (double)Value2)? true: false;
 
			case VT_BSTR:		return ((_bstr_t)Value1 >= (_bstr_t)Value2)? true: false;
 
			default:
				ATLASSERT(FALSE);
				return false;
			}
		}
 
		static T* CastFromVariant(VARIANT var)
		{
			if(var.vt != VT_BYREF || var.byref == NULL)
				return NULL;
			return (T*) var.byref;
		}
 
		static VARIANT CastToVariant(T* pT)
		{
			if(pT == NULL)
				return CComVariant();
 
			VARIANT var;
			var.byref = (void*) pT;
			var.vt = VT_BYREF;
			return var;
		}
 
	};  // class CCastingVariant
 
 
	typedef CCastingVariant<void> CMcnVariant;