Mensajes

Como puedo hacer , para borrarme delos registros de " aquí ".-  gracias

¿A que te refieres?, ¿quieres borrar tu cuenta dices?, en ese caso, ¿por qué motivo?.

De todas formas los miembros del staff que tienen los suficientes privilegios como para tomar la decisión de eliminación de usuario no lo harían, el acceso a tu cuenta tal vez si, pero los mensajes que escribiste no serían borrados ya que estos ayudan al crecicmiento y conservación del foro en general.

Si tienes un problema con un post/comentario en particular y quieres borrarlo, o cualquier otro tipo de altercado, entonces siempre puedes explicar el motivo y entonces ya se verá,
si no das ningún motivo para una petición de esa magnitud pues sinceramente no se que esperas que te digamos, como entenderás, por que alguien pida que borren su cuenta o un post o lo que sea, sin una razón consistente no se va a hacer.

EDITO: Veo que ya has preguntado 3 veces lo mismo y te borraron las preguntas... y digo yo, no tendrá que ver con que te hayan cerrado este post, ¿verdad?:
http://foro.elhacker.net/dudas_generales/clonar_un_ssd-t445105.0.html;msg2049217#msg2049217

Me asombra mucho que una persona digamos mayor tenga estos piques infantiles y pida que le borren su cuenta por algo así, y no es la primera vez.

Ese usuario intentó ofenderte, luego tú intentaste ofenderle a él, y por último Simorg tomó cartas en el asunto cerrando el post, ambos os insultasteis así que no se a que viene ahora esta "¿queja?" o petición. Si quieres que te reabran ese post entonces no hagas esto, haz la pregunta adecuada a quien te cerró el post.

Si me equivoco y tu extraña petición no tiene que ver con eso... entonces lo siento.

Saludos

Si no te manejas bien con el event-viewer, lee la respuesta que dejé en otro foro con una posible solución:



Fuente:
http://superuser.com/questions/985302/how-can-i-view-my-recent-device-activity/985304#985304

Saludos

[WindowMagnetizer.Threshold]

He estado refactorizando un viejo snippet, el cual es de mis favoritos, por ese motivo lo posteo aquí para hacer una mención especial y no en el apartado de snippets.

Lo que voy a mostrar es la forma más sencilla (copy&paste) para añadir magnetismo a una ventana.

Personalmente considero que todos deberiamos implementar esta funcionalidad en nuestras aplicaciones, ya que es una funcionalidad muy útil para mantener la organizción de las ventanas en la pantalla, cosa que cualquier usuario-final de su aplicación lo sabrá agradecer.

El magnetismo de ventanas consiste en que, al mover la ventana/Form cerca de un borde de la pantalla, la ventana se adhiera a dicho borde.



Nota: Esta funcionalidad estará incluida en la próxima versión de mi API ElektroKit: http://foro.elhacker.net/net/elektrokit_v10_api_de_proposito_general_para_desarrolladores_de_net-t444997.0.html



El siguiente código está escrito en Vb.Net (es suficiente con copiar, pegar y usar) pero se puede compilar en una dll para desarrolladores de código-C#.

La Class tiene dos propiedades importantes de personalización, la primera propiedad es WindowMagnetizer.Threshold, que indica el margen, en píxeles, en el que se debe producir el magnetismo. Yo suelo utilizar un valor de 35 píxeles ya que soy muy basto moviendo el ratón, pero creo que un valor de 20 seria lo apropiado de forma generalizada.

La otra propiedad se llama WindowMagnetizer.AllowOffscreen, que como su propio nombre indica por si mismo, sirve para habilitar o deshabilitar el poder mover la ventana fuera de los límites de la pantalla activa. (he tenido en cuenta la existencia de una pantalla dual).

El uso de esta class es muy, muy sencillo, tanto como esto:

Código (vbnet) [Seleccionar] Expandir

Private magnetizer As New WindowMagnetizer(Me) With
   {
       .Enabled = True,
       .AllowOffscreen = True,
       .Threshold = 30
   }

Código (csharp) [Seleccionar] Expandir

private WindowMagnetizer magnetizer;

private void Form1_Load(object sender, EventArgs e) {

  magnetizer = new WindowMagnetizer(this)
                   {
                       Enabled = true,
                       AllowOffscreen = true,
                       Threshold = 30
                   };  
}

Sin más, el código fuente:

Código (vbnet) [Seleccionar] Expandir

' ***********************************************************************
' Author   : Elektro
' Modified : 01-December-2015
' ***********************************************************************

#Region " Public Members Summary "

