Descripción:
Esta aplicación sirve para organizar canciones que estemos escuchando en WinAmp.

Imaginemos que tenemos una carpeta con 1.000 canciones, de varios estilos, reproducimos la carpeta en WinAmp y queremos organizar las canciones enviándolas a distintos directorios según el estilo de música que séa cada canción, pues para eso existe esta aplicaicón.


Imágenes:











Demostración:

Quizás puede resultar un poco dificil entender el concepto o la finalidad de la aplicaicon, por eso pueden ver este video donde se muestran todas las funciones del programa:



Descarga:

Título : WTF (WinampToFolder)
Versión: 1.1
Framework: 4.0
Requisitos: Winamp -> www.winamp.com
Descarga: http://ElektroStudios.tk/WinampToFolder.zip

PD: El programa ha sido testeado con la version 5.X de WinAmp.

Espero que os guste,
Saludos!

Necesito los típicos botones de Play, Pause, Stop, Previous y Next, preferíblemente de estilo mínimal.

El problema de buscar estos iconos en google images es que te pueden salir resultados muy variados, por ejemplo un icono azul y otro rosa... ya me entienden.

Sé como encontrar este tipo de recursos de manera más eficaz... pero antes de ponerme a revisar las infinitas páginas de DeviantArt y otros sitios pues... me gustaría saber si alguien ha hecho algún proyecto relacionado a reproductores de video/audio y si quiere compartir el pack de iconos que usó en su reproductor...
 
Gracias.

Por si no lo entienden, aquí irian los iconos de los botonoes:



Saludos.

EDITO:

Pfff... La verdad es que todos los sets de iconos que encuentro son de pago... y en deviantart y findicons no encuentro nada parecido.

Busco algo más o menos como esto:

Desde el día 14 de este més Youtube ha modificado los streams de los videos "VEVO" y otros tipos de videos "de autores" ...por llamarlo así.

¿Alguien sabe como descargar estos videos de Youtube?

Con JDownloader es imposible, además según el hilo oficial no van a añadir soporte porque el nuevo formato está protegido por una estúpida ley Alemana.

He probado con muchas extensiones para Firefox, igual que otros gestores de descarga como IDM, pero todo ha sido inutil.

Una url de ejemplo: http://www.youtube.com/watch?v=lES1SB9SqQw

Un saludo.

Hola,
bueno pues mi PC hace muchísimo ruido y me gustaría saber que necesito comprar para disminuir el ruido de manera considerable.

...Es que no sé si debo centrarme en los ventiladores (añadir más ventiladores o reemplazar los que hay), o en el disipador (reemplazar el disipador).

Además debo decir que el ruido del ventilador no sé percibir exáctamente si se trata del ventilador de la GPU o del CPU... :-/ (Normalmento no gasto la GPU así que pienso que será el de la CPU)

Y en la bios tengo el modo "silencioso" activado, pero silencioso mis cullons... xD

Aquí tienen la info de las temperaturas y otros datos de mi PC por si sirve de algo o ven algo que no esté bien:







Un saludo.

Hola

A ver, me estoy volviendo bastante loco con esto...

Hace unos pocos días me descargué una Class de VB para examinarla, el caso es que al usar el Intellisense sobre una de las funciones que contenia la Class, la información XML de los parámetros de dicha función aparecía debajo del tag de la descripción, en un color azúl cielo brillante, este tag precísamente:

