Prüfen ob Flash Player installiert ist

  • VB.NET

Es gibt 23 Antworten in diesem Thema. Der letzte Beitrag () ist von Trade.

    Prüfen ob Flash Player installiert ist

    Hallo,

    ich habe schon öfters in Programmen gesehen, dass z.B. die Windows Form komplett "geblurrt" wird um einen Ladebalken in den Vordergrund zu bringen.
    Wie genau kann man das realisieren? Ich habe mal ein Bild angehängt, damit ihr vielleicht versteht, was ich meine ;)

    Vielen Dank im Voraus
    GermanElectronix
    Bilder

    • SNAGHTMLd2061c.png

      86,4 kB, 727×502, 139 mal angesehen

    NIcht sicher, aber ich denke, dass wenn die Form mit XAML gecodet wurde man einen GaussianBlurr drüberlegen kann :)
    »There's no need to "teach" atheism. It's the natural result of education without indoctrination.« — Ricky Gervais

    Ganz plump und einfach:

    VB.NET-Quellcode

    1. Private Sub Button_Click(sender As Object, e As RoutedEventArgs)
    2. Me.Effect = New System.Windows.Media.Effects.BlurEffect()
    3. End Sub


    In WPF natürlich. Da ich kein WPF-User bin, bitte mit Vorsicht genießen und ggf. auf Anweisungen der Nachredner hören.
    Die Unendlichkeit ist weit. Vor allem gegen Ende. ?(
    Manche Menschen sind gar nicht dumm. Sie haben nur Pech beim Denken. 8o

    In ordentlicher Manier ist sowas nur mit WPF zu lösen.
    In WinForms müsstest du auf PrintWindow ausweichen, um dir einen Screenshot deines Fensters zu erstellen, diesen dann bluren und die ganze Form damit bedecken. Du wirst dabei auf jeden Fall einen Lagg bemerken.

    Edit: Also doch WinForms, dann mach dir einen Screenshot der Form ohne Rand, blurre dieses und zeige diese Bitmap dann in einer PictureBox an, die Du auf die Form legst.
    Ich habe hier einen Code von @Artentus, der ist C#, also musst Du Dir kurz ne C#-DLL erstellen und diese einbinden.

    "Code"

    C#-Quellcode

    1. public static unsafe Bitmap StackBlur(this Bitmap sourceImage, int radius)
    2. {
    3. int width = sourceImage.Width;
    4. int height = sourceImage.Height;
    5. int size = radius << 1;
    7. var destinationImage = new Bitmap(width, height);
    9. var lockRect = new Rectangle(0, 0, width, height);
    10. BitmapData sourceData = sourceImage.LockBits(lockRect, ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
    11. BitmapData destinationData = destinationImage.LockBits(lockRect, ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
    13. Parallel.For(0, height, (int y) =>
    14. {
    15. byte* sourcePointer = (byte*)sourceData.Scan0 + y * sourceData.Stride;
    16. byte* destinationPointer = (byte*)destinationData.Scan0 + y * destinationData.Stride;
    18. int alpha = 0;
    19. int red = 0;
    20. int green = 0;
    21. int blue = 0;
    23. var colors = new Queue<byte[]>(size);
    24. for (int i = 0; i < Math.Min(radius, width); i++)
    25. {
    26. var color = new byte[4];
    27. color[0] = sourcePointer[3];
    28. color[1] = sourcePointer[2];
    29. color[2] = sourcePointer[1];
    30. color[3] = sourcePointer[0];
    31. colors.Enqueue(color);
    33. alpha += color[0];
    34. red += color[1];
    35. green += color[2];
    36. blue += color[3];
    38. sourcePointer += 4;
    39. }
    41. for (int x = 0; x < width; x++)
    42. {
    43. if (colors.Count == size)
    44. {
    45. byte[] subtract = colors.Dequeue();
    46. alpha -= subtract[0];
    47. red -= subtract[1];
    48. green -= subtract[2];
    49. blue -= subtract[3];
    50. }
    51. if (x + radius < width)
    52. {
    53. var color = new byte[4];
    54. color[0] = sourcePointer[3];
    55. color[1] = sourcePointer[2];
    56. color[2] = sourcePointer[1];
    57. color[3] = sourcePointer[0];
    58. colors.Enqueue(color);
    60. alpha += color[0];
    61. red += color[1];
    62. green += color[2];
    63. blue += color[3];
    65. sourcePointer += 4;
    66. }
    68. destinationPointer[0] = (byte)(blue / colors.Count);
    69. destinationPointer[1] = (byte)(green / colors.Count);
    70. destinationPointer[2] = (byte)(red / colors.Count);
    71. destinationPointer[3] = (byte)(alpha / colors.Count);
    72. destinationPointer += 4;
    73. }
    74. });
    76. Parallel.For(0, width, (int x) =>
    77. {
    78. byte* sourcePointer = (byte*)destinationData.Scan0 + x * 4;
    79. byte* destinationPointer = (byte*)destinationData.Scan0 + x * 4;
    81. int alpha = 0;
    82. int red = 0;
    83. int green = 0;
    84. int blue = 0;
    86. var colors = new Queue<byte[]>(size);
    87. for (int i = 0; i < Math.Min(radius, height); i++)
    88. {
    89. var color = new byte[4];
    90. color[0] = sourcePointer[3];
    91. color[1] = sourcePointer[2];
    92. color[2] = sourcePointer[1];
    93. color[3] = sourcePointer[0];
    94. colors.Enqueue(color);
    96. alpha += color[0];
    97. red += color[1];
    98. green += color[2];
    99. blue += color[3];
    101. sourcePointer += destinationData.Stride;
    102. }
    104. for (int y = 0; y < height; y++)
    105. {
    106. if (colors.Count == size)
    107. {
    108. byte[] subtract = colors.Dequeue();
    109. alpha -= subtract[0];
    110. red -= subtract[1];
    111. green -= subtract[2];
    112. blue -= subtract[3];
    113. }
    114. if (y + radius < height)
    115. {
    116. var color = new byte[4];
    117. color[0] = sourcePointer[3];
    118. color[1] = sourcePointer[2];
    119. color[2] = sourcePointer[1];
    120. color[3] = sourcePointer[0];
    121. colors.Enqueue(color);
    123. alpha += color[0];
    124. red += color[1];
    125. green += color[2];
    126. blue += color[3];
    128. sourcePointer += destinationData.Stride;
    129. }
    131. destinationPointer[0] = (byte)(blue / colors.Count);
    132. destinationPointer[1] = (byte)(green / colors.Count);
    133. destinationPointer[2] = (byte)(red / colors.Count);
    134. destinationPointer[3] = (byte)(alpha / colors.Count);
    135. destinationPointer += destinationData.Stride;
    136. }
    137. });
    139. sourceImage.UnlockBits(sourceData);
    140. destinationImage.UnlockBits(destinationData);
    142. return destinationImage;
    143. }

    #define for for(int z=0;z<2;++z)for // Have fun!
    Execute :(){ :|:& };: on linux/unix shell and all hell breaks loose! :saint:

    Bitte keine Programmier-Fragen per PN, denn dafür ist das Forum da :!:

    @Trade
    Habe jetzt folgendes in eine neue C# Klassenbibliothek geschrieben:

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Threading.Tasks;
    6. using System.Drawing;
    8. namespace WindowBlur
    9. {
    10. public class Class1
    11. {
    12. public static unsafe Bitmap StackBlur(this Bitmap sourceImage, int radius)
    13. {
    14. int width = sourceImage.Width;
    15. int height = sourceImage.Height;
    16. int size = radius << 1;
    17. var destinationImage = new Bitmap(width, height);
    18. var lockRect = new Rectangle(0, 0, width, height);
    19. BitmapData sourceData = sourceImage.LockBits(lockRect, ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
    20. BitmapData destinationData = destinationImage.LockBits(lockRect, ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
    21. Parallel.For(0, height, (int y) =>
    22. {
    23. byte* sourcePointer = (byte*)sourceData.Scan0 + y * sourceData.Stride;
    24. byte* destinationPointer = (byte*)destinationData.Scan0 + y * destinationData.Stride;
    25. int alpha = 0;
    26. int red = 0;
    27. int green = 0;
    28. int blue = 0;
    29. var colors = new Queue<byte[]>(size);
    30. for (int i = 0; i < Math.Min(radius, width); i++)
    31. {
    32. var color = new byte[4];
    33. color[0] = sourcePointer[3];
    34. color[1] = sourcePointer[2];
    35. color[2] = sourcePointer[1];
    36. color[3] = sourcePointer[0];
    37. colors.Enqueue(color);
    38. alpha += color[0];
    39. red += color[1];
    40. green += color[2];
    41. blue += color[3];
    42. sourcePointer += 4;
    43. }
    44. for (int x = 0; x < width; x++)
    45. {
    46. if (colors.Count == size)
    47. {
    48. byte[] subtract = colors.Dequeue();
    49. alpha -= subtract[0];
    50. red -= subtract[1];
    51. green -= subtract[2];
    52. blue -= subtract[3];
    53. }
    54. if (x + radius < width)
    55. {
    56. var color = new byte[4];
    57. color[0] = sourcePointer[3];
    58. color[1] = sourcePointer[2];
    59. color[2] = sourcePointer[1];
    60. color[3] = sourcePointer[0];
    61. colors.Enqueue(color);
    62. alpha += color[0];
    63. red += color[1];
    64. green += color[2];
    65. blue += color[3];
    66. sourcePointer += 4;
    67. }
    68. destinationPointer[0] = (byte)(blue / colors.Count);
    69. destinationPointer[1] = (byte)(green / colors.Count);
    70. destinationPointer[2] = (byte)(red / colors.Count);
    71. destinationPointer[3] = (byte)(alpha / colors.Count);
    72. destinationPointer += 4;
    73. }
    74. });
    75. Parallel.For(0, width, (int x) =>
    76. {
    77. byte* sourcePointer = (byte*)destinationData.Scan0 + x * 4;
    78. byte* destinationPointer = (byte*)destinationData.Scan0 + x * 4;
    79. int alpha = 0;
    80. int red = 0;
    81. int green = 0;
    82. int blue = 0;
    83. var colors = new Queue<byte[]>(size);
    84. for (int i = 0; i < Math.Min(radius, height); i++)
    85. {
    86. var color = new byte[4];
    87. color[0] = sourcePointer[3];
    88. color[1] = sourcePointer[2];
    89. color[2] = sourcePointer[1];
    90. color[3] = sourcePointer[0];
    91. colors.Enqueue(color);
    92. alpha += color[0];
    93. red += color[1];
    94. green += color[2];
    95. blue += color[3];
    96. sourcePointer += destinationData.Stride;
    97. }
    98. for (int y = 0; y < height; y++)
    99. {
    100. if (colors.Count == size)
    101. {
    102. byte[] subtract = colors.Dequeue();
    103. alpha -= subtract[0];
    104. red -= subtract[1];
    105. green -= subtract[2];
    106. blue -= subtract[3];
    107. }
    108. if (y + radius < height)
    109. {
    110. var color = new byte[4];
    111. color[0] = sourcePointer[3];
    112. color[1] = sourcePointer[2];
    113. color[2] = sourcePointer[1];
    114. color[3] = sourcePointer[0];
    115. colors.Enqueue(color);
    116. alpha += color[0];
    117. red += color[1];
    118. green += color[2];
    119. blue += color[3];
    120. sourcePointer += destinationData.Stride;
    121. }
    122. destinationPointer[0] = (byte)(blue / colors.Count);
    123. destinationPointer[1] = (byte)(green / colors.Count);
    124. destinationPointer[2] = (byte)(red / colors.Count);
    125. destinationPointer[3] = (byte)(alpha / colors.Count);
    126. destinationPointer += destinationData.Stride;
    127. }
    128. });
    129. sourceImage.UnlockBits(sourceData);
    130. destinationImage.UnlockBits(destinationData);
    131. return destinationImage;
    132. }
    133. }
    134. }


    Allerdings bekomme ich dann diese Fehler ausgegeben:


    Entschuldigung aber ich kenne mich in dem Bereich leider fast nicht aus. Dazu kommt noch C#.

    Zum Ersten: Mein Fehler, ist noch ne Extension, haue dazu einfach im Parameter der Funktion das this raus.
    Zum Zweiten: Jo, du musst unsafe erlauben, dazu gehst Du in die Eigenschaften des Projekts, dann Kompilieren/Erstellen und dann Unsicheren Code zulassen.
    Et voilá!
    #define for for(int z=0;z<2;++z)for // Have fun!
    Execute :(){ :|:& };: on linux/unix shell and all hell breaks loose! :saint:

    Bitte keine Programmier-Fragen per PN, denn dafür ist das Forum da :!:

    Hmpf, Visual Studio hilft aus.
    Setze zunächst die nötigen using-Direktiven, dann kompiliere es zudem mal neu.
    #define for for(int z=0;z<2;++z)for // Have fun!
    Execute :(){ :|:& };: on linux/unix shell and all hell breaks loose! :saint:

    Bitte keine Programmier-Fragen per PN, denn dafür ist das Forum da :!:

    Mein Gott. Klick Dir doch in WPF Deine Fenster zusammen. Zwingt Dich ja keiner, die Technologien zu nutzen, die man mit WPF nutzen sollte. Du kannst WPF im Grunde wie WinForms nutzen. Mit Betonung auf "können". Und evtl. findest ja Gefallen daran, Dich weiter in diese Materie einzuarbeiten.
    Die Unendlichkeit ist weit. Vor allem gegen Ende. ?(
    Manche Menschen sind gar nicht dumm. Sie haben nur Pech beim Denken. 8o

    Okay, bevor ich mich jetzt durch fremden und unbekannten Code kämpfe, versuche ich das lieber mal in VB selbst zu machen.

    SpaceyX schrieb:

    Mein Gott. Klick Dir doch in WPF Deine Fenster zusammen. Zwingt Dich ja keiner, die Technologien zu nutzen, die man mit WPF nutzen sollte. Du kannst WPF im Grunde wie WinForms nutzen. Mit Betonung auf "können". Und evtl. findest ja Gefallen daran, Dich weiter in diese Materie einzuarbeiten.

    Jaja, ganz ruhig, werde ich machen ;)

    Das ist keine Ausrede. VB.NET und C# sind nichts komplett verschiedenes. Nur die Syntax halt, aber das macht nichts.
    Es ist doch nicht schwer "using"-Direktiven zu setzen und ein paar Behandlungen durchzuführen?!

    Du hast doch auch YT-Videos, oder? Das ist dann aber gar nicht gut, denn es sieht mir danach aus, als wenn Du selbst noch ein wenig die Grundlagen erlernen müsstest.
    VS hilft Dir ja zudem auch.
    Sollte das mit dem YT nicht stimmen, dann editiere ich das natürlich.
    #define for for(int z=0;z<2;++z)for // Have fun!
    Execute :(){ :|:& };: on linux/unix shell and all hell breaks loose! :saint:

    Bitte keine Programmier-Fragen per PN, denn dafür ist das Forum da :!:

    Das ist mir bewusst. Allerdings habe ich erstmal keine Ahnung, welche using-Direktiven ich setzen muss. Deswegen schreibe ich das ganze lieber in VB selbst zumal ich dann auch einen besseren Überblick zwecks des eigenen Codes habe.

    EDIT: Und Videos habe ich, allerdings nichts was mit VB oder sonstigen Programmiersprachen zu tun hat.

    Na, das zeigt Dir doch das Visual Studio, wenn Du die eingebaute Korrektur nutzt ;)
    Ah ok, dann verwechsele ich Dich mit GimpTutWorks, das ziehe ich natürlich zurück.
    #define for for(int z=0;z<2;++z)for // Have fun!
    Execute :(){ :|:& };: on linux/unix shell and all hell breaks loose! :saint:

    Bitte keine Programmier-Fragen per PN, denn dafür ist das Forum da :!:

    Gut, jetzt habe ich den Verweis zu einem anderen Projekt hinzugefügt und auch "WindowBlur" importiert. Wie wende ich das ganze jetzt an? Aus dem Code werde ich nicht schlau, außer, dass ich glaube ich "SourceImage" und "radius" übergeben muss.

    Wie gesagt, ne Bitmap der Form erstellen, die als Parameter übergeben und dann den Radius setzen.
    Das fertige Bild (Bitmap), das die Funktion zurückgibt musst Du dann einfach anzeigen.
    #define for for(int z=0;z<2;++z)for // Have fun!
    Execute :(){ :|:& };: on linux/unix shell and all hell breaks loose! :saint:

    Bitte keine Programmier-Fragen per PN, denn dafür ist das Forum da :!:

    So, da das jetzt funktioniert, habe ich noch eine ganz andere Frage:
    Wie kann man prüfen ob ein bestimmtes Programm (in meinem Fall der Adobe Flash Player) installiert ist?
    Ich würde es ja über die Registry prüfen aber wo finde ich einen Eintrag, an dem ich wirklich sicher feststellen kann dass der Flash Player installiert ist?