#Region " Constructors "

' WindowMagnetizer.New(IWin32Window)

#End Region

#Region " Properties "

' WindowMagnetizer.Handle As IntPtr
' WindowMagnetizer.OwnerWindow As IWin32Window
' WindowMagnetizer.Threshold As Integer
' WindowMagnetizer.Enabled As Boolean
' WindowMagnetizer.AllowOffscreen As Boolean

#End Region

#Region " Methods "

' WindowMagnetizer.Dispose()

#End Region

#End Region

#Region " Usage Examples "

'Private magnetizer As New WindowMagnetizer(Me) With
'    {
'        .Enabled = True,
'        .AllowOffscreen = True,
'        .Threshold = 30
'    }

#End Region

#Region " Option Statements "

Option Explicit On
Option Strict On
Option Infer Off

#End Region

#Region " Imports "

Imports System
Imports System.ComponentModel
Imports System.Drawing
Imports System.Linq
Imports System.Runtime.InteropServices
Imports System.Windows.Forms

' Imports Elektro.Interop.Win32
' Imports Elektro.Interop.Win32.Enums
' Imports Elektro.Interop.Win32.Types

#End Region

#Region " Window Magnetizer "

   ''' ----------------------------------------------------------------------------------------------------
   ''' <summary>
   ''' Add magnetism to the edges of a window,
   ''' in this way, by bringing the window to a screen edge, the edge of the window adheres it to the edge of the screen.
   ''' </summary>
   ''' ----------------------------------------------------------------------------------------------------
   ''' <example> This is a code example.
   ''' <code>
   ''' Private magnetizer As New WindowMagnetizer(Me) With
   '''     {
   '''         .Enabled = True,
   '''         .AllowOffscreen = True,
   '''         .Threshold = 30
   '''     }
   ''' </code>
   ''' </example>
   ''' ----------------------------------------------------------------------------------------------------
   Public Class WindowMagnetizer : Inherits NativeWindow : Implements IDisposable

#Region " Private Fields "

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Determines whether the owner window is being resized by one of its edges.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       Protected isResizing As Boolean

#End Region

#Region " Properties "

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Gets the window that owns this <see cref="WindowMagnetizer"/> instance.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <value>
       ''' The window.
       ''' </value>
       ''' ----------------------------------------------------------------------------------------------------
       Public Overridable ReadOnly Property OwnerWindow As IWin32Window
           <DebuggerStepThrough>
           Get
               Return Me.ownerWindowB
           End Get
       End Property
       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' ( Backing field )
       ''' The window that owns this <see cref="WindowMagnetizer"/> instance.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       Protected ownerWindowB As IWin32Window

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Gets the handle for the window that owns this <see cref="WindowMagnetizer"/> instance.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <value>
       ''' The handle.
       ''' </value>
       ''' ----------------------------------------------------------------------------------------------------
       Public Overridable Shadows ReadOnly Property Handle As IntPtr
           <DebuggerStepThrough>
           Get
               Return MyBase.Handle
           End Get
       End Property

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Gets or sets, in pixels, the minimum threshold that the magnetic window needs to dock it on the nearest window border.
       ''' <para></para>
       ''' (Default value is <c>20</c>))
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <value>
       ''' The minimum threshold that the magnetic window needs to dock it on the nearest window border.
       ''' </value>
       ''' ----------------------------------------------------------------------------------------------------
       Public Overridable Property Threshold As Integer
           <DebuggerStepThrough>
           Get
               Return Me.thresholdB
           End Get
           <DebuggerStepThrough>
           Set(ByVal value As Integer)
               Me.thresholdB = value
           End Set
       End Property
       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' ( Backing field )
       ''' The minimum threshold that the magnetic window needs to dock it on the nearest window border.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       Protected thresholdB As Integer

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Gets or sets a value indicating whether the magnetizer is enabled.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <value>
       ''' <see langword="True"/> if the magnetizer is enabled, otherwise, <see langword="False"/>.
       ''' </value>
       ''' ----------------------------------------------------------------------------------------------------
       Public Overridable Property Enabled As Boolean
           <DebuggerStepThrough>
           Get
               Return Me.enabledB
           End Get
           <DebuggerStepThrough>
           Set(ByVal value As Boolean)
               Me.enabledB = value
           End Set
       End Property
       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' ( Backing field )
       ''' A value indicating whether the magnetizer is enabled.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       Protected enabledB As Boolean

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Gets or sets a value indicating whether the window can be moved off-screen.
       ''' <para></para>
       ''' Default value is <see langword="True"/>.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <value>
       ''' <see langword="True"/> if the window can be moved off-screen, otherwise, <see langword="False"/>.
       ''' </value>
       ''' ----------------------------------------------------------------------------------------------------
       Public Overridable Property AllowOffscreen As Boolean
           <DebuggerStepThrough>
           Get
               Return Me.allowOffscreenB
           End Get
           <DebuggerStepThrough>
           Set(ByVal value As Boolean)
               Me.allowOffscreenB = value
           End Set
       End Property
       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' ( Backing field )
       ''' A value indicating whether the window can be moved off-screen.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       Protected allowOffscreenB As Boolean