''' <param name="Number">Description of the Number parameter</param>

Lo que sale en rojo pues en el Intellisense aparecia en color azul junto a la descripción en el color grisaceo ese de la IDE, pero el parámetro destacaba mucho vaya! y junto a la descripción del parámetro hacia el entendimiento de la función mucho más sencilla...
 
...en fín, el caso es que me gustó mucho ese efecto azulado (además de poder añadir descripción para un parámetro) así que hice un Copy/Paste de esa línea para agregarlo a una de mis funciones...

...Y el problema es que por más que lo intento no consigo que el intellisense me muestre nada, solo me muestra la descripción, a pesar de tener varias líneas escritas incluyendo la del parámetro:

    ''' <summary>
    ''' Function to pause a thread.
    ''' </summary>
    ''' 
    ''' <param name="Process_Name">The name of the process, ex: cmd.exe</param>
    ''' <param name="Thread_Number">The thread to pause, ex: 0</param>
    ''' <param name="Recursive"> <value name="True">Pause the thread in all processes recursively</value></param>
    ''' <returns>True if the process is found; otherwise, False.</returns>
    Public Shared Function Pause_Thread(ByRef Process_Name As String, _
                              Optional ByVal Thread_Number As Int32 = 0, _
                              Optional ByVal Recursive As Boolean = False) As Boolean

Y esto es lo que me muestra el Intellisense:



Según lo que ví en la Class que me descargué, me debería mostrar el parámetro en un color azúl, debajo de la descripción,
...es decir, justo debajo de "Function to pause a thread" debería salir "Process_Name" en azúl brillante, y a la derecha debería poner "The name of the process, ex: cmd.exe" en color blanco.

¿Alguien sabe en que estoy fallando?

PD: Por desgracia no guardé la Class, copié lo único que me interesaba ...que era el ejemplo de la documentación XML en azul brillante, y no recuerdo que Class era ni de donde la saqué ni nada.

PD2: Tengo activado el archivo de configuración XML en las propiedades del proyecto en la pestaña de Compilar.

Necesito ayuda con este xml para escapar el CDATA de la variable del RegEx (No quiero usar comillas dobles porque en otros códigos no puedo hacerlo),
no sé nada de XML y estoy perdido, muy perdido, no sé si esto tiene solución, ¿Que puedo hacer?:

<?xml version="1.0" encoding="utf-8"?>
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <CodeSnippet Format="1.0.0">
    <Header>
      <SnippetTypes>
        <SnippetType>Expansion</SnippetType>
      </SnippetTypes>
      <Title>
         Regex match htm html
      </Title>
      <Author>Elektro H@cker</Author>
      <Description>
         Expresión regular para encontrar urls.htm
      </Description>
      <HelpUrl>
      </HelpUrl>
      <Shortcut>
      </Shortcut>
    </Header>
    <Snippet>
      <Declarations>
        <Literal Editable="true">
          <ID>aaaaaaaaa</ID>
          <ToolTip>sfsdf</ToolTip>
          <Default>
          </Default>
          <Function>sdfsdf</Function>
        </Literal>
      </Declarations>
      <Code Language="vb"><![CDATA[
 
 
 
 
 
        Dim RegEx As New System.Text.RegularExpressions.Regex( _
        <a><![CDATA[(http://|https://|www).*\.html?]]></a>.Value)
 
 
 
 
 
]]></Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

Según esto al final del comentario a mi no me ha quedado muy claro si hay algún "trick" para mezclar los CDATA y que funcione :S : http://stackoverflow.com/questions/223652/is-there-a-way-to-escape-a-cdata-end-token-in-xml

...¿Alguna ayuda?

Hola

No puedo hallar la manera de traducir esta línea de código por mi mismo, espero que puedan ayudarme.

El problema es en este For, que se usa la función anónima "MyEnumThreadWindowsProc" como un argumento, sin pasarle argumentos a dicha función, y esto no sé traducirlo a VBNET.

foreach (ProcessThread t in p.Threads)
{
  EnumThreadWindows(t.Id, MyEnumThreadWindowsProc, IntPtr.Zero);
}

Los traductores no saben traducirlo corréctamente, y obtengo este reusltado:

For Each t As ProcessThread In p.Threads
  EnumThreadWindows(t.Id, MyEnumThreadWindowsProc, IntPtr.Zero)
Next

Según una persona me ha comentado hace poco, esto podría ser una solución:

   For Each t As ProcessThread In p.Threads
  Dim returnMyEnumThreadWindowsProc As Object
  returnMyEnumThreadWindowsProc = MyEnumThreadWindowsProc ( ... )
  EnumThreadWindows(t.Id, returnMyEnumThreadWindowsProc , IntPtr.Zero)
Next

...Pero aún así sigo con el problema de no saber que parámetros enviarle a "MyEnumThreadWindowsProc " en esa última modificación.

---

Aquí tienen la class de C#:

using System;
using System.Text;
using System.Runtime.InteropServices;
using System.Diagnostics;
 
namespace TaskbarHide
{
    /// <summary>
    /// Helper class for hiding/showing the taskbar and startmenu on
    /// Windows XP and Vista.
    /// </summary>
    public static class Taskbar
    {
        [DllImport("user32.dll")]
        private static extern int GetWindowText(IntPtr hWnd, StringBuilder text, int count); 
        [DllImport("user32.dll", CharSet = CharSet.Auto)]
        private static extern bool EnumThreadWindows(int threadId, EnumThreadProc pfnEnum, IntPtr lParam);
        [DllImport("user32.dll", SetLastError = true)]
        private static extern System.IntPtr FindWindow(string lpClassName, string lpWindowName);
        [DllImport("user32.dll", SetLastError = true)]
        private static extern IntPtr FindWindowEx(IntPtr parentHandle, IntPtr childAfter, string className,  string windowTitle);
        [DllImport("user32.dll")]
        private static extern IntPtr FindWindowEx(IntPtr parentHwnd, IntPtr childAfterHwnd, IntPtr className, string windowText);
        [DllImport("user32.dll")]
        private static extern int ShowWindow(IntPtr hwnd, int nCmdShow);
        [DllImport("user32.dll")]
        private static extern uint GetWindowThreadProcessId(IntPtr hwnd, out int lpdwProcessId);
 
        private const int SW_HIDE = 0;
        private const int SW_SHOW = 5;
 
        private const string VistaStartMenuCaption = "Start";
        private static IntPtr vistaStartMenuWnd = IntPtr.Zero;
        private delegate bool EnumThreadProc(IntPtr hwnd, IntPtr lParam);
 
        /// <summary>
        /// Show the taskbar.
        /// </summary>
        public static void Show()
        {
            SetVisibility(true);
        }
 
        /// <summary>
        /// Hide the taskbar.
        /// </summary>
        public static void Hide()
        {
            SetVisibility(false);
        }
 
        /// <summary>
        /// Sets the visibility of the taskbar.
        /// </summary>
        public static bool Visible
        {
            set { SetVisibility(value); }
        }
 
        /// <summary>
        /// Hide or show the Windows taskbar and startmenu.
        /// </summary>
        /// <param name="show">true to show, false to hide</param>
        private static void SetVisibility(bool show)
        {
            // get taskbar window
            IntPtr taskBarWnd = FindWindow("Shell_TrayWnd", null);
 
            // try it the WinXP way first...
            IntPtr startWnd = FindWindowEx(taskBarWnd, IntPtr.Zero, "Button", "Start");
 
            if (startWnd == IntPtr.Zero)
            {
                // try an alternate way, as mentioned on CodeProject by Earl Waylon Flinn
                startWnd = FindWindowEx(IntPtr.Zero, IntPtr.Zero, (IntPtr)0xC017, "Start");
            }
 
            if (startWnd == IntPtr.Zero)
            {
                // ok, let's try the Vista easy way...
                startWnd = FindWindow("Button", null);
 
                if (startWnd == IntPtr.Zero)
                {
                    // no chance, we need to to it the hard way...
                    startWnd = GetVistaStartMenuWnd(taskBarWnd);
                }
            }
 
            ShowWindow(taskBarWnd, show ? SW_SHOW : SW_HIDE);
            ShowWindow(startWnd, show ? SW_SHOW : SW_HIDE);
        }
 
        /// <summary>
        /// Returns the window handle of the Vista start menu orb.
        /// </summary>
        /// <param name="taskBarWnd">windo handle of taskbar</param>
        /// <returns>window handle of start menu</returns>
        private static IntPtr GetVistaStartMenuWnd(IntPtr taskBarWnd)
        {
            // get process that owns the taskbar window
            int procId;
            GetWindowThreadProcessId(taskBarWnd, out procId);
 
            Process p = Process.GetProcessById(procId);
            if (p != null)
            {
                // enumerate all threads of that process...
                foreach (ProcessThread t in p.Threads)
                {
                    EnumThreadWindows(t.Id, MyEnumThreadWindowsProc, IntPtr.Zero);
                }
            }
            return vistaStartMenuWnd;
        }
 
        /// <summary>
        /// Callback method that is called from 'EnumThreadWindows' in 'GetVistaStartMenuWnd'.
        /// </summary>
        /// <param name="hWnd">window handle</param>
        /// <param name="lParam">parameter</param>
        /// <returns>true to continue enumeration, false to stop it</returns>
        private static bool MyEnumThreadWindowsProc(IntPtr hWnd, IntPtr lParam)
        {
            StringBuilder buffer = new StringBuilder(256);
            if (GetWindowText(hWnd, buffer, buffer.Capacity) > 0)
            {
                Console.WriteLine(buffer);
                if (buffer.ToString() == VistaStartMenuCaption)
                {
                    vistaStartMenuWnd = hWnd;
                    return false;
                }
            }
            return true;
        }
    }
}

---

Y aquí la class "traducida":

'
' * Copyright (c) 2008..11 by Simon Baer
' * 
' *  You may use this code for whatever you want.
' 
 
 
Imports System
Imports System.Text
Imports System.Runtime.InteropServices
Imports System.Diagnostics
 
Namespace TaskbarHide
    ''' <summary>
    ''' Helper class for hiding/showing the taskbar and startmenu on
    ''' Windows XP and Vista.
    ''' </summary>
    Public NotInheritable Class Taskbar
        Private Sub New()
        End Sub
        <DllImport("user32.dll")> _
        Private Shared Function GetWindowText(hWnd As IntPtr, text As StringBuilder, count As Integer) As Integer
        End Function
        <DllImport("user32.dll", CharSet := CharSet.Auto)> _
        Private Shared Function EnumThreadWindows(threadId As Integer, pfnEnum As EnumThreadProc, lParam As IntPtr) As Boolean
        End Function
        <DllImport("user32.dll", SetLastError := True)> _
        Private Shared Function FindWindow(lpClassName As String, lpWindowName As String) As System.IntPtr
        End Function
        <DllImport("user32.dll", SetLastError := True)> _
        Private Shared Function FindWindowEx(parentHandle As IntPtr, childAfter As IntPtr, className As String, windowTitle As String) As IntPtr
        End Function
        <DllImport("user32.dll")> _
        Private Shared Function FindWindowEx(parentHwnd As IntPtr, childAfterHwnd As IntPtr, className As IntPtr, windowText As String) As IntPtr
        End Function
        <DllImport("user32.dll")> _
        Private Shared Function ShowWindow(hwnd As IntPtr, nCmdShow As Integer) As Integer
        End Function
        <DllImport("user32.dll")> _
        Private Shared Function GetWindowThreadProcessId(hwnd As IntPtr, lpdwProcessId As Integer) As UInteger
        End Function
 
        Private Const SW_HIDE As Integer = 0
        Private Const SW_SHOW As Integer = 5
 
        Private Const VistaStartMenuCaption As String = "Start"
        Private Shared vistaStartMenuWnd As IntPtr = IntPtr.Zero
        Private Delegate Function EnumThreadProc(hwnd As IntPtr, lParam As IntPtr) As Boolean
 
        ''' <summary>
        ''' Show the taskbar.
        ''' </summary>
        Public Shared Sub Show()
            SetVisibility(True)
        End Sub
 
        ''' <summary>
        ''' Hide the taskbar.
        ''' </summary>
        Public Shared Sub Hide()
            SetVisibility(False)
        End Sub
 
        ''' <summary>
        ''' Sets the visibility of the taskbar.
        ''' </summary>
        Public Shared WriteOnly Property Visible() As Boolean
            Set
                SetVisibility(value)
            End Set
        End Property
 
        ''' <summary>
        ''' Hide or show the Windows taskbar and startmenu.
        ''' </summary>
        ''' <param name="show">true to show, false to hide</param>
        Private Shared Sub SetVisibility(show As Boolean)
            ' get taskbar window
            Dim taskBarWnd As IntPtr = FindWindow("Shell_TrayWnd", Nothing)
 
            ' try it the WinXP way first...
            Dim startWnd As IntPtr = FindWindowEx(taskBarWnd, IntPtr.Zero, "Button", "Start")
 
            If startWnd = IntPtr.Zero Then
                ' try an alternate way, as mentioned on CodeProject by Earl Waylon Flinn
                startWnd = FindWindowEx(IntPtr.Zero, IntPtr.Zero, DirectCast(&Hc017, IntPtr), "Start")
            End If
 
            If startWnd = IntPtr.Zero Then
                ' ok, let's try the Vista easy way...
                startWnd = FindWindow("Button", Nothing)
 
                If startWnd = IntPtr.Zero Then
                    ' no chance, we need to to it the hard way...
                    startWnd = GetVistaStartMenuWnd(taskBarWnd)
                End If
            End If
 
            ShowWindow(taskBarWnd, If(show, SW_SHOW, SW_HIDE))
            ShowWindow(startWnd, If(show, SW_SHOW, SW_HIDE))
        End Sub
 
        ''' <summary>
        ''' Returns the window handle of the Vista start menu orb.
        ''' </summary>
        ''' <param name="taskBarWnd">windo handle of taskbar</param>
        ''' <returns>window handle of start menu</returns>
        Private Shared Function GetVistaStartMenuWnd(taskBarWnd As IntPtr) As IntPtr
            ' get process that owns the taskbar window
            Dim procId As Integer
            GetWindowThreadProcessId(taskBarWnd, procId)
 
            Dim p As Process = Process.GetProcessById(procId)
            If p IsNot Nothing Then
                ' enumerate all threads of that process...
                For Each t As ProcessThread In p.Threads
                    EnumThreadWindows(t.Id, MyEnumThreadWindowsProc, IntPtr.Zero)
                Next
            End If
            Return vistaStartMenuWnd
        End Function
 
        ''' <summary>
        ''' Callback method that is called from 'EnumThreadWindows' in 'GetVistaStartMenuWnd'.
        ''' </summary>
        ''' <param name="hWnd">window handle</param>
        ''' <param name="lParam">parameter</param>
        ''' <returns>true to continue enumeration, false to stop it</returns>
        Private Shared Function MyEnumThreadWindowsProc(hWnd As IntPtr, lParam As IntPtr) As Boolean
            Dim buffer As New StringBuilder(256)
            If GetWindowText(hWnd, buffer, buffer.Capacity) > 0 Then
                Console.WriteLine(buffer)
                If buffer.ToString() = VistaStartMenuCaption Then
                    vistaStartMenuWnd = hWnd
                    Return False
                End If
            End If
            Return True
        End Function
    End Class
End Namespace
 
'=======================================================
'Service provided by Telerik (www.telerik.com)
'Conversion powered by NRefactory.
'Twitter: @telerik, @toddanglin
'Facebook: facebook.com/telerik
'=======================================================

¿ Alguien sería tán amable de mostrarme un código para crear un Hook de bajo nivel GLOBAL (que funcione FUERA del Form) para manejar los mensajes de windows (En concreto WM_MOUSEWHEEL) ?

Esto he aprendido a hacerlo dentro del Form con la Interface "IMessageFilter", pero cuando lo intento hacer para que funcione fuera del form no hay manera, todo lo que consigo son un par de Fails!,

Me han explicado la manera de hacerlo global, se puede hacer importando la librería user32.dll (La función "SetWindowsHookEx") para crear un low-level hook para interceptar los mensajes de Windows, la teoría la tengo, pero no sé hacerlo, me trabo en el punto de intentar usar la función "SetWindowsHookEx" y crear el sub para interceptar los mensajes (if m.message = &HX then...), todo el código que encuentro es para C++/C#, y para lo poco que encuentro de VBNET, (que además tiene poco que ver con los mensajes que quiero interceptar) ni me entero, bastante dificil.

Lo que necesito es hacer algo como esto:

Pseudo-código:

Dim mousewheel_up as boolean
Dim mousewheel_down as boolean
 
Sub that Overides the windows messages to set the mousewheel booleans
 
    If mousewheel_up then msgbox("MouseWheel up")
    If mousewheel_down then msgbox("MouseWheel down")
 
End sub

Pero como ya digo, fuera del form.

Un saludo.

Hola.

Esto es pura curiosidad...

Me estaba preguntando cuanto tardaría en pulir un parser para los tags de un sitio específico, y esa pregunta me ha llevado a otra un poco ridícula quizás:
¿Cuanto tardaría en parsear un html de 100 mb?, y esta pregunta me lleva a la pregunta que reálmente quiero hacer (por curiosidad):

- ¿Existe un tamaño límite especificado en el lenguaje html?

...Es decir, ¿Si un html sobrepasa X tamaño (o número de líneas) es posible que el intérprete del navegador no pueda interpretar el código?

...¿Puede existir por la inmensa Internet un html de 2 Gb por ejemplo?, sé que es un tamaño descomunal, debería contener millones de líneas escritas, pero ahí tengo esa duda xD

Saludos!

Hola

Tengo 3 discos duros secundarios y... bueno, he estado reflexionando sobre el tema xD.

Antes yo tenía un PC con los HDD siempre encendidos, quiero decir con la configuración de energía para que no se apaguen nunca,
Esos discos nunca me dieron problemas, ni se estropearon, ni nada, es más, aún uso 1 de ellos.

Desde que me compré un nuevo PC, uso la configuración de energia para que los discos se apaguen cada 20 minutos por inactividad, pensé que era mejor apagarlos de vez en cuando aunque séan por 5 minutos.

El caso es que uso MUCHO los HDD, por ejemplo si uno se apaga pues a los 10 minutos ya estoy intentando acceder al disco, y escucho como se enciende y como tarda 2-3 segundos en iniciarse el disco (Pero eso no me importa en absoluto).

No sé que es mejor en mi caso, si dejarlos encendidos o apagarlos, porque si bien sabemos que apagar/reiniciar mucho un PC en un mismo día puede ser un punto negativo para la vida de este, no sé si ocurre lo mismo con los HDD.

En resumen, ¿Cual de estas dos opciones es más benéfica para la vida de mis HDD?
- Apagar/Encender los discos 20 veces al día.
- Dejarlos encendidos las 24 H sin apagarse.

...¿Y porqué?

Gracias por leer.