Club Builder - Foros de discusión Club Builder
Foro de C++Builder en español
 
 FAQFAQ   BuscarBuscar   MiembrosMiembros   Grupos de UsuariosGrupos de Usuarios   RegistrarseRegistrarse 
 PerfilPerfil   Entra para ver tus mensajes privadosEntra para ver tus mensajes privados   EntrarEntrar 

Inventario de Hardware automatizado (solucionado)

 
Publicar nuevo tema   Responder al tema    Foros de discusión -> Consultas
Ver tema anterior :: Ver tema siguiente  
Autor Mensaje
Mensaje    Asunto: Inventario de Hardware automatizado (solucionado) Responder citando

Hola foro, aqui les explico mi duda:
Quiero hacer una aplicacion que logre obtener la siguiente informacion de cierto equipo:

Driver de:
-Video
-Sonido
-LAN
-Modem
-Monitor,etc
Modelo de Placa Madre.-

He visto recientemente una aplicacion q hace todo esto sin tener siquiera un cliente en el equipo remoto, como? no tengo idea,

En todo caso las respuestas me sirven tanto para el equipo local, como para uno remoto.

De antemano muchisimas gracias....
Volver arriba
Mensaje    Asunto: Responder citando

Hace tiempo, navegando por Internet encontre las "win32 classes" en la pagina de microsoft (http://msdn.microsoft.com/) en ellas explicaba como acceder a practicamente todo lo relacionado con windows, entre ellas todo lo que tiene que ver con el hardware. Intente utilizarlas pero no lo logre y desde entonces no he tenido tiempo de retomar la cuestion. De hecho ahora que ha salido el tema a ver si alguien explica como aplicarlas.

En fin empieza mirando por aqui.

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/sms/hh/sms/refsms22_3lir.asp

O bien en el buscador de la pagina de microsoft con "win32 classes".

Bueno que tengas suerte.
Y lo dicho a ver si alguien explica como utilizar las win32 classes.
Volver arriba
Mensaje    Asunto: Responder citando

Gracias por tu respuesta, ya estoy leyendo....
Cita:
De hecho ahora que ha salido el tema a ver si alguien explica como aplicarlas.

Si alguien por ahi sabe como utilizar esta informacion, agradeceria sus aportes Wink
GRACIAS!!
Volver arriba
Mensaje    Asunto: Responder citando

Hola a todos, por fin he dado con una solucion, la publico por si le es de utilidad a alguien:

Solo necesitan 2 ListBox, 1 Memo, 1 Edit y un Button.-

Código:

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
#include "Unit2.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;


#define sizIO_HEADER  28
#define sizDMA_HEADER 16
#define sizIRQ_HEADER 20
#define sizMEM_HEADER 32

#define MAX_DEV_LEN 1000

#define ResType_Mem 0x00000001
#define ResType_IO  0x00000002
#define ResType_DMA 0x00000003
#define ResType_IRQ 0x00000004

#define CR_SUCCESS  0
#define CR_NO_MORE_LOG_CONF     0x0000000E
#define CR_BUFFER_SMALL         0x0000001A

#define CR_NO_SUCH_VALUE        (0x00000025)
#define CR_INVALID_DATA         (0x0000001F)

HINSTANCE CfgMan=NULL;

typedef DWORD WINAPI
  (* CM_Enumerate_Classes)(ULONG,LPGUID,ULONG);
typedef DWORD WINAPI
  (* CM_Get_First_Log_Conf)(PDWORD,DWORD,ULONG);
typedef DWORD WINAPI
  (* CM_Get_Next_Res_Des)(PDWORD,DWORD,ULONG,PULONG,ULONG);
typedef DWORD WINAPI
(* CM_Free_Log_Conf_Handle)(DWORD);
typedef DWORD WINAPI
(* CM_Free_Res_Des_Handle) (DWORD);
typedef DWORD WINAPI
(* CM_Get_Res_Des_Data)(DWORD,PVOID,ULONG,ULONG);
typedef DWORD WINAPI
(* CM_Get_Res_Des_Data_Size)(PULONG,DWORD,ULONG);

CM_Enumerate_Classes enumClasses=NULL;
CM_Get_First_Log_Conf GetFirstConf=NULL;
CM_Get_Next_Res_Des GetNextResDes=NULL;
CM_Free_Log_Conf_Handle FreeLogConfHandle=NULL;
CM_Free_Res_Des_Handle FreeResDesHandle=NULL;
CM_Get_Res_Des_Data GetResDesData=NULL;
CM_Get_Res_Des_Data_Size GetResDesDataSize=NULL;

bool FResourceOpen=false;
bool FExtractResource=false;
char* FBufForRes;
DWORD FResourceType;
DWORD CurrConf;
HDEVINFO FResDeviceInfoSet;
SP_DEVINFO_DATA FDeviceInfoData;
DWORD ResHandle;
DWORD PrevResHandle;
bool FNoResourses;
ULONG sizeResFu;

bool OpenResources(DWORD TypR,char* ClassName, int DeviceIndex)
{
    if( FResourceOpen )
        return false;
    FExtractResource = false;
    if(FBufForRes)delete []FBufForRes;
    FBufForRes = 0;

    if( (TypR != ResType_Mem) && (TypR != ResType_IO) &&
        (TypR != ResType_DMA) && (TypR != ResType_IRQ) ) {

        FResourceType = TypR;
        FResourceOpen = true;
        CurrConf = 0;
        FResDeviceInfoSet = 0;
        ResHandle = 0;
        PrevResHandle = 0;
        FNoResourses = true;
        return false;
    }

    DWORD rs;
    DWORD typeP;
    GUID *guids;
    DWORD RequiredSize = 0;

    bool guidTest = false;

bool res=SetupDiClassGuidsFromNameA(ClassName,guids,RequiredSize,&RequiredSize);
if(RequiredSize==0)
               {

                return false;
               }

if(!res)
        {
         guids=(GUID *)malloc(RequiredSize*sizeof(GUID));
         res=SetupDiClassGuidsFromNameA(ClassName,guids,RequiredSize,&RequiredSize);

         if(!res || RequiredSize==0)
               {

                realloc(guids,0);
                return false;
               }
        }


    for( int j=0; j<(int)RequiredSize; ++j ) {
        FResDeviceInfoSet=SetupDiGetClassDevs(guids,NULL,NULL,DIGCF_PRESENT);
        if( FResDeviceInfoSet == INVALID_HANDLE_VALUE )
            continue;
        guidTest = true;
        break;
    }
    if( !guidTest ) {
        FResourceType = TypR;
        FResourceOpen = true;
        CurrConf = 0;
        FResDeviceInfoSet = 0;
        ResHandle = 0;
        PrevResHandle = 0;
        realloc(guids,0);
        return false;
    }

    int res1;
    FDeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
    res1 = SetupDiEnumDeviceInfo(FResDeviceInfoSet,DeviceIndex,&FDeviceInfoData);

    if( !res1 ) {
        SetupDiDestroyDeviceInfoList(FResDeviceInfoSet);
        FResourceType = TypR;
        FResourceOpen = true;
        CurrConf = 0;
        FResDeviceInfoSet = 0;
        ResHandle = 0;
        PrevResHandle = 0;
        FNoResourses = true;
        realloc(guids,0);
        return false;
    }

    CurrConf = 0;
    ResHandle = 0;

    DWORD cmRes = GetFirstConf(&CurrConf,FDeviceInfoData.DevInst,0x00000002);
    if( cmRes == CR_NO_MORE_LOG_CONF ) {
        cmRes = GetFirstConf(&CurrConf,FDeviceInfoData.DevInst,0x00000003);
    }
    if( cmRes != CR_SUCCESS ) {
        SetupDiDestroyDeviceInfoList(FResDeviceInfoSet);
        CurrConf = 0;
        FResDeviceInfoSet = 0;
        ResHandle = 0;
        PrevResHandle = 0;
        FResourceType = TypR;
        FResourceOpen = true;
        FNoResourses = true;
        realloc(guids,0);
        return false;
    }

    cmRes = GetNextResDes(&ResHandle, CurrConf, TypR, NULL, 0);
    if(cmRes == CR_SUCCESS) {
        FResourceType = TypR;
        FResourceOpen = true;
        PrevResHandle = 0;
        FNoResourses = false;
        realloc(guids,0);
        return true;
    } else {
        SetupDiDestroyDeviceInfoList(FResDeviceInfoSet);
        CurrConf = 0;
        FResDeviceInfoSet = 0;
        ResHandle = 0;
        PrevResHandle = 0;
        FResourceType = TypR;
        FResourceOpen = true;
        FNoResourses = true;
        realloc(guids,0);
        return false;
    }
}

bool GetResource(char *bufres, int sizeBuf)
{
    if( FNoResourses )
        return false;
    if( !FExtractResource )
        return false;
    if( sizeBuf < sizeResFu )
        return false;
    memcpy(bufres, FBufForRes, sizeResFu);
    delete []FBufForRes;
    FBufForRes=0;
    return true;
}

int  ExtractResourceInfo(bool *NextResExist)
{
    ULONG sizeRes=0;
    if( FBufForRes )
       {
        delete [] FBufForRes;
        FBufForRes=0;
       }
    if(FNoResourses) {
        *NextResExist = false;
        return false;
    }
    if( ResHandle == 0 ) {
        *NextResExist = false;
        return -1;
    }

    DWORD cmRes = GetResDesDataSize(&sizeRes,ResHandle,0);
    if( cmRes != CR_SUCCESS ) {
        *NextResExist = false;
        return -2;
    }

    //int numres = 0;
    sizeResFu = sizeRes;


    FBufForRes = new char[sizeResFu];
    cmRes = GetResDesData(ResHandle, FBufForRes, sizeResFu, 0);
    if(cmRes == CR_BUFFER_SMALL )
        return -5;
    if(cmRes != CR_SUCCESS) {
        *NextResExist = false;
        return -4;
    }

    FExtractResource = true;
    PrevResHandle = 0;
    cmRes = GetNextResDes(&PrevResHandle, ResHandle, FResourceType, NULL, 0);
    if( cmRes == CR_SUCCESS ) {
        *NextResExist=true;
        FreeResDesHandle(ResHandle);
        ResHandle=PrevResHandle;
        PrevResHandle=0;
    } else {
        *NextResExist = false;
        FreeResDesHandle(ResHandle);
        ResHandle = 0;
        PrevResHandle = 0;
    }

    return sizeResFu;
}

bool CloseResources(void)
{
    if(!FResourceOpen)
        return false;
    FResourceType = 0;

    if(ResHandle) {
        FreeResDesHandle(ResHandle);
        ResHandle = 0;
    }

    if(CurrConf) {
        FreeLogConfHandle(CurrConf);
        CurrConf = 0;
    }

    if(FResDeviceInfoSet)
        SetupDiDestroyDeviceInfoList(FResDeviceInfoSet);

    FResourceOpen = false;
    FNoResourses = true;
    return true;
}



int EnumerateDevices(ULONG DeviceIndex, char *ClassName, char *DeviceName)
{
DWORD RequiredSize = 0;
GUID *guids;
HDEVINFO NewDeviceInfoSet;
SP_DEVINFO_DATA DeviceInfoData;
DWORD rs;
DWORD typeP;

bool res=SetupDiClassGuidsFromNameA(ClassName,guids,RequiredSize,&RequiredSize);
if(RequiredSize==0)
               {
         //íåâåðíîå èìÿ êëàññà:
                *DeviceName=0;
                return -2;
               }

if(!res)
        {
         guids=(GUID *)malloc(RequiredSize*sizeof(GUID));
         res=SetupDiClassGuidsFromNameA(ClassName,guids,RequiredSize,&RequiredSize);

         if(!res || RequiredSize==0)
               {

                realloc(guids,0);
                *DeviceName=0;
                return -2;
               }
        }
NewDeviceInfoSet=SetupDiGetClassDevs(guids,NULL,NULL,DIGCF_PRESENT);
if( NewDeviceInfoSet == INVALID_HANDLE_VALUE )
         if(!res)
               {

                realloc(guids,0);
                *DeviceName=0;
                return -3;
               }

DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
res=SetupDiEnumDeviceInfo(NewDeviceInfoSet,DeviceIndex,&DeviceInfoData);
            if(!res) {

                SetupDiDestroyDeviceInfoList(NewDeviceInfoSet);
                realloc(guids,0);
                *DeviceName=0;
                return -1;
            }

if(!SetupDiGetDeviceRegistryPropertyA(NewDeviceInfoSet,&DeviceInfoData,
SPDRP_FRIENDLYNAME,&typeP,DeviceName,MAX_DEV_LEN,&rs) )
        {
         res = SetupDiGetDeviceRegistryPropertyA(NewDeviceInfoSet,
          &DeviceInfoData,SPDRP_DEVICEDESC,&typeP,DeviceName,MAX_DEV_LEN,&rs);
         if(!res){

                SetupDiDestroyDeviceInfoList(NewDeviceInfoSet);
                realloc(guids,0);
                *DeviceName=0;
                return -4;
            }
        }
                realloc(guids,0);
                return 0;
}

//---------------------------------------------------------------------------

HANDLE BeginEnumerateClasses(void)
{
  if(CfgMan == NULL)CfgMan=LoadLibrary("cfgmgr32");
  enumClasses=(CM_Enumerate_Classes)GetProcAddress(CfgMan,"CM_Enumerate_Classes");
  return enumClasses;
}

int EnumerateClasses(ULONG ClassIndex, char* ClassName, char* ClassDescription, BOOL *DevicePresent)
{

  GUID ClassGuid;
  HDEVINFO NewDeviceInfoSet;
  SP_DEVINFO_DATA DeviceInfoData;
  DWORD result;
  char *name=0;
  bool resNam=false;
  DWORD RequiredSize=0;


  if(CfgMan == NULL || enumClasses == NULL)return -4;


  result = enumClasses(ClassIndex,&ClassGuid,0);


     if(result == CR_INVALID_DATA)
      {
       *DevicePresent=false;
       *ClassName=0;
       return -2;
      }

     if(result == CR_NO_SUCH_VALUE)
      {
       *DevicePresent=false;
       *ClassName=0;
       return -1;
      }

     if(result != CR_SUCCESS)
      {
       *DevicePresent=false;
       *ClassName=0;
       return -3;
      }

            resNam=SetupDiClassNameFromGuidA(&ClassGuid,name,RequiredSize,&RequiredSize);
            if(RequiredSize > 0)
             {
                name=(char *)malloc(RequiredSize);
                SetupDiClassNameFromGuidA(&ClassGuid,name,RequiredSize,&RequiredSize);
             }

            NewDeviceInfoSet=SetupDiGetClassDevs(
             &ClassGuid,
             NULL,
             NULL,
             DIGCF_PRESENT);

            if(NewDeviceInfoSet == INVALID_HANDLE_VALUE)
               {      *DevicePresent=false;
                      strcpy(ClassName,name);
                      return 0;}

            int numD=0;
            int res1;
            DeviceInfoData.cbSize=sizeof(SP_DEVINFO_DATA);
            res1=SetupDiEnumDeviceInfo(
            NewDeviceInfoSet,
            numD,
            &DeviceInfoData);


            if(!res1)
                {
                SetupDiDestroyDeviceInfoList(NewDeviceInfoSet);
                *DevicePresent=false;
                strcpy(ClassName,name);
                realloc(name,0);
                return 0;
                }

            HKEY KeyClass=SetupDiOpenClassRegKeyEx(
                &ClassGuid,MAXIMUM_ALLOWED,DIOCR_INSTALLER,NULL,NULL);
            LONG sizeB=1000;
            LONG res=RegQueryValue(KeyClass,NULL,ClassDescription,&sizeB);
            if(res)*ClassDescription=0;
            SetupDiDestroyDeviceInfoList(NewDeviceInfoSet);
                strcpy(ClassName,name);
                realloc(name,0);
               *DevicePresent=true;

            return 0;
}

void EndEnumerateClasses(void)
{
enumClasses=NULL;
if(CfgMan != NULL)FreeLibrary(CfgMan);
CfgMan=NULL;
}
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)
{
char* tmp;
for(int i=0; i<ListBox1->Items->Count; ++i)
{
tmp=(char *)ListBox1->Items->Objects[i];
free(tmp);
}
Close();
}
//---------------------------------------------------------------------------