#End Region

#Region " Constructors "

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Prevents a default instance of the <see cref="WindowMagnetizer"/> class from being created.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       <DebuggerNonUserCode>
       Private Sub New()
       End Sub

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Initializes a new instance of the <see cref="WindowMagnetizer"/> class.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <param name="window">
       ''' The <see cref="IWin32Window"/> window that owns this instance (eg. a <see cref="Form"/> window).
       ''' </param>
       ''' ----------------------------------------------------------------------------------------------------
       <DebuggerStepThrough>
       Public Sub New(ByVal window As IWin32Window)

           Me.allowOffscreenB = True
           Me.thresholdB = 20
           Me.ownerWindowB = window

           MyBase.AssignHandle(window.Handle)

       End Sub

#End Region

#Region " Private Methods "

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' If the margin between the specified <paramref name="window"/>
       ''' and the nearest border of the active screeen is lower than the value specified in <paramref name="threshold"/>,
       ''' then it docks the window to the border.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <param name="window">
       ''' The magnetic window.
       ''' </param>
       '''
       ''' <param name="windowPosHandle">
       ''' A pointer to a <see cref="Interop.Win32.Types.WindowPos"/> structure that contains the
       ''' new size and position of the <paramref name="window"/>.
       ''' </param>
       '''
       ''' <param name="threshold">
       ''' The minimum threshold that the window needs to dock it on the nearest desktop border.
       ''' </param>
       ''' ----------------------------------------------------------------------------------------------------
       Protected Overridable Sub DockToNearestScreenBorder(ByVal window As IWin32Window,
                                                           ByVal windowPosHandle As IntPtr,
                                                           Optional ByVal threshold As Integer = 0I)

           Dim workingArea As Rectangle =
               Screen.FromControl(DirectCast(window, Control)).WorkingArea ' Active screen.

           workingArea.Width = 0
           workingArea.Height = 0

           Screen.AllScreens.ToList.ForEach(
               Sub(scr As Screen)
                   workingArea.Width += scr.WorkingArea.Width
                   workingArea.Height += scr.WorkingArea.Height
               End Sub)

           Dim windowPos As WindowPos =
               CType(Marshal.PtrToStructure(windowPosHandle, GetType(WindowPos)), WindowPos)

           If (windowPos.Y = 0) OrElse (windowPos.X = 0) Then
               ' Nothing to do.
               Exit Sub
           End If

           Dim win32Rect As Rect
           Dim rect As Rectangle
           NativeMethods.GetWindowRect(window.Handle, win32Rect)
           rect = win32Rect

           ' Top border
           If ((windowPos.Y >= -threshold) AndAlso
              ((workingArea.Y > 0) AndAlso (windowPos.Y <= (threshold + workingArea.Y)))) _
           OrElse ((workingArea.Y <= 0) AndAlso (windowPos.Y <= threshold)) Then

               windowPos.Y = workingArea.Y

           End If

           ' Left border
           If (windowPos.X >= (workingArea.X - threshold)) AndAlso
              (windowPos.X <= (workingArea.X + threshold)) Then

               windowPos.X = workingArea.X

           ElseIf (windowPos.X <= (workingArea.X - threshold)) AndAlso
                  Not (Me.allowOffscreenB) Then

               windowPos.X = workingArea.X

           End If

           ' Right border.
           If ((windowPos.X + rect.Width) <= (workingArea.Right + threshold)) AndAlso
              ((windowPos.X + rect.Width) >= (workingArea.Right - threshold)) Then

               windowPos.X = (workingArea.Right - rect.Width)

           ElseIf ((windowPos.X + rect.Width) >= (workingArea.Right + threshold)) AndAlso
                  Not (Me.allowOffscreenB) Then

               windowPos.X = (workingArea.Right - rect.Width)

           End If

           ' Bottom border.
           If ((windowPos.Y + rect.Height) <= (workingArea.Bottom + threshold)) AndAlso
              ((windowPos.Y + rect.Height) >= (workingArea.Bottom - threshold)) Then

               windowPos.Y = (workingArea.Bottom - rect.Height)

           ElseIf ((windowPos.Y + rect.Height) >= (workingArea.Bottom + threshold)) AndAlso
                  Not (Me.allowOffscreenB) Then

               windowPos.Y = (workingArea.Bottom - rect.Height)

           End If

           ' Marshal it back.
           Marshal.StructureToPtr(structure:=windowPos, ptr:=windowPosHandle, fDeleteOld:=True)

       End Sub

#End Region

#Region " Window Procedure (WndProc) "

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Invokes the default window procedure associated with this window to process windows messages.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <param name="m">
       ''' A <see cref="T:Message"/> that is associated with the current Windows message.
       ''' </param>
       ''' ----------------------------------------------------------------------------------------------------
       <DebuggerStepThrough>
       Protected Overrides Sub WndProc(ByRef m As Message)

           Select Case m.Msg

               Case WindowsMessages.WmSizing
                   Me.isResizing = True

               Case WindowsMessages.WmExitSizeMove
                   Me.isResizing = False

               Case WindowsMessages.WmWindowPosChanging

                   If Not (Me.isResizing) AndAlso (Me.enabledB) Then
                       Me.DockToNearestScreenBorder(window:=Me.ownerWindowB,
                                                    windowPosHandle:=m.LParam,
                                                    threshold:=Me.thresholdB)
                   End If

           End Select

           MyBase.WndProc(m)

       End Sub

