#Coding4Fun – Slap your boss away with #Skype and #LeapMotion (I’m getting ready for 2020!)

Buy Me A Coffee

Important: This repost is just to start one of my 2020 projects, which is very easy: write more fun stuff !

Hi !

During all my time working I was lucky enough to have some very cool bosses. So this is not personal at all, is just a funny way to discard a “incoming call” from someone.

The main idea is to use Leap Motion SDK and Skype for Business Desktop SDK (Lync 2013 SDK) to create a simple app which will allows us to ignore a call just doing a Swipe gesture.


Important: If you try to use Lync 2013 SDK in Windows 10 with Visual Studio 2015 or Visual Studio 15 Preview, you’ll find tons of problems. I’ll write a post on this later about the necessary steps to do this.

The source code is available in GitHub

Greetings @ Toronto

-El Bruno


#Event – Slides, source code and links used on #MSFTHacks #Hackathon

Hola ! Es momento de compartir los materiales que utilicé este fin de semana durante el Hackathon en MSFT Hacks. Empezamos por las Slides 2017 03 25 Microsoft Hacks, How to code efficiently from Bruno Capuano El código fuente se puede descargar desde aquí (link) Y los ejemplos con el Lego están basados en Channel 9, Lego […]

Hi !

Time to share some of the materials I used during the MSFT Hacks Hackathon this weekend. A couple of Slides

The Source Code is available on GitHub here  (link)

The Lego samples are based on

Greetings @ Toronto

El Bruno

#Event – Materiales utilizandos en el #Hackathon #MSFTHacks

Hola !

Es momento de compartir los materiales que utilicé este fin de semana durante el Hackathon en MSFT Hacks. Empezamos por las Slides

El código fuente se puede descargar desde aquí (link)

Y los ejemplos con el Lego están basados en

Saludos @ Toronto

El Bruno

[#RESHARPER] ReSharper 9.0 EAP para que lo pruebes right now !!!

Saturday footbal

Hola !!!

Quick post de fin de semana: todos pueden probar la versión para Early Adopters de ReSharper 9, el mismo se descarga desde sus nightly builds, y al día de hoy la más estable disponible es del 21 de Octubre.

Además, novedad interesante es la posibilidad de utilizarlo y probarlo en Visual Studio 14.


/El Bruno

Descarga: http://confluence.jetbrains.com/display/ReSharper/ReSharper+9.0+EAP

[#EVENT] Materials and Video for the #Coding4Fun Developer’s Day event



It’s been a few weeks since I participated in the event on the day of the programmer. It was a beautiful occasion since it allowed me to stand for 45 minutes in virtual form in my hometown: Cordoba Argentina. In the event, the classical materials, a little USB Hacking, Arduinos, Leap Motions, etc.

And now that I have returned from South Africa, and will finally have a couple of days at home, because I’m

Matias Iacono, thank for the opportunity to share something in remote

-Thank also the organization that commissioned in addition to record it live and share it here

-The quality of the recording is very good, however live is better Open-mouthed smile


-Share the slides

– And obviously also the fonts used in the presentation

https://onedrive.live.com/redir?resid=BEF06DFFDB192125! 78606 & authkey =!AAlKDEcYMs659L0 & ithint = file % 2czip

Video: http://www.ustream.tv/recorded/52597309

Saludos @ Home

El Bruno

image image image Google

[#LEAPMOTION] HowTo: Show the number of fingers ever the Leap


Today is going to be a quick post, I’ll change the console app for a WPF app to work with the Leap Motion. In this app, I’ll show how a gesture is detected by the sensor in addition to the amount of active fingers over the sensor. For this example I’ve used some information from in this post of the great Iris Classon to create the following listener

   1: using System;

   2: using System.Threading.Tasks;

   3: using Leap;


   5: namespace LeapWpf01

   6: {

   7:     public class ElBrunoListener : Listener

   8:     {

   9:         public void Sample(){}

  10:         public event Action<FingerList> OnFingersRegistered;

  11:         public event Action<GestureList> OnGestureMade;

  12:         private long _now;

  13:         private long _previous;

  14:         private long _timeDifference;


  16:         public override void OnInit(Controller controller) { }


  18:         public override void OnConnect(Controller controller)

  19:         {

  20:             controller.EnableGesture(Gesture.GestureType.TYPECIRCLE);

  21:             controller.EnableGesture(Gesture.GestureType.TYPEKEYTAP);

  22:             controller.EnableGesture(Gesture.GestureType.TYPESCREENTAP);

  23:             controller.EnableGesture(Gesture.GestureType.TYPESWIPE);

  24:         }


  26:         public override void OnDisconnect(Controller controller) { }


  28:         public override void OnExit(Controller controller) { }


  30:         public override void OnFrame(Controller controller)

  31:         {

  32:             var frame = controller.Frame();

  33:             _now = frame.Timestamp;

  34:             _timeDifference = _now - _previous;


  36:             if (frame.Hands.IsEmpty) return;


  38:             _previous = frame.Timestamp;

  39:             if (_timeDifference < 1000) return;


  41:             // Run async

  42:             if (frame.Gestures().Count > 0)

  43:                 Task.Factory.StartNew(() => OnGestureMade(frame.Gestures()));

  44:             if (frame.Fingers.Count > 0)

  45:                 Task.Factory.StartNew(() => OnFingersRegistered(frame.Fingers));

  46:         }

  47:     }

  48: }

The listener is quite simple, public an event with the information captured by the LEAP every 1 second.

In the MainWindow of my WPF app, I have the following code. The only thing that must be taken into consideration, is that the best sensor initialization in the Loaded() event, and always with care for closing the View close the controller and the listener with the sensor.

   1: using System;

   2: using System.ComponentModel;

   3: using System.Diagnostics;

   4: using System.Runtime.CompilerServices;

   5: using System.Windows;

   6: using Leap;

   7: using LeapWpf01.Annotations;


   9: namespace LeapWpf01

  10: {

  11:     public partial class MainWindow : INotifyPropertyChanged

  12:     {

  13:         private string _gesturesText;

  14:         private Controller _controller;

  15:         private ElBrunoListener _listener;

  16:         private string _fingersText;


  18:         public MainWindow()

  19:         {

  20:             DataContext = this;

  21:             Loaded += MainWindow_Loaded;

  22:             Closing += MainWindow_Closing;

  23:             InitializeComponent();

  24:         }


  26:         void MainWindow_Closing(object sender, CancelEventArgs e)

  27:         {

  28:             _controller.RemoveListener(_listener);

  29:             _controller.Dispose();

  30:         }


  32:         void MainWindow_Loaded(object sender, RoutedEventArgs e)

  33:         {

  34:             _listener = new ElBrunoListener();

  35:             _controller = new Controller();

  36:             _controller.AddListener(_listener);

  37:             _listener.OnFingersRegistered += OnFingersRegistered;

  38:             _listener.OnGestureMade += OnGestureMade;

  39:         }


  41:         void OnGestureMade(GestureList gestures)

  42:         {

  43:             var gesturesData = string.Empty;

  44:             foreach (var gesture in gestures)

  45:             {

  46:                 gesturesData += gesture.Type + Environment.NewLine;

  47:             }

  48:             GesturesText = gesturesData;

  49:         }


  51:         void OnFingersRegistered(FingerList fingers)

  52:         {

  53:             FingersText = "Active Fingers:" + fingers.Count;

  54:         }

  55:     }

  56: }

Then, the functionality of the app is pretty straigh forward,


The sensor is OK, but in order to have something up and running, you have to work a lot. The SDK gives you raw information , so you have to work with this information to get cool results

Saludos @ Home

El Bruno

image image image Google