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
'=======================================================

Haz una dll con esa class "taskbar.cs" y luego referencias la dll a tu proyecto y listo.

No intentes traducir el code a VB, no vas a saber ni a poder hacerlo, los traductores online no saben traducirlo,
En el code de C# se llama a una función sin parámetros como si fuese un parámetro en si mismo, y eso en VB no sé como sería el equivalente.

Creo que haré una pregunta sobre como traducir ese maldita código ...sino posteas tu la misma pregunta antes que yo xD

Creo que djiste que no era esto, pero si que es:

¿Has probado a modificar la propiedad SHOWINTASKBAR a FALSE como te dije?, si no muestras el icono de la aplicación en el taskbar imagino que el taskbar no tendría motivos para "saltar".

Si eso no es suficiente, entonces como ya te dije hay que usar APIs: http://www.codeproject.com/Articles/25572/Hiding-the-Taskbar-and-Startmenu-start-orb-in-Wind


Saludos

Esto ya está mejor, aunque la parte "alternativa" no está pulida, la parte "progresiva" está sin bugs:

Public Class Form1
 
    Dim Scroll_Position As Int32 = 0
    Dim Button_Down_Is_Pressed As Boolean = False
    Dim Button_Up_Is_Pressed As Boolean = False
    Dim WithEvents Progressive_Scroll_Timer As New Timer
    Dim SmallChange As Int32 = 10
    Dim Largechange As Int32 = 20
    Dim Maximum As Int64 = 0
 
    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        Panel1.AutoScroll = True
        Maximum = Panel1.VerticalScroll.Maximum
        Panel1.AutoScroll = False
        Panel1.VerticalScroll.Maximum = Maximum / 2
        Progressive_Scroll_Timer.Interval = 50
        Panel1.BackColor = Color.FromArgb(150, 0, 0, 0)
 
        For Each PicBox As PictureBox In Panel1.Controls
            AddHandler PicBox.MouseHover, AddressOf Panel_MouseHover
        Next
 
    End Sub
 
    Private Sub Panel_MouseHover(sender As Object, e As EventArgs) Handles Panel1.MouseHover
        sender.select()
        sender.focus()
    End Sub
 
    Private Sub Timer1_Tick(sender As Object, e As EventArgs) Handles Progressive_Scroll_Timer.Tick
        If Button_Down_Is_Pressed Then
            Scroll_Down(SmallChange)
        ElseIf Button_Up_Is_Pressed Then
            Scroll_Up(SmallChange)
        Else
            sender.stop()
        End If
    End Sub
 
    Private Sub Scroll_Up(ByVal Change As Int32)
        Scroll_Position -= Change
        Try
            Panel1.VerticalScroll.Value = Scroll_Position
        Catch
            Scroll_Position = 0
        End Try
    End Sub
 
    Private Sub Scroll_Down(ByVal Change As Int32)
        Scroll_Position += Change
        Try
            Panel1.VerticalScroll.Value = Scroll_Position
        Catch
            Scroll_Position -= Change
        End Try
    End Sub
 
    Private Sub Button_Down_MouseDown(sender As Object, e As MouseEventArgs) Handles Button2.MouseDown
        If e.Button = Windows.Forms.MouseButtons.Left Then
            Button_Down_Is_Pressed = True
            Progressive_Scroll_Timer.Start()
        End If
    End Sub
 
    Private Sub Button_Up_MouseDown(sender As Object, e As MouseEventArgs) Handles Button1.MouseDown
        If e.Button = Windows.Forms.MouseButtons.Left Then
            Button_Up_Is_Pressed = True
            Progressive_Scroll_Timer.Start()
        End If
    End Sub
 
    Private Sub Button_Down_MouseUp(sender As Object, e As MouseEventArgs) Handles Button2.MouseUp
        Button_Down_Is_Pressed = False
    End Sub
 
    Private Sub Button_Up_MouseUp(sender As Object, e As MouseEventArgs) Handles Button1.MouseUp
        Button_Up_Is_Pressed = False
    End Sub
 
    Private Sub Form_MouseWheel(ByVal sender As Object, ByVal e As MouseEventArgs) Handles Panel1.MouseWheel
        Select Case Math.Sign(e.Delta)
            Case Is > 0 : Scroll_Up(Largechange)
            Case Is < 0 : Scroll_Down(Largechange)
        End Select
    End Sub
 
 
 
    ' Versión alternativa:
    Dim PictureBoxes_Height As Int64 = 100 ' La altura de cada picturebox
 
    Private Sub Button3_Click(sender As Object, e As EventArgs) Handles Button3.Click
        Scroll_Position -= PictureBoxes_Height
        Try
            Panel1.VerticalScroll.Value = Scroll_Position
        Catch
            Panel1.VerticalScroll.Value = 1
            Scroll_Position += PictureBoxes_Height
        End Try
    End Sub
 
    Private Sub Button4_Click(sender As Object, e As EventArgs) Handles Button4.Click
        Scroll_Position += PictureBoxes_Height
        Try
            Panel1.VerticalScroll.Value = Scroll_Position
        Catch
 
            Scroll_Position -= PictureBoxes_Height
        End Try
    End Sub
    ' Fin de versión alternativa
 