#End Region

#Region " Hidden Base Members "

       <EditorBrowsable(EditorBrowsableState.Never)>
       <DebuggerNonUserCode>
       Public Shadows Function ReferenceEquals(ByVal objA As Object, ByVal objB As Object) As Boolean
           Return Object.ReferenceEquals(objA, objB)
       End Function

       <EditorBrowsable(EditorBrowsableState.Never)>
       <DebuggerNonUserCode>
       Public Shadows Function GetHashCode() As Integer
           Return MyBase.GetHashCode
       End Function

       <EditorBrowsable(EditorBrowsableState.Never)>
       <DebuggerNonUserCode>
       Public Shadows Function [GetType]() As Type
           Return MyBase.GetType
       End Function

       <EditorBrowsable(EditorBrowsableState.Never)>
       <DebuggerNonUserCode>
       Public Shadows Function Equals(ByVal obj As Object) As Boolean
           Return MyBase.Equals(obj)
       End Function

       <EditorBrowsable(EditorBrowsableState.Never)>
       <DebuggerNonUserCode>
       Public Shadows Function ToString() As String
           Return MyBase.ToString
       End Function

       <EditorBrowsable(EditorBrowsableState.Never)>
       <DebuggerNonUserCode>
       Public Shadows Sub AssignHandle(ByVal handle As IntPtr)
           MyBase.AssignHandle(handle)
       End Sub

       <EditorBrowsable(EditorBrowsableState.Never)>
       <DebuggerNonUserCode>
       Public Shadows Sub CreateHandle(ByVal cp As CreateParams)
           MyBase.CreateHandle(cp)
       End Sub

       <EditorBrowsable(EditorBrowsableState.Never)>
       <DebuggerNonUserCode>
       Public Shadows Sub DestroyHandle()
           MyBase.DestroyHandle()
       End Sub

       <EditorBrowsable(EditorBrowsableState.Never)>
       <DebuggerNonUserCode>
       Public Shadows Sub ReleaseHandle()
           MyBase.ReleaseHandle()
       End Sub

       <EditorBrowsable(EditorBrowsableState.Never)>
       <DebuggerNonUserCode>
       Public Shadows Function FromHandle(ByVal handle As IntPtr) As NativeWindow
           Return NativeWindow.FromHandle(handle)
       End Function

       <EditorBrowsable(EditorBrowsableState.Never)>
       <DebuggerNonUserCode>
       Public Shadows Function GetLifeTimeService() As Object
           Return MyBase.GetLifetimeService
       End Function

       <EditorBrowsable(EditorBrowsableState.Never)>
       <DebuggerNonUserCode>
       Public Shadows Function InitializeLifeTimeService() As Object
           Return MyBase.InitializeLifetimeService
       End Function

       <EditorBrowsable(EditorBrowsableState.Never)>
       <DebuggerNonUserCode>
       Public Shadows Function CreateObjRef(ByVal requestedType As Type) As System.Runtime.Remoting.ObjRef
           Return MyBase.CreateObjRef(requestedType)
       End Function

       <EditorBrowsable(EditorBrowsableState.Never)>
       <DebuggerNonUserCode>
       Public Shadows Sub DefWndProc(ByRef m As Message)
           MyBase.DefWndProc(m)
       End Sub