void __fastcall TForm1::FormActivate(TObject *Sender)
{
  if(CfgMan == NULL)CfgMan=LoadLibrary("cfgmgr32");
  if(CfgMan == NULL)
    {
     ShowMessage("cfgmgr32 íå çàãðóæàåòñÿ");
     Application->Terminate();
     return;
    }
    GetFirstConf = (CM_Get_First_Log_Conf)GetProcAddress(CfgMan,"CM_Get_First_Log_Conf");
    GetNextResDes  = (CM_Get_Next_Res_Des)GetProcAddress(CfgMan,"CM_Get_Next_Res_Des");
    FreeLogConfHandle =  (CM_Free_Log_Conf_Handle)GetProcAddress(CfgMan,"CM_Free_Log_Conf_Handle");
    FreeResDesHandle  =   (CM_Free_Res_Des_Handle)GetProcAddress(CfgMan,"CM_Free_Res_Des_Handle");
    GetResDesData  = (CM_Get_Res_Des_Data)GetProcAddress(CfgMan,"CM_Get_Res_Des_Data");
    GetResDesDataSize = (CM_Get_Res_Des_Data_Size)GetProcAddress(CfgMan,"CM_Get_Res_Des_Data_Size");


    char *classes=0;
    char *classesDescr=0;
        classesDescr=(char*)malloc(1000);
        BOOL DevExist;
        BeginEnumerateClasses();
        ULONG i=0;
        while(true)
        {
        classes=(char*)malloc(1000);
        int res=EnumerateClasses(i,classes,classesDescr,&DevExist);
        if(res == -1)
               {
                free(classes);
                break;
               }
        ++i;
        if(res < -1 || !DevExist)
               {
               free(classes);
               continue;
               }
        classes=(char*)realloc(classes,strlen(classes)+1);
        ListBox1->Items->AddObject(classesDescr,(TObject *)classes);
        Repaint();
        }
        EndEnumerateClasses();
        realloc(classesDescr,0);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ListBox1Click(TObject *Sender)
{
    char *devices=0;
    int Index=0;
    if(ListBox1->ItemIndex == -1)return;
    ListBox2->Hint="";
    ListBox2->Clear();
    Memo1->Clear();
    ListBox2->Enabled=false;
    ListBox1->Enabled=false;
    Edit1->Text=AnsiString((char *)ListBox1->Items->Objects[ListBox1->ItemIndex]);
    ListBox1->Hint=ListBox1->Items->Strings[ListBox1->ItemIndex];
        devices=(char*)malloc(MAX_DEV_LEN);
        while(true)
        {
        int result=EnumerateDevices(Index, Edit1->Text.c_str(), devices);
        if(result == -1)break;
        if(result == 0)
               {
                ListBox2->Items->AddObject(devices,(TObject *)Index);
                Repaint();
               }
        Index++;
        }

    ListBox2->Enabled=true;
    ListBox1->Enabled=true;
    realloc(devices,0);

}
//---------------------------------------------------------------------------
void __fastcall TForm1::ListBox2Click(TObject *Sender)
{
Memo1->Clear();
    bool NextResExist;

    IO_RESOURCE *IoResource;
    DMA_RESOURCE *DmaResource;
    IRQ_RESOURCE *IrqResource;
    MEM_RESOURCE *MemResource;

    int size;
    char buf[1000];
    if(ListBox2->ItemIndex == -1)return;
    ListBox2->Hint=ListBox2->Items->Strings[ListBox2->ItemIndex];
    int DI=int((char *)ListBox2->Items->Objects[ListBox2->ItemIndex]);

    if(OpenResources(ResType_Mem,Edit1->Text.c_str(),DI))
      {
        Memo1->Lines->Add("Memoria:");
        do {
            size=ExtractResourceInfo(&NextResExist);
            if(size > 0) {
                GetResource(buf, size);
                MemResource=(MEM_RESOURCE*)buf;
                Memo1->Lines->Add(IntToHex((int)MemResource->MEM_Header.MD_Alloc_Base,8)+ " - "+
                  IntToHex((int)MemResource->MEM_Header.MD_Alloc_End,8));
            for( int i=0; i < ((size - sizMEM_HEADER)/MemResource->MEM_Header.MD_Type); ++i ) {
        if(MemResource[i].MEM_Data->MR_Min != 0 && MemResource[i].MEM_Data->MR_Max !=0
          && ((unsigned int)MemResource[i].MEM_Data->MR_Min < (unsigned int)MemResource[i].MEM_Data->MR_Max))
        Memo1->Lines->Add(IntToHex((int)MemResource[i].MEM_Data->MR_Min,8) + " - " +
           IntToHex((int)MemResource[i].MEM_Data->MR_Max,8));}
          }
        }while(NextResExist);
      }

    CloseResources();


    if(OpenResources(ResType_IO,Edit1->Text.c_str(),DI))
     {
        if(Memo1->Lines->Count)Memo1->Lines->Add("");
        Memo1->Lines->Add("Puertos:");
        do {
            size=ExtractResourceInfo(&NextResExist);
            if(size > 0) {
                GetResource(buf, size);
                IoResource=(IO_RESOURCE*)buf;

                Memo1->Lines->Add(IntToHex((int)IoResource->IO_Header.IOD_Alloc_Base,4) + " - "+
                    IntToHex((int)IoResource->IO_Header.IOD_Alloc_End,4));

                for(int i=0; i < ((size - sizIO_HEADER)/IoResource->IO_Header.IOD_Type); ++i ) {
                    if( IoResource[i].IO_Data->IOR_Min != 0 && IoResource->IO_Data->IOR_Max !=0 &&
                      (unsigned int)IoResource[i].IO_Data->IOR_Min < (unsigned int)IoResource->IO_Data->IOR_Max )
                        Memo1->Lines->Add(IntToHex((int)IoResource->IO_Data->IOR_Min,4) + " - " +
                    IntToHex((int)IoResource->IO_Data->IOR_Max,4));
                };
            };
        } while( NextResExist );
    CloseResources();
       }

    if(OpenResources(ResType_DMA,Edit1->Text.c_str(),DI))

        do {
            size=ExtractResourceInfo(&NextResExist);
            if(size > 0) {
                GetResource(buf, size);
                DmaResource=(DMA_RESOURCE*)buf;
                if(Memo1->Lines->Count)Memo1->Lines->Add("");
                Memo1->Lines->Add("DMA Chan.: "+IntToStr(DmaResource->DMA_Header.DD_Alloc_Chan));
                for( int i=0; i < ((size - sizDMA_HEADER)/DmaResource->DMA_Header.DD_Type); ++i ) {
                    if(DmaResource[i].DMA_Data->DR_Min != 0 && DmaResource->DMA_Data->DR_Max !=0)
                        Memo1->Lines->Add(IntToStr(DmaResource->DMA_Data->DR_Min) + " - " +
                            IntToStr(DmaResource->DMA_Data->DR_Max));
                    };
                };
        } while( NextResExist );
    CloseResources();

    if(OpenResources(ResType_IRQ,Edit1->Text.c_str(),DI))
       {
        if(Memo1->Lines->Count)Memo1->Lines->Add("");
        Memo1->Lines->Add("IRQ:");
        do {
            size=ExtractResourceInfo(&NextResExist);
            if(size > 0) {
                GetResource(buf, size);
                IrqResource=(IRQ_RESOURCE*)buf;
                Memo1->Lines->Add(IntToStr(IrqResource->IRQ_Header.IRQD_Alloc_Num));
                for( int i=0; i < ((size - sizIRQ_HEADER)/IrqResource->IRQ_Header.IRQD_Type); ++i ) {

                    if(IrqResource[i].IRQ_Data->IRQR_Min != 0 && IrqResource[i].IRQ_Data->IRQR_Max !=0 &&
                      IrqResource[i].IRQ_Data->IRQR_Min != IrqResource->IRQ_Header.IRQD_Alloc_Num &&
                      IrqResource[i].IRQ_Data->IRQR_Max != IrqResource->IRQ_Header.IRQD_Alloc_Num )

                        Memo1->Lines->Add(IntToStr(IrqResource->IRQ_Data->IRQR_Min) + " - " +
                          IntToStr(IrqResource->IRQ_Data->IRQR_Max));
                };
            };
        } while(NextResExist);
       }
    CloseResources();

}
//---------------------------------------------------------------------------


Espero les sirva de algo Wink
(Si alguien quiere el ejemplo: victor_yp@hotmail.com )

Saludos
_________________
"Ser inteligente no es ser mas, solo equivocarse menos y no usar Visual Basic"
Atte.
Victor Yañez

Apoyen el Proyecto OpenSource del Club Builder. Ya tenemos componentes Listos!!!
Volver arriba
Ver perfil de usuario Enviar mensaje privado Enviar email Yahoo Messenger MSN Messenger
Mensaje    Asunto: Creo que falla Responder citando

Viktor:


Creo que le faltan algunas cosas al codigo que has publicado ya que lo he puespo a mi compilador y me marca varios errores, yo manejo el builder 5.0 uno de los errores, es que no encuentra la funcion:
Código:
    bool res=SetupDiClassGuidsFromNameA(ClassName,guids,RequiredSize,&RequiredSize);


Si no es mucha la molestia puedes enviar tu programa a la siguiente direccion:
Gustdiaz@orbis.org.mx

Te lo agradeceria mucho. Bye
Volver arriba
Mostrar mensajes de anteriores:   
Cambiar a:  
No puedes publicar temas nuevos en este foro
No puedes responder a temas en este foro
No puedes editar tus mensajes en este foro
No puedes borrar tus mensajes en este foro
No puedes votar en las encuestas de este foro


Hosting WordPress Indedmedia desde 3,99 €
© 2002–2026 Club Builder · Funciona con phpBB.