Holas =), bueno nada nuevo, simplemente lo posteo para el que le interese y al que no bueno ya sabe puede ignorarlo categoricamente.

Que es? una clase para detectar el arrivo de nuevos dispositivos, en este caso se limita a los que tienen bus del tipo USB, la clase es un poco grande (unas 570 lineas) porque la idea es expandirla para soportar todos los tipos de mensajes procporcionados por el evento WM_DEVICECHANGE, es IDE safe y no tiene dependencias.

Testeada en:
  XP SP2
 
Con:
  -PNY Attache Flash Drive
  -Firefly External Hard Drive
  -Hagiwara UDRW  Flash Drive

Descarga:
  http://www.uploadsourcecode.com.ar/d/saSqPP36BmHgfw2LBNa4Z8tXIXypiDlF

Hola, bueno estaba por ahi mirando codigos y me tope con aguna de estas funciones asi que las junte con algunas que conocia y usaba. Me gustaria que presenten otras maneras o simplemente comenten acerca de estas funciones para ver cual creen que es mejor y por que.

En mi opinion la numero 1 (IsEXE1) es la mejor de todas.

Option Explicit
 
Private Declare Function GetModuleHandle Lib "kernel32.dll" Alias "GetModuleHandleA" (ByVal lpModuleName As String) As Long
 
Private Sub Form_Load()
    MsgBox IsEXE0
    MsgBox IsEXE1
    MsgBox IsEXE2
    MsgBox IsEXE3
End Sub
 
Private Function IsEXE0() As Boolean
    On Error GoTo IDE
    Debug.Print 1 / 0
    IsEXE0 = True
IDE:
End Function
 
Private Function IsEXE1() As Boolean
   Static bEXE As Boolean
 
   If Not bEXE Then
      bEXE = True
      Debug.Assert IsEXE1() Or True
      IsEXE1 = bEXE
   End If
   bEXE = False
End Function
 
Private Function IsEXE2() As Boolean
    IsEXE2 = Not (App.EXEName = App.Title)
End Function
 
Private Function IsEXE3() As Boolean
    If GetModuleHandle("vba6") = 0 Then
        IsEXE3 = True
    End If
End Function
 
 

Holas =) estaba medio aburrido y me puse  hacer esta mini aplicacion que sirve para calcular el checksum, hash, digest o como les guste llamarlo de un archivo.

La aplicaciones muy simple de usar, soporta 4 algoritmos diferentes MD2, MD4, MD5 y SHA-1, puede comparar checksums, soporta Drag and Drop y es totalmente portatil.

Espero que les guste! =)

Download (Source + App): http://www.uploadsourcecode.com.ar/d/RZrSG6y45iuxZLZgkeIk2E3NIT2VkMDL

Filesize: 495 KB

Screenshot:

Bueno la verdad soy MUY malo explicando asi que voy a tratar de hacer lo mejor posible.

Hay una duda y/o problema recurrente, como enviar e interpretar instrucciones usando winsock, voy a intentar mostrar una tecnica muy simple de hacerlo utilizando CallByName a ver si terminan las preguntas y PMs con respecto a este tema.

En un Form

Option Explicit
 
Private Const DELIMITER As String = "|" ' delimitador para separar instrucciones
 
Private Const inst_MSG  As String = "inst_MENSAJE"  'nombre de nustra instruccion
Private Const inst_BEEP As String = "inst_BEEP"     'nombre de otra instruccion
 
Private Sub Form_Load()
 
    'esto es simplemente para imitar el arrivo de datos
    TestDataArival inst_MSG & DELIMITER & "Hello"
    TestDataArival inst_BEEP
    TestDataArival inst_MSG & DELIMITER & "Bye Bye"
 
End Sub
 
'sData seria la variable con los datos que llegaron del socket
Private Sub TestDataArival(sData As String)
    Dim cInstInt    As New cInstructionInterpreter
 
    'Vemos si la funcion tiene o no parametros
    If UBound(Split(sData, DELIMITER)) > 0 Then
        'llamamos a la funcion con parametros
        CallByName cInstInt, Split(sData, DELIMITER)(0), VbMethod, sData
    Else
        'llamamos una funcion sin parametros
        CallByName cInstInt, Split(sData, DELIMITER)(0), VbMethod
    End If