#End Region

#Region " IDisposable Implementation "

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' To detect redundant calls when disposing.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       Protected isDisposed As Boolean

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Releases all the resources used by this instance.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       <DebuggerStepThrough>
       Public Sub Dispose() Implements IDisposable.Dispose

           Me.Dispose(isDisposing:=True)
           GC.SuppressFinalize(obj:=Me)

       End Sub

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
       ''' Releases unmanaged and - optionally - managed resources.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <param name="isDisposing">
       ''' <see langword="True"/>  to release both managed and unmanaged resources;
       ''' <see langword="False"/> to release only unmanaged resources.
       ''' </param>
       ''' ----------------------------------------------------------------------------------------------------
       <DebuggerStepThrough>
       Protected Overridable Sub Dispose(ByVal isDisposing As Boolean)

           If (Not Me.isDisposed) AndAlso (isDisposing) Then

               With Me
                   .enabledB = False
                   .AllowOffscreen = True
                   .thresholdB = 0
               End With

               MyBase.ReleaseHandle()
               MyBase.DestroyHandle()

           End If

           Me.isDisposed = True

       End Sub

#End Region

   End Class

#End Region

P/Invokes:

Código (vbnet) [Seleccionar] Expandir

       <SuppressUnmanagedCodeSecurity>
       <DllImport("user32.dll", SetLastError:=True)>
       Public Shared Function GetWindowRect(ByVal hwnd As IntPtr,
                                            ByRef rect As Rect
       ) As <MarshalAs(UnmanagedType.Bool)> Boolean
       End Function

Código (vbnet) [Seleccionar] Expandir

Public Enum WindowsMessages As Integer

        WmSizing = &H214
        WmExitSizeMove = &H232
        WmWindowPosChanging = &H46

End Enum

Código (vbnet) [Seleccionar] Expandir

Imports System
Imports System.Diagnostics
Imports System.Linq
Imports System.Runtime.InteropServices

#Region " Window Pos "

   ''' ----------------------------------------------------------------------------------------------------
   ''' <summary>
   ''' Contains information about the size and position of a window.
   ''' </summary>
   ''' ----------------------------------------------------------------------------------------------------
   ''' <remarks>
   ''' <see href="http://msdn.microsoft.com/en-us/library/windows/desktop/ms632612%28v=vs.85%29.aspx"/>
   ''' </remarks>
   ''' ----------------------------------------------------------------------------------------------------
   <DebuggerStepThrough>
   <StructLayout(LayoutKind.Sequential)>
   Public Structure WindowPos

#Region " Fields "

       ''' <summary>
       ''' A handle to the window.
       ''' </summary>
       Public Hwnd As IntPtr

       ''' <summary>
       ''' The position of the window in Z order (front-to-back position).
       ''' This member can be a handle to the window behind which this window is placed,
       ''' or can be one of the special values listed with the 'SetWindowPos' function.
       ''' </summary>
       Public HwndInsertAfter As IntPtr

       ''' <summary>
       ''' The position of the left edge of the window.
       ''' </summary>
       Public X As Integer

       ''' <summary>
       ''' The position of the top edge of the window.
       ''' </summary>
       Public Y As Integer

       ''' <summary>
       ''' The window width, in pixels.
       ''' </summary>
       Public Width As Integer

       ''' <summary>
       ''' The window height, in pixels.
       ''' </summary>
       Public Height As Integer

       ''' <summary>
       ''' Flag containing the window position.
       ''' </summary>
       Public Flags As Integer

#End Region

   End Structure

#End Region

Código (vbnet) [Seleccionar] Expandir

Imports System
Imports System.Diagnostics
Imports System.Drawing
Imports System.Linq
Imports System.Runtime.InteropServices

#Region " Rect "

   ''' ----------------------------------------------------------------------------------------------------
   ''' <summary>
   ''' Defines the coordinates of the upper-left and lower-right corners of a rectangle.
   ''' </summary>
   ''' ----------------------------------------------------------------------------------------------------
   ''' <remarks>
   ''' <see href="http://msdn.microsoft.com/en-us/library/windows/desktop/dd162897%28v=vs.85%29.aspx"/>
   ''' <para></para>
   ''' <see href="http://www.pinvoke.net/default.aspx/Structures/rect.html"/>
   ''' </remarks>
   ''' ----------------------------------------------------------------------------------------------------
   <DebuggerStepThrough>
   <StructLayout(LayoutKind.Sequential)>
   Public Structure Rect

