SeraphyScriptToolsCP.h

   1 #pragma once
   2
   3 template <class T>
   4 class CProxy_IOverlappedWindowEvents : public IConnectionPointImpl<T, &DIID__IOverlappedWindowEvents, CComDynamicUnkArray>
   5 {
   6         //Warning this class may be recreated by the wizard.
   7 public:
   8         HRESULT Fire_OnClick()
   9         {
  10                 CComVariant varResult;
  11                 T* pT = static_cast<T*>(this);
  12                 int nConnectionIndex;
  13                 int nConnections = m_vec.GetSize();
  14
  15                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
  16                         pT->Lock();
  17                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
  18                         pT->Unlock();
  19                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
  20                         if (pDispatch != NULL) {
  21                                 VariantClear(&varResult);
  22                                 DISPPARAMS disp = {NULL, NULL, 0, 0};
  23                                 pDispatch->Invoke(0xa, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
  24                         }
  25                 }
  26                 return varResult.scode;
  27
  28         }
  29         HRESULT Fire_OnRClick()
  30         {
  31                 CComVariant varResult;
  32                 T* pT = static_cast<T*>(this);
  33                 int nConnectionIndex;
  34                 int nConnections = m_vec.GetSize();
  35
  36                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
  37                         pT->Lock();
  38                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
  39                         pT->Unlock();
  40                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
  41                         if (pDispatch != NULL) {
  42                                 VariantClear(&varResult);
  43                                 DISPPARAMS disp = {NULL, NULL, 0, 0};
  44                                 pDispatch->Invoke(0xb, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
  45                         }
  46                 }
  47                 return varResult.scode;
  48
  49         }
  50         HRESULT Fire_OnDblClick()
  51         {
  52                 CComVariant varResult;
  53                 T* pT = static_cast<T*>(this);
  54                 int nConnectionIndex;
  55                 int nConnections = m_vec.GetSize();
  56
  57                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
  58                         pT->Lock();
  59                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
  60                         pT->Unlock();
  61                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
  62                         if (pDispatch != NULL) {
  63                                 VariantClear(&varResult);
  64                                 DISPPARAMS disp = {NULL, NULL, 0, 0};
  65                                 pDispatch->Invoke(0xc, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
  66                         }
  67                 }
  68                 return varResult.scode;
  69
  70         }
  71         HRESULT Fire_OnRDblClick()
  72         {
  73                 CComVariant varResult;
  74                 T* pT = static_cast<T*>(this);
  75                 int nConnectionIndex;
  76                 int nConnections = m_vec.GetSize();
  77
  78                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
  79                         pT->Lock();
  80                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
  81                         pT->Unlock();
  82                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
  83                         if (pDispatch != NULL) {
  84                                 VariantClear(&varResult);
  85                                 DISPPARAMS disp = {NULL, NULL, 0, 0};
  86                                 pDispatch->Invoke(0xd, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
  87                         }
  88                 }
  89                 return varResult.scode;
  90
  91         }
  92         HRESULT Fire_OnSize()
  93         {
  94                 CComVariant varResult;
  95                 T* pT = static_cast<T*>(this);
  96                 int nConnectionIndex;
  97                 int nConnections = m_vec.GetSize();
  98
  99                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 100                         pT->Lock();
 101                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 102                         pT->Unlock();
 103                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 104                         if (pDispatch != NULL) {
 105                                 VariantClear(&varResult);
 106                                 DISPPARAMS disp = {NULL, NULL, 0, 0};
 107                                 pDispatch->Invoke(0xe, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 108                         }
 109                 }
 110                 return varResult.scode;
 111
 112         }
 113         HRESULT Fire_OnCommand()
 114         {
 115                 CComVariant varResult;
 116                 T* pT = static_cast<T*>(this);
 117                 int nConnectionIndex;
 118                 int nConnections = m_vec.GetSize();
 119
 120                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 121                         pT->Lock();
 122                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 123                         pT->Unlock();
 124                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 125                         if (pDispatch != NULL) {
 126                                 VariantClear(&varResult);
 127                                 DISPPARAMS disp = {NULL, NULL, 0, 0};
 128                                 pDispatch->Invoke(0xf, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 129                         }
 130                 }
 131                 return varResult.scode;
 132
 133         }
 134         HRESULT Fire_OnDropFiles()
 135         {
 136                 CComVariant varResult;
 137                 T* pT = static_cast<T*>(this);
 138                 int nConnectionIndex;
 139                 int nConnections = m_vec.GetSize();
 140
 141                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 142                         pT->Lock();
 143                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 144                         pT->Unlock();
 145                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 146                         if (pDispatch != NULL) {
 147                                 VariantClear(&varResult);
 148                                 DISPPARAMS disp = {NULL, NULL, 0, 0};
 149                                 pDispatch->Invoke(0x10, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 150                         }
 151                 }
 152                 return varResult.scode;
 153
 154         }
 155         HRESULT Fire_OnMouseMove()
 156         {
 157                 CComVariant varResult;
 158                 T* pT = static_cast<T*>(this);
 159                 int nConnectionIndex;
 160                 int nConnections = m_vec.GetSize();
 161
 162                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 163                         pT->Lock();
 164                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 165                         pT->Unlock();
 166                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 167                         if (pDispatch != NULL) {
 168                                 VariantClear(&varResult);
 169                                 DISPPARAMS disp = {NULL, NULL, 0, 0};
 170                                 pDispatch->Invoke(0x11, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 171                         }
 172                 }
 173                 return varResult.scode;
 174
 175         }
 176         HRESULT Fire_OnClickOut()
 177         {
 178                 CComVariant varResult;
 179                 T* pT = static_cast<T*>(this);
 180                 int nConnectionIndex;
 181                 int nConnections = m_vec.GetSize();
 182
 183                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 184                         pT->Lock();
 185                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 186                         pT->Unlock();
 187                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 188                         if (pDispatch != NULL) {
 189                                 VariantClear(&varResult);
 190                                 DISPPARAMS disp = {NULL, NULL, 0, 0};
 191                                 pDispatch->Invoke(0x12, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 192                         }
 193                 }
 194                 return varResult.scode;
 195
 196         }
 197         HRESULT Fire_OnRClickOut()
 198         {
 199                 CComVariant varResult;
 200                 T* pT = static_cast<T*>(this);
 201                 int nConnectionIndex;
 202                 int nConnections = m_vec.GetSize();
 203
 204                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 205                         pT->Lock();
 206                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 207                         pT->Unlock();
 208                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 209                         if (pDispatch != NULL) {
 210                                 VariantClear(&varResult);
 211                                 DISPPARAMS disp = {NULL, NULL, 0, 0};
 212                                 pDispatch->Invoke(0x13, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 213                         }
 214                 }
 215                 return varResult.scode;
 216
 217         }
 218         HRESULT Fire_OnClickCancel()
 219         {
 220                 CComVariant varResult;
 221                 T* pT = static_cast<T*>(this);
 222                 int nConnectionIndex;
 223                 int nConnections = m_vec.GetSize();
 224
 225                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 226                         pT->Lock();
 227                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 228                         pT->Unlock();
 229                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 230                         if (pDispatch != NULL) {
 231                                 VariantClear(&varResult);
 232                                 DISPPARAMS disp = {NULL, NULL, 0, 0};
 233                                 pDispatch->Invoke(0x14, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 234                         }
 235                 }
 236                 return varResult.scode;
 237
 238         }
 239         HRESULT Fire_OnRClickCancel()
 240         {
 241                 CComVariant varResult;
 242                 T* pT = static_cast<T*>(this);
 243                 int nConnectionIndex;
 244                 int nConnections = m_vec.GetSize();
 245
 246                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 247                         pT->Lock();
 248                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 249                         pT->Unlock();
 250                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 251                         if (pDispatch != NULL) {
 252                                 VariantClear(&varResult);
 253                                 DISPPARAMS disp = {NULL, NULL, 0, 0};
 254                                 pDispatch->Invoke(0x15, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 255                         }
 256                 }
 257                 return varResult.scode;
 258
 259         }
 260         HRESULT Fire_OnTimer()
 261         {
 262                 CComVariant varResult;
 263                 T* pT = static_cast<T*>(this);
 264                 int nConnectionIndex;
 265                 int nConnections = m_vec.GetSize();
 266
 267                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 268                         pT->Lock();
 269                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 270                         pT->Unlock();
 271                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 272                         if (pDispatch != NULL) {
 273                                 VariantClear(&varResult);
 274                                 DISPPARAMS disp = {NULL, NULL, 0, 0};
 275                                 pDispatch->Invoke(0x16, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 276                         }
 277                 }
 278                 return varResult.scode;
 279
 280         }
 281         HRESULT Fire_OnOK()
 282         {
 283                 CComVariant varResult;
 284                 T* pT = static_cast<T*>(this);
 285                 int nConnectionIndex;
 286                 int nConnections = m_vec.GetSize();
 287
 288                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 289                         pT->Lock();
 290                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 291                         pT->Unlock();
 292                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 293                         if (pDispatch != NULL) {
 294                                 VariantClear(&varResult);
 295                                 DISPPARAMS disp = {NULL, NULL, 0, 0};
 296                                 pDispatch->Invoke(0x17, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 297                         }
 298                 }
 299                 return varResult.scode;
 300
 301         }
 302         HRESULT Fire_OnCancel()
 303         {
 304                 CComVariant varResult;
 305                 T* pT = static_cast<T*>(this);
 306                 int nConnectionIndex;
 307                 int nConnections = m_vec.GetSize();
 308
 309                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 310                         pT->Lock();
 311                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 312                         pT->Unlock();
 313                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 314                         if (pDispatch != NULL) {
 315                                 VariantClear(&varResult);
 316                                 DISPPARAMS disp = {NULL, NULL, 0, 0};
 317                                 pDispatch->Invoke(0x18, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 318                         }
 319                 }
 320                 return varResult.scode;
 321
 322         }
 323         HRESULT Fire_OnExit()
 324         {
 325                 CComVariant varResult;
 326                 T* pT = static_cast<T*>(this);
 327                 int nConnectionIndex;
 328                 int nConnections = m_vec.GetSize();
 329
 330                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 331                         pT->Lock();
 332                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 333                         pT->Unlock();
 334                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 335                         if (pDispatch != NULL) {
 336                                 VariantClear(&varResult);
 337                                 DISPPARAMS disp = {NULL, NULL, 0, 0};
 338                                 pDispatch->Invoke(0x19, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 339                         }
 340                 }
 341                 return varResult.scode;
 342
 343         }
 344         HRESULT Fire_InitWindow()
 345         {
 346                 CComVariant varResult;
 347                 T* pT = static_cast<T*>(this);
 348                 int nConnectionIndex;
 349                 int nConnections = m_vec.GetSize();
 350
 351                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 352                         pT->Lock();
 353                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 354                         pT->Unlock();
 355                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 356                         if (pDispatch != NULL) {
 357                                 VariantClear(&varResult);
 358                                 DISPPARAMS disp = {NULL, NULL, 0, 0};
 359                                 pDispatch->Invoke(0x1a, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 360                         }
 361                 }
 362                 return varResult.scode;
 363
 364         }
 365         HRESULT Fire_ExitWindow()
 366         {
 367                 CComVariant varResult;
 368                 T* pT = static_cast<T*>(this);
 369                 int nConnectionIndex;
 370                 int nConnections = m_vec.GetSize();
 371
 372                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 373                         pT->Lock();
 374                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 375                         pT->Unlock();
 376                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 377                         if (pDispatch != NULL) {
 378                                 VariantClear(&varResult);
 379                                 DISPPARAMS disp = {NULL, NULL, 0, 0};
 380                                 pDispatch->Invoke(0x1b, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 381                         }
 382                 }
 383                 return varResult.scode;
 384
 385         }
 386         HRESULT Fire_OnClickEx(IUnknown * varObj)
 387         {
 388                 CComVariant varResult;
 389                 T* pT = static_cast<T*>(this);
 390                 int nConnectionIndex;
 391                 CComVariant* pvars = new CComVariant[1];
 392                 int nConnections = m_vec.GetSize();
 393
 394                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 395                         pT->Lock();
 396                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 397                         pT->Unlock();
 398                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 399                         if (pDispatch != NULL) {
 400                                 VariantClear(&varResult);
 401                                 pvars[0] = varObj;
 402                                 DISPPARAMS disp = {pvars, NULL, 1, 0};
 403                                 pDispatch->Invoke(0x6e, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 404                         }
 405                 }
 406                 delete[] pvars;
 407                 return varResult.scode;
 408
 409         }
 410         HRESULT Fire_OnRClickEx(IUnknown * varObj)
 411         {
 412                 CComVariant varResult;
 413                 T* pT = static_cast<T*>(this);
 414                 int nConnectionIndex;
 415                 CComVariant* pvars = new CComVariant[1];
 416                 int nConnections = m_vec.GetSize();
 417
 418                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 419                         pT->Lock();
 420                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 421                         pT->Unlock();
 422                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 423                         if (pDispatch != NULL) {
 424                                 VariantClear(&varResult);
 425                                 pvars[0] = varObj;
 426                                 DISPPARAMS disp = {pvars, NULL, 1, 0};
 427                                 pDispatch->Invoke(0x6f, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 428                         }
 429                 }
 430                 delete[] pvars;
 431                 return varResult.scode;
 432
 433         }
 434         HRESULT Fire_OnDblClickEx(IUnknown * varObj)
 435         {
 436                 CComVariant varResult;
 437                 T* pT = static_cast<T*>(this);
 438                 int nConnectionIndex;
 439                 CComVariant* pvars = new CComVariant[1];
 440                 int nConnections = m_vec.GetSize();
 441
 442                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 443                         pT->Lock();
 444                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 445                         pT->Unlock();
 446                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 447                         if (pDispatch != NULL) {
 448                                 VariantClear(&varResult);
 449                                 pvars[0] = varObj;
 450                                 DISPPARAMS disp = {pvars, NULL, 1, 0};
 451                                 pDispatch->Invoke(0x70, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 452                         }
 453                 }
 454                 delete[] pvars;
 455                 return varResult.scode;
 456
 457         }
 458         HRESULT Fire_OnRDblClickEx(IUnknown * varObj)
 459         {
 460                 CComVariant varResult;
 461                 T* pT = static_cast<T*>(this);
 462                 int nConnectionIndex;
 463                 CComVariant* pvars = new CComVariant[1];
 464                 int nConnections = m_vec.GetSize();
 465
 466                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 467                         pT->Lock();
 468                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 469                         pT->Unlock();
 470                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 471                         if (pDispatch != NULL) {
 472                                 VariantClear(&varResult);
 473                                 pvars[0] = varObj;
 474                                 DISPPARAMS disp = {pvars, NULL, 1, 0};
 475                                 pDispatch->Invoke(0x71, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 476                         }
 477                 }
 478                 delete[] pvars;
 479                 return varResult.scode;
 480
 481         }
 482         HRESULT Fire_OnSizeEx(IUnknown * varObj)
 483         {
 484                 CComVariant varResult;
 485                 T* pT = static_cast<T*>(this);
 486                 int nConnectionIndex;
 487                 CComVariant* pvars = new CComVariant[1];
 488                 int nConnections = m_vec.GetSize();
 489
 490                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 491                         pT->Lock();
 492                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 493                         pT->Unlock();
 494                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 495                         if (pDispatch != NULL) {
 496                                 VariantClear(&varResult);
 497                                 pvars[0] = varObj;
 498                                 DISPPARAMS disp = {pvars, NULL, 1, 0};
 499                                 pDispatch->Invoke(0x72, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 500                         }
 501                 }
 502                 delete[] pvars;
 503                 return varResult.scode;
 504
 505         }
 506         HRESULT Fire_OnCommandEx(IUnknown * varObj)
 507         {
 508                 CComVariant varResult;
 509                 T* pT = static_cast<T*>(this);
 510                 int nConnectionIndex;
 511                 CComVariant* pvars = new CComVariant[1];
 512                 int nConnections = m_vec.GetSize();
 513
 514                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 515                         pT->Lock();
 516                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 517                         pT->Unlock();
 518                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 519                         if (pDispatch != NULL) {
 520                                 VariantClear(&varResult);
 521                                 pvars[0] = varObj;
 522                                 DISPPARAMS disp = {pvars, NULL, 1, 0};
 523                                 pDispatch->Invoke(0x73, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 524                         }
 525                 }
 526                 delete[] pvars;
 527                 return varResult.scode;
 528
 529         }
 530         HRESULT Fire_OnDropFilesEx(IUnknown * varObj)
 531         {
 532                 CComVariant varResult;
 533                 T* pT = static_cast<T*>(this);
 534                 int nConnectionIndex;
 535                 CComVariant* pvars = new CComVariant[1];
 536                 int nConnections = m_vec.GetSize();
 537
 538                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 539                         pT->Lock();
 540                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 541                         pT->Unlock();
 542                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 543                         if (pDispatch != NULL) {
 544                                 VariantClear(&varResult);
 545                                 pvars[0] = varObj;
 546                                 DISPPARAMS disp = {pvars, NULL, 1, 0};
 547                                 pDispatch->Invoke(0x74, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 548                         }
 549                 }
 550                 delete[] pvars;
 551                 return varResult.scode;
 552
 553         }
 554         HRESULT Fire_OnMouseMoveEx(IUnknown * varObj)
 555         {
 556                 CComVariant varResult;
 557                 T* pT = static_cast<T*>(this);
 558                 int nConnectionIndex;
 559                 CComVariant* pvars = new CComVariant[1];
 560                 int nConnections = m_vec.GetSize();
 561
 562                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 563                         pT->Lock();
 564                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 565                         pT->Unlock();
 566                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 567                         if (pDispatch != NULL) {
 568                                 VariantClear(&varResult);
 569                                 pvars[0] = varObj;
 570                                 DISPPARAMS disp = {pvars, NULL, 1, 0};
 571                                 pDispatch->Invoke(0x75, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 572                         }
 573                 }
 574                 delete[] pvars;
 575                 return varResult.scode;
 576
 577         }
 578         HRESULT Fire_OnClickOutEx(IUnknown * varObj)
 579         {
 580                 CComVariant varResult;
 581                 T* pT = static_cast<T*>(this);
 582                 int nConnectionIndex;
 583                 CComVariant* pvars = new CComVariant[1];
 584                 int nConnections = m_vec.GetSize();
 585
 586                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 587                         pT->Lock();
 588                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 589                         pT->Unlock();
 590                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 591                         if (pDispatch != NULL) {
 592                                 VariantClear(&varResult);
 593                                 pvars[0] = varObj;
 594                                 DISPPARAMS disp = {pvars, NULL, 1, 0};
 595                                 pDispatch->Invoke(0x76, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 596                         }
 597                 }
 598                 delete[] pvars;
 599                 return varResult.scode;
 600
 601         }
 602         HRESULT Fire_OnRClickOutEx(IUnknown * varObj)
 603         {
 604                 CComVariant varResult;
 605                 T* pT = static_cast<T*>(this);
 606                 int nConnectionIndex;
 607                 CComVariant* pvars = new CComVariant[1];
 608                 int nConnections = m_vec.GetSize();
 609
 610                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 611                         pT->Lock();
 612                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 613                         pT->Unlock();
 614                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 615                         if (pDispatch != NULL) {
 616                                 VariantClear(&varResult);
 617                                 pvars[0] = varObj;
 618                                 DISPPARAMS disp = {pvars, NULL, 1, 0};
 619                                 pDispatch->Invoke(0x77, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 620                         }
 621                 }
 622                 delete[] pvars;
 623                 return varResult.scode;
 624
 625         }
 626         HRESULT Fire_OnClickCancelEx(IUnknown * varObj)
 627         {
 628                 CComVariant varResult;
 629                 T* pT = static_cast<T*>(this);
 630                 int nConnectionIndex;
 631                 CComVariant* pvars = new CComVariant[1];
 632                 int nConnections = m_vec.GetSize();
 633
 634                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 635                         pT->Lock();
 636                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 637                         pT->Unlock();
 638                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 639                         if (pDispatch != NULL) {
 640                                 VariantClear(&varResult);
 641                                 pvars[0] = varObj;
 642                                 DISPPARAMS disp = {pvars, NULL, 1, 0};
 643                                 pDispatch->Invoke(0x78, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 644                         }
 645                 }
 646                 delete[] pvars;
 647                 return varResult.scode;
 648
 649         }
 650         HRESULT Fire_OnRClickCancelEx(IUnknown * varObj)
 651         {
 652                 CComVariant varResult;
 653                 T* pT = static_cast<T*>(this);
 654                 int nConnectionIndex;
 655                 CComVariant* pvars = new CComVariant[1];
 656                 int nConnections = m_vec.GetSize();
 657
 658                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 659                         pT->Lock();
 660                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 661                         pT->Unlock();
 662                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 663                         if (pDispatch != NULL) {
 664                                 VariantClear(&varResult);
 665                                 pvars[0] = varObj;
 666                                 DISPPARAMS disp = {pvars, NULL, 1, 0};
 667                                 pDispatch->Invoke(0x79, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 668                         }
 669                 }
 670                 delete[] pvars;
 671                 return varResult.scode;
 672
 673         }
 674         HRESULT Fire_OnTimerEx(IUnknown * varObj)
 675         {
 676                 CComVariant varResult;
 677                 T* pT = static_cast<T*>(this);
 678                 int nConnectionIndex;
 679                 CComVariant* pvars = new CComVariant[1];
 680                 int nConnections = m_vec.GetSize();
 681
 682                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 683                         pT->Lock();
 684                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 685                         pT->Unlock();
 686                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 687                         if (pDispatch != NULL) {
 688                                 VariantClear(&varResult);
 689                                 pvars[0] = varObj;
 690                                 DISPPARAMS disp = {pvars, NULL, 1, 0};
 691                                 pDispatch->Invoke(0x7a, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 692                         }
 693                 }
 694                 delete[] pvars;
 695                 return varResult.scode;
 696
 697         }
 698         HRESULT Fire_OnOKEx(IUnknown * varObj)
 699         {
 700                 CComVariant varResult;
 701                 T* pT = static_cast<T*>(this);
 702                 int nConnectionIndex;
 703                 CComVariant* pvars = new CComVariant[1];
 704                 int nConnections = m_vec.GetSize();
 705
 706                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 707                         pT->Lock();
 708                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 709                         pT->Unlock();
 710                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 711                         if (pDispatch != NULL) {
 712                                 VariantClear(&varResult);
 713                                 pvars[0] = varObj;
 714                                 DISPPARAMS disp = {pvars, NULL, 1, 0};
 715                                 pDispatch->Invoke(0x7b, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 716                         }
 717                 }
 718                 delete[] pvars;
 719                 return varResult.scode;
 720
 721         }
 722         HRESULT Fire_OnCancelEx(IUnknown * varObj)
 723         {
 724                 CComVariant varResult;
 725                 T* pT = static_cast<T*>(this);
 726                 int nConnectionIndex;
 727                 CComVariant* pvars = new CComVariant[1];
 728                 int nConnections = m_vec.GetSize();
 729
 730                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 731                         pT->Lock();
 732                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 733                         pT->Unlock();
 734                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 735                         if (pDispatch != NULL) {
 736                                 VariantClear(&varResult);
 737                                 pvars[0] = varObj;
 738                                 DISPPARAMS disp = {pvars, NULL, 1, 0};
 739                                 pDispatch->Invoke(0x7c, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 740                         }
 741                 }
 742                 delete[] pvars;
 743                 return varResult.scode;
 744
 745         }
 746         HRESULT Fire_OnExitEx(IUnknown * varObj)
 747         {
 748                 CComVariant varResult;
 749                 T* pT = static_cast<T*>(this);
 750                 int nConnectionIndex;
 751                 CComVariant* pvars = new CComVariant[1];
 752                 int nConnections = m_vec.GetSize();
 753
 754                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 755                         pT->Lock();
 756                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 757                         pT->Unlock();
 758                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 759                         if (pDispatch != NULL) {
 760                                 VariantClear(&varResult);
 761                                 pvars[0] = varObj;
 762                                 DISPPARAMS disp = {pvars, NULL, 1, 0};
 763                                 pDispatch->Invoke(0x7d, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 764                         }
 765                 }
 766                 delete[] pvars;
 767                 return varResult.scode;
 768
 769         }
 770         HRESULT Fire_InitWindowEx(IUnknown * varObj)
 771         {
 772                 CComVariant varResult;
 773                 T* pT = static_cast<T*>(this);
 774                 int nConnectionIndex;
 775                 CComVariant* pvars = new CComVariant[1];
 776                 int nConnections = m_vec.GetSize();
 777
 778                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 779                         pT->Lock();
 780                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 781                         pT->Unlock();
 782                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 783                         if (pDispatch != NULL) {
 784                                 VariantClear(&varResult);
 785                                 pvars[0] = varObj;
 786                                 DISPPARAMS disp = {pvars, NULL, 1, 0};
 787                                 pDispatch->Invoke(0x7e, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 788                         }
 789                 }
 790                 delete[] pvars;
 791                 return varResult.scode;
 792
 793         }
 794         HRESULT Fire_ExitWindowEx(IUnknown * varObj)
 795         {
 796                 CComVariant varResult;
 797                 T* pT = static_cast<T*>(this);
 798                 int nConnectionIndex;
 799                 CComVariant* pvars = new CComVariant[1];
 800                 int nConnections = m_vec.GetSize();
 801
 802                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 803                         pT->Lock();
 804                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 805                         pT->Unlock();
 806                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 807                         if (pDispatch != NULL) {
 808                                 VariantClear(&varResult);
 809                                 pvars[0] = varObj;
 810                                 DISPPARAMS disp = {pvars, NULL, 1, 0};
 811                                 pDispatch->Invoke(0x7f, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 812                         }
 813                 }
 814                 delete[] pvars;
 815                 return varResult.scode;
 816
 817         }
 818         HRESULT Fire_OnContextMenu()
 819         {
 820                 CComVariant varResult;
 821                 T* pT = static_cast<T*>(this);
 822                 int nConnectionIndex;
 823                 int nConnections = m_vec.GetSize();
 824
 825                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 826                         pT->Lock();
 827                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 828                         pT->Unlock();
 829                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 830                         if (pDispatch != NULL) {
 831                                 VariantClear(&varResult);
 832                                 DISPPARAMS disp = {NULL, NULL, 0, 0};
 833                                 pDispatch->Invoke(0x80, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 834                         }
 835                 }
 836                 return varResult.scode;
 837
 838         }
 839         HRESULT Fire_OnContextMenuEx(IUnknown * punkVal)
 840         {
 841                 CComVariant varResult;
 842                 T* pT = static_cast<T*>(this);
 843                 int nConnectionIndex;
 844                 CComVariant* pvars = new CComVariant[1];
 845                 int nConnections = m_vec.GetSize();
 846
 847                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 848                         pT->Lock();
 849                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 850                         pT->Unlock();
 851                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 852                         if (pDispatch != NULL) {
 853                                 VariantClear(&varResult);
 854                                 pvars[0] = punkVal;
 855                                 DISPPARAMS disp = {pvars, NULL, 1, 0};
 856                                 pDispatch->Invoke(0x81, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 857                         }
 858                 }
 859                 delete[] pvars;
 860                 return varResult.scode;
 861
 862         }
 863         HRESULT Fire_OnContextDelete()
 864         {
 865                 CComVariant varResult;
 866                 T* pT = static_cast<T*>(this);
 867                 int nConnectionIndex;
 868                 int nConnections = m_vec.GetSize();
 869
 870                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 871                         pT->Lock();
 872                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 873                         pT->Unlock();
 874                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 875                         if (pDispatch != NULL) {
 876                                 VariantClear(&varResult);
 877                                 DISPPARAMS disp = {NULL, NULL, 0, 0};
 878                                 pDispatch->Invoke(0x82, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 879                         }
 880                 }
 881                 return varResult.scode;
 882
 883         }
 884         HRESULT Fire_OnContextDeleteEx(IUnknown * punkVal)
 885         {
 886                 CComVariant varResult;
 887                 T* pT = static_cast<T*>(this);
 888                 int nConnectionIndex;
 889                 CComVariant* pvars = new CComVariant[1];
 890                 int nConnections = m_vec.GetSize();
 891
 892                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 893                         pT->Lock();
 894                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 895                         pT->Unlock();
 896                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 897                         if (pDispatch != NULL) {
 898                                 VariantClear(&varResult);
 899                                 pvars[0] = punkVal;
 900                                 DISPPARAMS disp = {pvars, NULL, 1, 0};
 901                                 pDispatch->Invoke(0x83, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 902                         }
 903                 }
 904                 delete[] pvars;
 905                 return varResult.scode;
 906
 907         }
 908         HRESULT Fire_OnKeydown()
 909         {
 910                 CComVariant varResult;
 911                 T* pT = static_cast<T*>(this);
 912                 int nConnectionIndex;
 913                 int nConnections = m_vec.GetSize();
 914
 915                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 916                         pT->Lock();
 917                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 918                         pT->Unlock();
 919                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 920                         if (pDispatch != NULL) {
 921                                 VariantClear(&varResult);
 922                                 DISPPARAMS disp = {NULL, NULL, 0, 0};
 923                                 pDispatch->Invoke(0x84, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 924                         }
 925                 }
 926                 return varResult.scode;
 927
 928         }
 929         HRESULT Fire_OnKeydownEx(IUnknown * punkVal)
 930         {
 931                 CComVariant varResult;
 932                 T* pT = static_cast<T*>(this);
 933                 int nConnectionIndex;
 934                 CComVariant* pvars = new CComVariant[1];
 935                 int nConnections = m_vec.GetSize();
 936
 937                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 938                         pT->Lock();
 939                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 940                         pT->Unlock();
 941                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 942                         if (pDispatch != NULL) {
 943                                 VariantClear(&varResult);
 944                                 pvars[0] = punkVal;
 945                                 DISPPARAMS disp = {pvars, NULL, 1, 0};
 946                                 pDispatch->Invoke(0x85, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 947                         }
 948                 }
 949                 delete[] pvars;
 950                 return varResult.scode;
 951
 952         }
 953         HRESULT Fire_OnKeydown2()
 954         {
 955                 CComVariant varResult;
 956                 T* pT = static_cast<T*>(this);
 957                 int nConnectionIndex;
 958                 int nConnections = m_vec.GetSize();
 959
 960                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 961                         pT->Lock();
 962                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 963                         pT->Unlock();
 964                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 965                         if (pDispatch != NULL) {
 966                                 VariantClear(&varResult);
 967                                 DISPPARAMS disp = {NULL, NULL, 0, 0};
 968                                 pDispatch->Invoke(0x86, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 969                         }
 970                 }
 971                 return varResult.scode;
 972
 973         }
 974         HRESULT Fire_OnKeydown2Ex(IUnknown * punkVal)
 975         {
 976                 CComVariant varResult;
 977                 T* pT = static_cast<T*>(this);
 978                 int nConnectionIndex;
 979                 CComVariant* pvars = new CComVariant[1];
 980                 int nConnections = m_vec.GetSize();
 981
 982                 for (nConnectionIndex = 0; nConnectionIndex < nConnections; nConnectionIndex++) {
 983                         pT->Lock();
 984                         CComPtr<IUnknown> sp = m_vec.GetAt(nConnectionIndex);
 985                         pT->Unlock();
 986                         IDispatch* pDispatch = reinterpret_cast<IDispatch*>(sp.p);
 987                         if (pDispatch != NULL) {
 988                                 VariantClear(&varResult);
 989                                 pvars[0] = punkVal;
 990                                 DISPPARAMS disp = {pvars, NULL, 1, 0};
 991                                 pDispatch->Invoke(0x87, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, &varResult, NULL, NULL);
 992                         }
 993                 }
 994                 delete[] pvars;
 995                 return varResult.scode;
 996
 997         }
 998 };