End Sub
 

bueno en el primer code lo que vemos es muy simple tenemos 3 llamadas a TestDataArival pasandole unos parametros que en este caso serian nustras instrucciones  o comandos a ejecutar. la estructura del mensaje es simple [instruccion/delimitador/dato/.../delimitador/dato] en este caso los declare como constantes para  evitar errores y facilitar su modificacion (nada misterioso hasta aca)

en la funcion TestDataArival, lo primero que vemos es [ Dim cInstInt    As New cInstructionInterpreter] simplemente creamos una instancia de nuestra clase, luego un simple if que va a llamar a CallByName de 2 maneras diferentes dependiendo de si tenemos o no datos para pasarle a la instruccion

En una clase (yo la llame cInstructionInterpreter)

Option Explicit
 
Private Const DELIMITER As String = "|"
 
Public Sub inst_MENSAJE(ByVal sData As String)
    Dim svData() As String
 
    If SplitData(sData, 1, svData) Then
        MsgBox svData(1)
    End If
 
End Sub
 
Public Sub inst_BEEP()
    Call Beep
End Sub
 
'funcion generica para dividir y validar los datos
Private Function SplitData( _
    ByVal sData As String, _
    ByVal lExpectedParams As Long, _
    ByRef svData() As String) As Boolean
 
    svData = Split(sData, DELIMITER)
 
    If UBound(svData) >= lExpectedParams Then
        SplitData = True
    End If
 
End Function
 

Bueno la clase en si tampoco tiene mucho, 2 funciones declaradas como publicas que son nustros comandos, los nombres de estas funciones tienen que coincidir con los que utilizamos para llamarlar  y una tercera que es privada simplemente para dividir y validar los datos.

bueno para los que no tienen idea de como usar CallByName aca les dejo unos links

http://msdn.microsoft.com/en-us/library/chsc1tx6(VS.80).aspx

http://www.recursosvisualbasic.com.ar/htm/trucos-codigofuente-visual-basic/153-callbyname.htm
 
Si alguno quiere agregar algo para hacer esto mas claro que lo haga sin problemas se que puede ser un poco confusa mi explicacion.

Espero que sea util.

Holas =), bueno viendo el post que dejo SERBice me diron ganas de entender bien como funcionaba el code etc, asi que decidi reescribirlo a mi gusto y agregarle unas cositas. Que es esto? un modulo para ejecutar un PE desde un byte array, calculo que puede ser util para un joiner o packager.

Que ventajas tiene, bueno la primera y principal que es poder correr un exe desde un byte array esto es bueno si se esta corriendo el programa desde un CD por ejemplo, otra cosa buena es que podemos "imitar" procesos, al usar un host para lanzar nuestra alpicacion esta va a aparecer como el host en la lista de procesos del administrador de tareas.

Bueno usen la imaginacion!

Descarga: http://www.uploadsourcecode.com.ar/d/hVAPGKNaFO2zRW9QmmDt9SEttwqKNHu8

Bueno, estaba aburrido y se me ocurrio hacer este code, es para proteger las aplicaciones, no es infalible pero seguramente va a molestar bastante a un debugger.

Espero que les guste y aprendan algo del code =)

Descarga
http://www.uploadsourcecode.com.ar/d/I0LDiGZnKy25FwuwoMJm408wEN1SIkkT

Aca les dejo un snippet que muestra como obtener el espacio libre, total y disponible de una unidad y formatearlo.

Option Explicit
 
Private Declare Function SHGetDiskFreeSpace Lib "shell32" Alias "SHGetDiskFreeSpaceA" (ByVal pszVolume As String, pqwFreeCaller As Currency, pqwTot As Currency, pqwFree As Currency) As Long
Private Declare Function StrFormatByteSize64A Lib "SHLWAPI.DLL" (ByVal qdw As Currency, ByVal pszBuf As String, ByVal uiBufSize As Long) As Long
Private Declare Function lstrlen Lib "kernel32" Alias "lstrlenA" (ByVal lpString As String) As Long
 