#Region " Properties "

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Gets or sets the x-coordinate of the upper-left corner of the rectangle.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <value>
       ''' The x-coordinate of the upper-left corner of the rectangle.
       ''' </value>
       ''' ----------------------------------------------------------------------------------------------------
       Public Property Left As Integer

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Gets or sets the y-coordinate of the upper-left corner of the rectangle.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <value>
       ''' The y-coordinate of the upper-left corner of the rectangle.
       ''' </value>
       ''' ----------------------------------------------------------------------------------------------------
       Public Property Top As Integer

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Gets or sets the x-coordinate of the lower-right corner of the rectangle.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <value>
       ''' The x-coordinate of the lower-right corner of the rectangle.
       ''' </value>
       ''' ----------------------------------------------------------------------------------------------------
       Public Property Right As Integer

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Gets or sets the y-coordinate of the lower-right corner of the rectangle.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <value>
       ''' The y-coordinate of the lower-right corner of the rectangle.
       ''' </value>
       ''' ----------------------------------------------------------------------------------------------------
       Public Property Bottom As Integer

#End Region

#Region " Constructors "

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Initializes a new instance of the <see cref="Rect"/> struct.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <param name="left">
       ''' The x-coordinate of the upper-left corner of the rectangle.
       ''' </param>
       '''
       ''' <param name="top">
       ''' The y-coordinate of the upper-left corner of the rectangle.
       ''' </param>
       '''
       ''' <param name="right">
       ''' The x-coordinate of the lower-right corner of the rectangle.
       ''' </param>
       '''
       ''' <param name="bottom">
       ''' The y-coordinate of the lower-right corner of the rectangle.
       ''' </param>
       ''' ----------------------------------------------------------------------------------------------------
       Public Sub New(ByVal left As Integer,
                      ByVal top As Integer,
                      ByVal right As Integer,
                      ByVal bottom As Integer)

           Me.Left = left
           Me.Top = top
           Me.Right = right
           Me.Bottom = bottom

       End Sub

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Initializes a new instance of the <see cref="Rect"/> struct.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <param name="rect">
       ''' The <see cref="Rectangle"/>.
       ''' </param>
       ''' ----------------------------------------------------------------------------------------------------
       Public Sub New(ByVal rect As Rectangle)

           Me.New(rect.Left, rect.Top, rect.Right, rect.Bottom)

       End Sub

#End Region

#Region " Operator Conversions "

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Performs an implicit conversion from <see cref="Rect"/> to <see cref="Rectangle"/>.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <param name="rect">The <see cref="Rect"/>.
       ''' </param>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <returns>
       ''' The resulting <see cref="Rectangle"/>.
       ''' </returns>
       ''' ----------------------------------------------------------------------------------------------------
       Public Shared Widening Operator CType(rect As Rect) As Rectangle

           Return New Rectangle(rect.Left, rect.Top, (rect.Right - rect.Left), (rect.Bottom - rect.Top))

       End Operator

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Performs an implicit conversion from <see cref="Rectangle"/> to <see cref="Rect"/>.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <param name="rect">The <see cref="Rectangle"/>.
       ''' </param>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <returns>
       ''' The resulting <see cref="Rect"/>.
       ''' </returns>
       ''' ----------------------------------------------------------------------------------------------------
       Public Shared Widening Operator CType(rect As Rectangle) As Rect

           Return New Rect(rect)

       End Operator

#End Region

   End Structure

#End Region

Espero que esto les pueda servir de ayuda.

Saludos!

¿No hay nada para girar la pantalla y que funcione en XP? Encontré varios códigos que funcionan en Vista y posterior pero no en XP.

Nop, pero tampoco tengo el propósito de desarrollar código para dar soporte a un sistema operativo deprecado .

Quizás esta librería te sirva:
https://multimonitorhelper.codeplex.com/
https://github.com/ChrisEelmaa/MultiMonitorHelper/tree/master

Fuente y ejemplo de uso:
http://stackoverflow.com/questions/11087613/how-do-i-set-the-monitor-orientation-in-windows-7

Gracias por el comentario

saludos!

Y bueno la verdad no se muy bien como aplicar todo el ejemplo en una aplicacion de Windows Forms y si quisiera mostrar el nombre del documento al que se le sumo "+1" en un label ?.

Hombre, no te lo voy a hacer todo. Creo haberte resuelto la parte importante del problema que podría resultarte más problemática y espero que ahora hayas podido entender como aplicarlo al código, de lo contrario, pregunta.