End Class

Public Class DoubleBufferedPanel
    Inherits Panel
 
    Public Sub New()
        DoubleBuffered = True
        ResumeLayout(False)
    End Sub
 
    Protected Overrides ReadOnly Property CreateParams() As CreateParams
        Get
            Dim cp As CreateParams = MyBase.CreateParams
            cp.ExStyle = cp.ExStyle Or &H2000000
            Return cp
        End Get
    End Property
 
End Class

ups... me equivoquñe de post al comentar xD (...tienes tantos).

http://foro.elhacker.net/net/scroll_de_imagenes-t391409.0.html;msg1858088#msg1858088

Sorry por el spam.

Como heredar un control para eliminar al 100% el Flickering en un control Default de un WindowsForm:

(Me he pasado unos 3-5 meses buscando una solución eficaz a esto ...Y aunque esta no es la solución más óptima, funciona y la considero eficaz en el aspecto de que funciona al 100%, pero leer el comentario que he dejado en inglés.)

Public Class Panel_Without_Flickering
 
    Inherits Panel
 
    Public Sub New()
        Me.DoubleBuffered = False
        Me.ResumeLayout(False)
    End Sub
 
    ' Caution:
    ' This turns off any Flicker effect
    ' ...but also reduces the performance (speed) of the control about 30% slower.
    ' This don't affect to the performance of the application, only to the performance of this control.
    Protected Overrides ReadOnly Property CreateParams() As CreateParams
        Get
            Dim cp As CreateParams = MyBase.CreateParams
            cp.ExStyle = cp.ExStyle Or &H2000000
            Return cp
        End Get
    End Property
 
End Class

---

Un ejemplo hecho por mi de como heredar un control cualquiera, más bien es una especie de plantilla...

Public Class MyControl  ' Name of this control.
 
    Inherits PictureBox ' Name of the inherited control.
 
#Region " New "
 
    Public Sub New()
        Me.DoubleBuffered = True
        Me.SetStyle(ControlStyles.ResizeRedraw, False)
        Me.Name = "MyControl"
        'Me.Text = "Text"
        'Me.Size = New Point(60, 60)
    End Sub
 
#End Region
 
#Region " Properties "
 
    Private _Description As String = String.Empty
 
    ''' <summary>
    ''' Add a description for this control.
    ''' </summary>
    Public Property Description() As String
        Get
            Return _Description
        End Get
        Set(ByVal Value As String)
            Me._Description = Value
        End Set
    End Property
 
#End Region
 
#Region " Event handlers "
 
    ' Private Sub MyControl_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Click
    '    Me.ForeColor = Color.White
    '    Me.BackColor = Color.CadetBlue
    ' End Sub
 
    ' Protected Overrides Sub OnPaint(ByVal pEvent As PaintEventArgs)
    '    MyBase.OnPaint(pEvent)
    '    If Me.Checked Then
    '       pEvent.Graphics.FillRectangle(New SolidBrush(Color.YellowGreen), New Rectangle(3, 4, 10, 12))
    '    End If
    ' End Sub
 
#End Region
 
#Region " Methods / Functions "
 
    ''' <summary>
    ''' Show the autor of this control.
    ''' </summary>
    Public Sub About()
        MsgBox("Elektro H@cker")
    End Sub
 
#End Region
 
End Class

sip!

Ves haciéndolo y si te surge un problema al leer el valor del ini o al crear los pictureboxes te ayudo de mejor forma

Por cierto, para colocarlos dentro del panel:

panel1.controls.add(MyNewPanel)

---

PD: ya tienes el dubspet subido en la url que te dije, pero se me jodió la subida 2 veces y el server no tiene "resume" así q he subido solo accesos directos.

Claro.

No esperes añadir los pictureboxes de forma permanente, eso no puedes hacerlo, es imposible porque en el Source no están declarados, tienes que generar los controles desde el código.

No me parece que séa un problema que al cerrar la app "se eliminen", si al volver a iniciar la app se volverían a generar los controles (crear, nombrar, colocar, redimensionar, lo que quieras) gracias a tu INI.

Saludos

Si un array de controles de forma dinámica.


Pues "detecta" el número de modpacks que hay instalados y vas creando en tiempo de ejecución cada picturebox como te expliqué... "For x to NúmeroDeModpacks"

Mírate mi post de snippets de vez en cuando, para algo está:

    Dim chk_() As CheckBox
 
    Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
 
        Dim Array_Size As Integer = 300 'change this for the number of controls that will appear
        ReDim chk_(Array_Size)
 
        For chk_num = 0 To Array_Size
            Application.DoEvents()
            chk_(chk_num) = New CheckBox
            chk_(chk_num).Text = "Checkbox " + chk_num.ToString
            chk_(chk_num).Top = 20 * chk_num
            Me.Controls.Add(chk_(chk_num))
        Next
 
    End Sub

300 pictureboxes o cuantos quieras

Salu2

Puedes definir el número de pictureboxes que serán, guardas ese número en el ini, y lo lees...

For i as int32 = 1 to (valor)
   generar checkboxes
loop

no se si te refieres a hacer eso,
mañana hablamos por skype