El motivo de crear esta utilidad
surgió por el problema que algunas veces hay a la hora de
descargar archivos de Internet.
¿A quién no se le ha cortado alguna vez la conexión?
Lo que hace este programa es tomar
un archivo y trocearlo en piezas más pequeñas (se le debe
indicar el número de KB que debe tener cada uno de los trozos)
Cuando se trocea un archivo se crean una serie de
"trozos", (con la extensión cxx), que corresponden al
archivo original, pero en piezas más pequeñas, además se
genera un archivo con la extensión cit que es el que se usará para volver a unir los
trozos, para formar de nuevo el archivo original.
El programa se puede usar desde la
líinea de comandos o como programa independiente.
Si soltamos un archivo sobre el ejecutable y este tiene la
extensión cit, "reconstruirá" el archivo
original.
En caso de que la extensión sea diferente a la indicada
anteriormente, lo que hace es descomponer el archivo en trozos de
200 KB, que es el valor por defecto.
Para usarlo desde la línea de comandos:
Cut-It nombre_archivo.extensión tamaño_de_cada_trozo [/T] Cut-It nombre_archivo.cit [/U]
Ya sabes, si la extensión es cit
se "recompone" el archivo antes troceado.
Si no es esa extensión se "trocea" en piezas del
tamaño indicado o de 200 KB si no se especifica el tamaño
Espero que te pueda ser de utilidad.
Pulsa este link para bajate el ejecutable y los listados (CutIt.zip 17.7 KB)
Nota: Bájate el de la última versión.
A continuación te muestro el
listado y una imagen del form.
Este programa usa una clase para abrir archivos y mostrar el
cuadro de diálogos comunes sin necesidad de usar ningún
control.
Si se te ocurre alguna cosa para mejorarlo, no dudes en decírmelo.
El listado del módulo (BAS)
'--------------------------------------------------------------
'Módulo de entrada para el programa Cut-It (19/Sep/97)
'
'(c)Guillermo Som, 1997
'--------------------------------------------------------------
Option Explicit
Option Compare Text
Public FormVisible As Boolean 'Si el form está visible
Private cutitErrMsg As String 'Devolver en esta cadena cualquier mensaje de error
Public sArchivo As String 'Archivo a procesar
Public lngSize As Long 'Tamaño del archivo a trocear
Public iSize As Integer 'Tamaño de cada trozo
Public iTrozos As Integer 'Número de trozos
Public vFecha As Date 'Fecha del archivo
Public iAccion As Integer 'Acción a realizar
'para las opciones
Public Const cTrocear = 0
Public Const cUnir = 1
Private Type tCutIt
Archivo As String
Size As Long
Fecha As Date
Trozos As Integer
Info As String
End Type
Public Sub Main()
'Este será el punto de entrada.
'si no se especifica línea de comandos, mostrar el form
If LineaComandos() Then
'procesar los datos
ProcesarArchivo
Else
fCutIt.Show
End If
End Sub
Private Function LineaComandos() As Boolean
'Leer la línea de comandos
'
'Devuelve True si hay línea de comandos
' False si no hay línea de comandos
'
'Se usarán las siguientes opciones:
' /T Trocear el archivo
' /U Unir los trozos y crear el archivo
'
'Ejemplos para:
' trocear: Cut-it archivo_original.ext tamaño_trozos /T
' Cut-It vb.hlp 400 /T
' unir: Cut-it archivo.cit /U
' Cut-It vb.cit /U
'
'Si se especifican más de un parámetro y no se usan opciones,
'se entiende que se quiere trocear.
'El parámetro tamaño_trozos es opcional,
'siendo el valor por defecto: 200KB
'(se debe especificar /T salvo que la extensión no sea cIt)
'
'Si la extensión es .cit y no se indican más parámetros,
'se entiende que se quiere pegar.
'
Dim sCommand As String
Dim i As Integer
Dim sTmp As String
sCommand = Trim$(Command$)
If Len(sCommand) = 0 Then Exit Function
'Comprobar si hay algún archivo en la línea de comandos
sTmp = sCommand
'Si tiene los caracteres de comillas, quitarselos
i = InStr(sTmp, Chr$(34))
If i Then
sTmp = Left$(sTmp, i - 1) & Mid$(sTmp, i + 1)
i = InStr(sTmp, Chr$(34))
If i Then
sTmp = Left$(sTmp, i - 1) & Mid$(sTmp, i + 1)
End If
End If
sCommand = sTmp
iSize = 200
If InStr(sCommand, ".cit") Then _
iAccion = cUnir
i = InStr(sCommand, "/T")
If i Then
iAccion = cTrocear
'quitar la /T
sCommand = Left$(sCommand, i - 1) & " " & LTrim$(Mid$(sCommand, i + 2))
End If
i = InStr(sCommand, "/U")
If i Then
iAccion = cUnir
'quitar la /U
sCommand = Left$(sCommand, i - 1) & " " & LTrim$(Mid$(sCommand, i + 2))
End If
'El primer parámetro debe ser el nombre del archivo
i = InStr(sCommand, " ")
If i = 0 Then
i = Len(sCommand) + 1
End If
sArchivo = Left$(sCommand, i - 1)
sCommand = Mid$(sCommand, i + 1)
'Si se especifica el tamaño
If iAccion = cTrocear Then
If Len(sCommand) Then
iSize = Val(sCommand)
If iSize = 0 Then
iSize = 200
End If
End If
End If
LineaComandos = True
End Function
Public Sub ProcesarArchivo()
'
Select Case iAccion
Case cTrocear
If Trocear() Then _
MsgBox "No se ha podido trocear el archivo" & vbCrLf & cutitErrMsg
Case cUnir
If Unir() Then _
MsgBox "No se ha podido unir el archivo" & vbCrLf & cutitErrMsg
End Select
End Sub
Private Function Trocear() As Boolean
'Trocear el archivo.
'Devuelve True si hay error
' False si está bien
Dim Cadena As String
Dim nTrozo As Integer
Dim NuevoTrozo As Boolean
Dim GrabadoActual As Long 'Bytes grabados en el trozo actual
Dim TotalGrabado As Long 'Total de bytes grabados
Dim TotalTrozo As Long 'Tamaño en bytes de cada trozo
Dim lngResto As Long 'Tamaño del trozo a grabar
Dim Origen As Integer
Dim Destino As Integer
Dim sDestino As String
Dim sExt As String 'Extensión de cada trozo
Dim sNombreArchivo As String 'Archivo sin extensión
Dim sPath As String
Dim pCutIt As tCutIt
'Comprobar si existe
If Len(Dir$(sArchivo)) = 0 Then
cutitErrMsg = "El archivo '" & sArchivo & "'" & vbCrLf & "No existe."
Trocear = True
Exit Function
End If
Screen.MousePointer = vbArrowHourglass
lngSize = FileLen(sArchivo)
vFecha = FileDateTime(sArchivo)
TotalTrozo = CLng(iSize) * 1024&
'Asignar los valores para el archivo de información
With pCutIt
.Archivo = sArchivo
.Size = lngSize
.Fecha = vFecha
.Trozos = 0
.Info = "Archivo troceado el " & Format$(Now, "dd/mm/yyyy hh:mm:ss")
End With
'Dividir el nombre del archivo...
SplitPath sArchivo, sPath, sNombreArchivo, sExt
nTrozo = InStr(sNombreArchivo, "." & sExt)
If nTrozo Then
sNombreArchivo = Left$(sNombreArchivo, nTrozo - 1)
End If
'Este es el nombre del archivo sin la extensión
sNombreArchivo = sPath & "\" & sNombreArchivo
NuevoTrozo = True 'Forzar a crear un archivo al principio
nTrozo = 0
GrabadoActual = 0
TotalGrabado = 0
'Abrir el archivo de origen
Origen = FreeFile
Open sArchivo For Binary Access Read As Origen
Do While TotalGrabado < lngSize
If NuevoTrozo Then
nTrozo = nTrozo + 1
sExt = ".C" & Format$(nTrozo, "00")
sDestino = sNombreArchivo & sExt
Destino = FreeFile
Open sDestino For Binary Access Write As Destino
NuevoTrozo = False
Else
'Leer 1024 bytes o el resto...
lngResto = lngSize - TotalGrabado
If lngResto >= 1024& Then
lngResto = 1024
End If
Cadena = String$(lngResto, " ")
GrabadoActual = GrabadoActual + lngResto
TotalGrabado = TotalGrabado + lngResto
Get Origen, , Cadena
Put Destino, , Cadena
'
If FormVisible Then
fCutIt.lblInfo = "Trozo: " & CStr(nTrozo) & _
", grabado actualmente: " & TotalGrabado
End If
DoEvents
'
If GrabadoActual = TotalTrozo Or TotalGrabado = lngSize Then
Close Destino
NuevoTrozo = True
GrabadoActual = 0
End If
End If
Loop
Close Origen
'guardar cabecera
sDestino = sNombreArchivo & ".cIt"
Destino = FreeFile
Open sDestino For Output As Destino
With pCutIt
Print #Destino, .Archivo
Print #Destino, .Size
Print #Destino, .Fecha
.Trozos = nTrozo
Print #Destino, .Trozos
Print #Destino, .Info
End With
Close Destino
Screen.MousePointer = vbDefault
If FormVisible Then
fCutIt.lblInfo = "Procesado en " & CStr(nTrozo) & " trozo(s)"
DoEvents
End If
Trocear = False
End Function
Private Sub SplitPath(ByVal sTodo As String, sPath As String, Optional vNombre, Optional vExt)
'----------------------------------------------------------------
'Divide el nombre recibido en la ruta, nombre y extensión
'(c)Guillermo Som, 1997 ( 1/Mar/97)
'
'Esta rutina aceptará los siguientes parámetros:
'sTodo Valor de entrada con la ruta completa
'Devolverá la información en:
'sPath Ruta completa, incluida la unidad
'vNombre Nombre del archivo incluida la extensión
'vExt Extensión del archivo
'
'Los parámetros opcionales sólo se usarán si se han especificado
'----------------------------------------------------------------
Dim bNombre As Boolean 'Flag para saber si hay que devolver el nombre
Dim i As Integer
If Not IsMissing(vNombre) Then
bNombre = True
vNombre = sTodo
End If
If Not IsMissing(vExt) Then
vExt = ""
i = InStr(sTodo, ".")
If i Then
vExt = Mid$(sTodo, i + 1)
End If
End If
sPath = ""
'Asignar el path
For i = Len(sTodo) To 1 Step -1
If Mid$(sTodo, i, 1) = "\" Then
sPath = Left$(sTodo, i - 1)
'Si hay que devolver el nombre
If bNombre Then
vNombre = Mid$(sTodo, i + 1)
End If
Exit For
End If
Next
End Sub
Private Function Unir() As Boolean
'Unir el archivo.
'Devuelve True si hay error
' False si está bien
Dim Cadena As String
Dim nTrozo As Integer
Dim GrabadoActual As Long 'Bytes grabados en el trozo actual
Dim TotalGrabado As Long 'Total de bytes grabados
Dim TotalTrozo As Long 'Tamaño en bytes de cada trozo
Dim lngResto As Long 'Tamaño del trozo a grabar
Dim Origen As Integer
Dim Destino As Integer
Dim sOrigen As String
Dim sExt As String 'Extensión de cada trozo
Dim sNombreArchivo As String 'Archivo sin extensión
Dim sPath As String
Dim pCutIt As tCutIt
Dim sTmp As String
'Comprobar si existe
If Len(Dir$(sArchivo)) = 0 Then
cutitErrMsg = "El archivo '" & sArchivo & "'" & vbCrLf & "No existe."
Unir = True
Exit Function
End If
Screen.MousePointer = vbArrowHourglass
Origen = FreeFile
Open sArchivo For Input As Origen
With pCutIt
Line Input #Origen, sTmp
.Archivo = Trim$(sTmp)
Line Input #Origen, sTmp
.Size = Val(sTmp)
lngSize = .Size
Line Input #Origen, sTmp
.Fecha = sTmp
vFecha = .Fecha
Line Input #Origen, sTmp
.Trozos = Val(sTmp)
nTrozo = .Trozos
'Line Input #Origen, sTmp
'.Info = sTmp
End With
Close Origen
'El archivo de destino se guardará en el directorio
'en el que estaba el archivo de cabecera
SplitPath pCutIt.Archivo, sPath, sOrigen
SplitPath sArchivo, sPath 'el path del archivo .cIt
sArchivo = sPath & "\" & sOrigen 'Path completo del archivo original
'Crear un nombre base sin extensión
SplitPath sArchivo, sPath, sNombreArchivo, sExt
nTrozo = InStr(sNombreArchivo, "." & sExt)
If nTrozo Then
sNombreArchivo = Left$(sNombreArchivo, nTrozo - 1)
End If
'Este es el nombre del archivo sin la extensión
sNombreArchivo = sPath & "\" & sNombreArchivo
GrabadoActual = 0
TotalGrabado = 0
Destino = FreeFile
Open sArchivo For Binary Access Write As Destino
For nTrozo = 1 To pCutIt.Trozos
sExt = ".c" & Format$(nTrozo, "00")
sOrigen = sNombreArchivo & sExt
Origen = FreeFile
TotalTrozo = FileLen(sOrigen)
Open sOrigen For Binary Access Read As Origen
Do
'Leer 1024 bytes o el resto...
lngResto = lngSize - TotalGrabado
If lngResto >= 1024& Then
lngResto = 1024
End If
Cadena = String$(lngResto, " ")
GrabadoActual = GrabadoActual + lngResto
TotalGrabado = TotalGrabado + lngResto
Get Origen, , Cadena
Put Destino, , Cadena
'
If FormVisible Then
fCutIt.lblInfo = "Trozo: " & CStr(nTrozo) _
& ", grabado actualmente: " & TotalGrabado
End If
DoEvents
'
If GrabadoActual = TotalTrozo Or TotalGrabado = lngSize Then
Exit Do
End If
Loop
Close Origen
GrabadoActual = 0
Next
Close Destino
'Marcarlo con la fecha original
Dim tFecha As Date
tFecha = Now
Date = Format(vFecha, "dd/mm/yyyy")
Time = Format(vFecha, "hh:mm:ss")
Destino = FreeFile
Cadena = " "
Open sArchivo For Binary As Destino
Get Destino, 1, Cadena
Put Destino, 1, Cadena
Close Destino
'Restablecer la fecha/hora (salvo el tiempo empleado en procesar)
Date = Format(tFecha, "mm/dd/yyyy")
Time = Format(tFecha, "hh:mm:ss")
Screen.MousePointer = vbDefault
If FormVisible Then
fCutIt.lblInfo = "Se ha unido el archivo... troceado en " & CStr(pCutIt.Trozos) & " trozo(s)"
DoEvents
End If
Unir = False
End Function
El listado del Form
'--------------------------------------------------------------
'Utilidad para dividir archivos en trozos pequeños (18/Sep/97)
'
'(c)Guillermo Som, 1997
'
'La estructura y extensión de cada archivo troceado es:
' CUT El primero de la serie.
' Cxx siguientes archivos xx números de 01 a 99
'Estructura de CUT:
' Nombre original String
' Tamaño Long
' Fecha/Hora Date
' Número de trozos Integer
'Estructura de Cxx:
' ninguna, sólo los datos
'--------------------------------------------------------------
Option Explicit
Option Compare Text
'Variable para el diálogo común
Dim CommonDialog As New cComDlg
Private Sub cmdCancelar_Click()
'Cancelar
Unload Me
End
End Sub
Private Sub cmdExaminar_Click()
'Seleccionar archivo para abrir
Dim lngSize As Long
Dim vDate As Date
On Local Error Resume Next
With CommonDialog
.CancelError = True
.Filter = "Todos los archivos (*.*)|*.*|Archivos Cut-It (*.cIt)|*.cIt"
If optAccion(1) Then
.Filter = "Archivos Cut-It (*.cIt)|*.cIt|Todos los archivos (*.*)|*.*"
End If
.ShowOpen
If Err Then
Err = 0
Else
txtArchivo = .FileName
lngSize = FileLen(txtArchivo)
vDate = FileDateTime(txtArchivo)
lblArchivo = "Tamaño: " & Format$(lngSize, "###,###") & ", Fecha: " & Format$(vDate, "dd/mm/yy hh:mm")
End If
If InStr(.FileName, ".cIt") Then
optAccion_Click cUnir
Else
optAccion_Click cTrocear
End If
End With
End Sub
Private Sub cmdProcesar_Click()
'procear el archivo, según la acción
On Local Error Resume Next
sArchivo = txtArchivo
iSize = Val(txtSizeTrozo)
If optAccion(0) Then
iAccion = cTrocear
Else
iAccion = cUnir
End If
If Err Then
MsgBox "Se ha producido el error " & CStr(Err) & ", " & Error$
Err = 0
Exit Sub
End If
On Local Error GoTo 0
ProcesarArchivo
End Sub
Private Sub Form_Load()
txtArchivo = ""
lblArchivo = ""
lblTrozos = ""
lblInfo = ""
optAccion_Click iAccion
FormVisible = True
End Sub
Private Sub Form_Unload(Cancel As Integer)
Set CommonDialog = Nothing
Set fCutIt = Nothing
End Sub
Private Sub optAccion_Click(Index As Integer)
Static YaEstoy As Boolean
If YaEstoy Then Exit Sub
YaEstoy = True
iAccion = Index
If iAccion = cTrocear Then
txtSizeTrozo.Enabled = True
Else
txtSizeTrozo.Enabled = False
End If
optAccion(Index) = True
YaEstoy = False
End Sub
El listado de la clase para abrir archivos
'----------------------------------------------------------------
'cComDlg Clase para simular el control de Diálogos Comunes
'
'Primera tentativa: (04:57 25/Ago/97)
'
'Versión reducida, sólo Abrir (10:20 18/Sep/97)
'
'©Guillermo 'guille' Som, 1997 <[email protected]>
'----------------------------------------------------------------
Option Explicit
Private sFilter As String
'Esta propiedad hará referencia al hWnd de un Form
Public hWnd As Long
'Propiedades genéricas de los diálogos comunes
Public DialogTitle As String
Public CancelError As Boolean
Public Flags As Long
'Propiedades para Abrir y Guardar como
Public DefaultExt As String
Public FileName As String
Public FileTitle As String
'Public Filter As String
Public FilterIndex As Long
Public InitDir As String
'Public MaxFileSize As Long (será 260)
'----------------------------------------------------------------------------
'Estructura de datos para Abrir y Guardar como...
'----------------------------------------------------------------------------
Private Type OPENFILENAME
lStructSize As Long
hwndOwner As Long
hInstance As Long
lpstrFilter As String
lpstrCustomFilter As String
nMaxCustFilter As Long
nFilterIndex As Long
lpstrFile As String
nMaxFile As Long
lpstrFileTitle As String
nMaxFileTitle As Long
lpstrInitialDir As String
lpstrTitle As String
Flags As Long
nFileOffset As Integer
nFileExtension As Integer
lpstrDefExt As String
lCustData As Long
lpfnHook As Long
lpTemplateName As String
End Type
Private Declare Function GetOpenFileName Lib "comdlg32.dll" Alias "GetOpenFileNameA" (pOpenFilename As OPENFILENAME) As Long
Public Function ShowOpen(Optional ByVal vFileName, Optional ByVal vTitle, Optional ByVal vFilter, Optional vFlags, Optional ByVal vhWnd) As Boolean
'----------------------------------------------------------
'Método para mostrar el cuadro de diálogo de Abrir
'
'(c) Guillermo Som Cerezo 24/Oct/93
'
'Convertido en objeto (clase) (25/Ago/97)
'
'Los parámetros opcionales especificarán:
' vFileName El nombre del archivo
' vTitle Título del cuadro de diálogo
' vFilter Extensiones
' vFlags Los flags
' vhWnd El hWnd del Form
'----------------------------------------------------------
'Const OFN_HIDEREADONLY = &H4
Const OFN_PATHMUSTEXIST = &H800
Const OFN_FILEMUSTEXIST = &H1000
Dim resultado As Long
Dim ofn As OPENFILENAME
On Local Error Resume Next
If Not IsMissing(vFileName) Then _
FileName = CStr(vFileName)
If Not IsMissing(vhWnd) Then _
hWnd = CLng(vhWnd)
If Not IsMissing(vFilter) Then _
Me.Filter = CStr(vFilter)
If Not IsMissing(vTitle) Then _
DialogTitle = CStr(vTitle)
If Not IsMissing(vFlags) Then _
Flags = CLng(vFlags)
ofn.lStructSize = Len(ofn)
ofn.hwndOwner = hWnd
ofn.hInstance = 0
If Len(sFilter) = 0 Then _
sFilter = "Todos los Archivos (*.*)" & Chr$(0) & "*.*" & Chr$(0) & Chr$(0)
ofn.lpstrFilter = sFilter
ofn.nFilterIndex = FilterIndex
ofn.lpstrFile = Left$(FileName & String$(260, 0), 260)
ofn.nMaxFile = 260
ofn.nFileOffset = 0
ofn.nFileExtension = 0
ofn.lpstrDefExt = DefaultExt
ofn.lpstrFileTitle = Left$(FileTitle & String$(260, 0), 260)
ofn.nMaxFileTitle = 260
ofn.lpstrInitialDir = Left$(InitDir & String$(260, 0), 260)
If Flags = 0 Then 'Si no se especifican los flags
Flags = OFN_PATHMUSTEXIST Or OFN_FILEMUSTEXIST
End If
ofn.Flags = Flags
If Len(DialogTitle) = 0 Then 'Si no se especifica el título
DialogTitle = "Abrir"
End If
ofn.lpstrTitle = DialogTitle
ofn.nFileOffset = 0
ofn.lpstrDefExt = 0
ofn.lCustData = 0
ofn.lpfnHook = 0
ofn.lpTemplateName = 0
resultado = GetOpenFileName(ofn)
If resultado <> 0 Then
FileName = Left$(ofn.lpstrFile, InStr(ofn.lpstrFile, Chr$(0)) - 1)
FileTitle = Left$(ofn.lpstrFileTitle, InStr(ofn.lpstrFileTitle, Chr$(0)) - 1)
InitDir = Left$(ofn.lpstrInitialDir, InStr(ofn.lpstrInitialDir, Chr$(0)) - 1)
Else
If CancelError Then
Err.Raise 32755, "cComDlg.ShowOpen", "Error en Abrir (clase cComDlg)"
End If
End If
'Devuelve True si se puede abrir
ShowOpen = (resultado <> 0)
Err = 0
On Local Error GoTo 0
End Function
Public Property Let Action(vNewValue As Integer)
'0 Ninguna acción.
'1 Muestra el cuadro de diálogo Abrir.
'2 Muestra el cuadro de diálogo Guardar como.
'3 Muestra el cuadro de diálogo Color.
'4 Muestra el cuadro de diálogo Fuente.
'5 Muestra el cuadro de diálogo Impresora.
'6 Ejecuta WINHELP.EXE.
'
Select Case vNewValue
Case 1: ShowOpen
'Case 2: ShowSave
'Case 3: 'ShowColor
'Case 4: 'ShowFont
'Case 5: 'ShowPrinter
'Case 6: 'ShowHelp
'Case Else
'nada que mostrar
End Select
End Property
Public Property Let Filter(ByVal sNewFilter As String)
'Procesar el parámetro para convertirlo a formato C,
'Se usará | como separador.
Dim i As Integer, j As Integer
Dim sTmp As String
sTmp = ""
If InStr(sNewFilter, "|") Then
sNewFilter = Trim$(sNewFilter)
If Right$(sNewFilter, 1) <> "|" Then
sNewFilter = sNewFilter & "|"
End If
Do
i = InStr(sNewFilter, "|")
If i Then
sTmp = sTmp & Left$(sNewFilter, i - 1) & Chr$(0)
sNewFilter = Mid$(sNewFilter, i + 1)
Else
Exit Do
End If
Loop While i
If Right$(sTmp, 1) = Chr$(0) Then
sNewFilter = sTmp & Chr$(0)
Else
sNewFilter = sTmp & Chr$(0) & Chr$(0)
End If
ElseIf InStr(sNewFilter, Chr$(0)) = 0 Then
sNewFilter = ""
End If
sFilter = sNewFilter
End Property