Sin saber muy bien como lo quieres hacer, el Form yo lo dejaría así:


Se trata de un Form con un label, un ListBox, y dos botones.

En el código del Form, solo tienes que iterar el archivo de texto que contiene las preguntas y respuestas (el cual tampoco se como está delimitado así que no puedo ponerte un ejemplo) y mostrar cada pregunta en el label, y las respuestas en el ListBox.

Pseudo-Ejemplo, con muchos comentarios para ayudarte a comprender todo a la primera :

( el foro da error al intentar publicar el código, así que te dejo un enlace )

http://pastebin.com/8yHJZara

Saludos

[int.TryParse]

Lo que no entiendo es a que hace referencia cada cosa...

El primer argumento de la función es la ruta de directorio donde buscar archivos, y el segundo argumento determina el tipo de extensión (.txt).

Como le digo a la funcion que quiero que lea los archivos de determinado documento? por ejemplo una carpeta llamada "Datos" y que se encuentre en Disco C

Pasándole como primer argumento dicho directorio:

Código (csharp) [Seleccionar] Expandir

ileInfo file = GetFileWithBiggestNumberInFilename("C:\\Datos", ".txt");

Tendria que reeplazar el "string dirpath" ? por algo asi como "string dirpath = @"C:\datos\";?.

Si no quieres utilizar una función, entonces si que debes modificar la variable dirpath para asignarle el directorio como has dicho.

Lo que no entiendo es para que el.

Código (csharp) [Seleccionar] Expandir

int result = 0;
...
where int.TryParse(Path.GetFileNameWithoutExtension(file.Name), out result)
...

La función int.TryParse sirve para intentar convertir un string a un número entero de 32 bits (int).

donde se almacena el resultado? en Result ? Es en esa variable de tipo int donde se almacena el numero del archivo que necesito? en este caso el mayor?

La variable result es usada para almacenar un valor booleano (true/false) que determina si la conversión a int de la función int.TryParse tuvo éxito. nada más.

Con eso le quitas la extensión al archivo?

Con la función Path.GetFileNameWithoutExtension obtengo el nombre del archivo sin extensión, eso elimina la extensión y también la ruta de directorio dejando solamente el nombre de archivo ...pero esto es temporal simplemente para acondicionar la evaluación del primer argumento que toma la función int.TryParse, el por qué de esto es simple, si dejo la ruta de directorio y la extensión ".txt" obviamente ni lo uno ni lo otro se puede representar como un número, en cambio el nombre de archivo si, ya que dijiste que son nombres de archivo numéricos.

No se si me habrás entendido bien.

- Eso fue solo un ejemplo y tengo que ver la manera de como aplicarlo con relacion al primer codigo ? pregunto porque me imagino que se tiene que hacer referencia a "result" en algun lugar de este codigo o no?...

No, no es ningún ejemplo que debas adaptar, lo único que debes adaptar son los argumentos que le pasas a la función GetFileWithBiggestNumberInFilename para indicar la ruta en donde quieres que se busquen los archivos y la extensión de archivo a buscar.

El código es completamente funcional, es una función de uso genérico, tú le indicas un directorio a la función y esta buscará el nombre de archivo numérico más grande y te devolverá una representación de ese archivo (contenido en el valor de retorno de la función), que es un objeto de tipo FileInfo.

El valor de retorno de dicha función ya se asigna a la variable file:

Código (csharp) [Seleccionar] Expandir

FileInfo file = GetFileWithBiggestNumberInFilename("C:\\", ".txt");

Olvida la variable result, eso simplemente es parte de la lógica del algoritmo utilizado para buscar/evaluar y devolverte el objeto FileInfo. El valor de retorno es lo que te debe interesar.

y si quisiera mostrar el nombre del documento al que se le sumo "+1" en un label ?.

Tomando como referencia el código que te mostré, en el segundo bloque de código declaro la variable newFilepath la cual contiene la ruta completa del nuevo archivo a crear (con el número incrementado). Te lo dejé todo bien fácil, solo tienes que observar de nuevo el código para saber como obtener el nombre de archivo de una ruta completa, haciendo uso de la función Path.GetFileNameWithoutExtension(), Path.GetFileName(), o creando una instancia de la class FileInfo.

Ejemplo:

Código (csharp) [Seleccionar] Expandir

this.Label1.Text = Path.GetFileName(newFilepath);

o también:

Código (csharp) [Seleccionar] Expandir

this.Label1.Text = New FileInfo(newFilepath).Name;

Saludos

[¿Podemos predecir el momento de nuestra muerte?]