Private Sub Form_Load()
    Dim cFreeCaller As Currency
    Dim cTotal      As Currency
    Dim cFreeTotal  As Currency
    Dim cFormat     As Currency
    Dim sBuff       As String
 
    If Not SHGetDiskFreeSpace( _
       Environ$("HOMEDRIVE"), _
       cFreeCaller, _
       cTotal, _
       cFreeTotal) = 0 Then
 
        Debug.Print "Drive: " & Environ$("HOMEDRIVE")
        cFormat = cFreeTotal:   GoSub Format: Debug.Print "Total Free Space: " & sBuff
        cFormat = cFreeCaller:  GoSub Format: Debug.Print "Free Caller: " & sBuff
        cFormat = cTotal:       GoSub Format: Debug.Print "Total Space: " & sBuff
 
    End If
 
    Exit Sub
Format:
    sBuff = Space(32)
    StrFormatByteSize64A cFormat, sBuff, 32
    sBuff = Left(sBuff, lstrlen(sBuff))
    Return
End Sub
 

Abro un nuevo tema asi todos se enteran de que esta esto.

Aca les dejo un link con infoemacion y tres estructuras para crear manifests para Vista y obtener distintos privilegios.

Link con informacion que deberian leer
http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=463884&SiteID=1

Estructura de 3 manifest para Vista

Aca les dejo dos funciones para trabajar con archivos de tamaño superior a los 2GB.

Private Const Bit31                         As Currency = 2147483647@
Private Const Bit32                         As Currency = 4294967295@
 
Private Declare Function SetFilePointer Lib "kernel32" (ByVal hFile As Long, ByVal lDistanceToMove As Long, lpDistanceToMoveHigh As Long, ByVal dwMoveMethod As Long) As Long
Private Declare Function GetFileSize Lib "kernel32" (ByVal hFile As Long, lpFileSizeHigh As Long) As Long
 
Private Function GetFileSizeEx(ByVal hFile As Long) As Currency
    Dim lLow    As Long
    Dim lHigh   As Long
    lLow = GetFileSize(hFile, lHigh)
    Call ToLargeInt(GetFileSizeEx, lLow, lHigh)
End Function
 
Private Function SetFilePointerEx(ByVal hFile As Long, ByVal lDistanceToMove As Currency, ByVal dwMoveMethod As Long) As Currency
    Dim lLow    As Long
    Dim lHigh   As Long
 
    Call FromLargeInt(lDistanceToMove, lLow, lHigh)
    lLow = SetFilePointer(hFile, lLow, lHigh, dwMoveMethod)
    Call ToLargeInt(SetFilePointerEx, lLow, lHigh)
End Function
 
Private Sub FromLargeInt(ByVal cLargeInt As Currency, ByRef lLow As Long, ByRef lHigh As Long)
    Do Until cLargeInt < Bit32
        lHigh = lHigh + 1
        cLargeInt = cLargeInt - Bit32
    Loop
    If cLargeInt > Bit31 Then
        lLow = -CLng(Bit32 - (cLargeInt - 1))
    Else
        lLow = CLng(cLargeInt)
    End If
End Sub
 
Private Sub ToLargeInt(ByRef cLargeInt As Currency, ByVal lLow As Long, ByVal lHigh As Long)
    cLargeInt = Bit32 * lHigh
    If lLow < 0 Then
        cLargeInt = cLargeInt + (Bit32 + (lLow + 1))
    Else
        cLargeInt = cLargeInt + lLow
    End If
End Sub
 
 

Holi Holas, nada nuevo bajo el sol =), aca les dejo una mini clase (la mas chica del mercado creo :p ) que reemplaza a un timer, yo usualmente utilizo una en mis proyectos que es bastante grande, hasta diria un poco desmedida para un simple timer asi que en un momento de idle decidi hacer esta que considero es mucho mas razonable.

La clase tiene 101 lineas de code, self callback y es IDE safe, una aclaracion para los que les gusta usar el STOP (cosa totalmente desacosejable), si lo hacen la clase no va a destruir el timer y en consecuencia van a tener comportamientos erraticos... llamese varios timers pulsando el mismo evento. Nada tragico puesto que no va a crashear el IDE pero se los advierto simplemente.

Descarga: http://www.uploadsourcecode.com.ar/d/QuQTw0n1elsDABYCzw9tutY3MrrCY8zr

Se puede reducir un poco mas... digo esto simplemente para evitar comentarios de gente muy sabia, pero asi es mas que suficiente para mi.