¿Podemos predecir el momento de nuestra muerte?

No, no podemos. El futuro no está predeterminado, y en el caso de que lo estuviera, su computación no es posible.

Yo empezaría por una pregunta más básica, "¿podemos predecir el futuro?", si, por supuesto, eso es precisamente una de las habilidades que nos define como seres humanos, la inteligencia, lo que conlleva a poder predecir las consecuencias de nuestros actos en la linea del tiempo, predecir el futuro (o al menos el futuro como creemos que este lo será) ...hasta cierto punto claro está; y si en un momento dado somos completamente conscientes de que dadas las circunstancias específicas, habiendo evaluado correctamente todos los posibles factores vemos que el futuro que predecimos no puede ser otro más que la muerte inevitable, por ejemplo si vemos que se estamos cayendo al vacío, ¿entonces que argumento hay para intentar refutar esto?.

Pondré un ejemplo sencillo, una persona se cae desde una avioneta y va a 250 km/h por hora (por decir algo, no se cuanta velocidad puede alcanzar una persona que se cae de un avión xD). No importa las circunstancias que se den, ni auqnue aparezca una alfombra mágica voladora y te caigas encima, dada la velocidad del impacto la persona morirá ocurra lo que ocurra, ¿alguien puede decir que esto no es así?.

Otra forma más "natural" que se me ocurre de predecir nuestra muerte es implicando una decisión de suicidio, queriendo morir, es decir, una persona suicida que haya tomado la decisión de morir, y esté avanzando hacia una ventana para saltar, y salte. Claro que ...la persona debe haber tomado la decisión, no haberse arrepentido en el último momento.

Puedo poner otro ejemplo mucho más rebuscado, por ejemplo si tenemos un "cacharro" que funciona mediante un reloj atómico, y sabemos que cuando dicho cacharro hace "tick" se dispara una bala que sabemos que irá a "X" velocidad" (en circunstancias de laboratorio con unas condiciones acondicionadas para que suceda todo como queramos), y nos ponemos en frente del cacharro, entonces habriamos podido computar o predecir el momento exacto de nuestra muerte, ¿no?.

Se que es muy rebuscado, pero no por eso deja de ser una prueba, ¿o no?.

Saludos!

La presentación está muy chula.

Saludos!

El tema ha sido movido a Java.

http://foro.elhacker.net/index.php?topic=444983.0

[¿Qué es ElektroKit?]

¿Qué es ElektroKit?

ElektroKit es un sofisticado y completo conjunto de utilidades con nuevas APIs y extensiones de método para complementar al núclero de .Net Framework, para ayudarle así a completar su caja de herramientas de programación con esta librería de classes adicional. ElektroKit se distribuye en un conjunto de (por el momento) 22 21 librerías que están enfocadas hacia diversas temáticas: DESCARGA (v2.0) GitHub: Compilación + Documentación + Código fuente Paquete Nuget DONACIONES Con la intención de soportar la continuidad de este proyecto, por el esfuerzo invertido y la motivación para seguir actualizando, quizás usted quiera considerar donar la cantidad de dinero que desee, mediante Paypal, haciendo click en la siguuiente imagen: ¡¡ MUCHAS GRACIAS !! CONTRIBUICIONES Para contribuir fisicamente modificando el código fuente, pueden crear una bifurcación (fork) del proyecto desde GitHub, haciendo click en esta imagen: BUGS, PETICIONES Y SUGERENCIAS Pueden dejar su comentario en este post para cualquier duda, petición o sugerencia, todo es bienvenido. También pueden utilizar el rastreador de problemas de GitHub para reportar bugs, haciendo click en esta imagen: DOCUMENTACIÓN Todos los miembros del código fuente están documentados, la documentación se distribuye de varias formas. Pueden acceder a la documentación online mediante esta imagen: También pueden obtener la documentación en formato CHM haciendo click en esta imagen: Nótese que existen multitud de ejemplos de código en ambas documentaciones, los cuales pueden ser un buen punto de partida para comprender como utilizar ElektroKit: ( click para agrandar ) También pueden inspeccionar la documentación Xml en el código fuente: ( click para agrandar ) O examinar la descripción de los miembros mediante Intellisense o el examinador de objetos de Visual Studio: RESUMEN DE MIEMBROS Resulta imposible mencionar cada una de las funcionalidades de ElektroKit, realmente son muchísimas (y para eso ya está la documentación), intentaré hacer un breve resumen resaltando características que les podrían resultar muy interesantes. SI TE HA GUSTADO MI APORTE, ¡COMENTA!