Récupérer une vidéo enregistré sur la PS4 sur une clé USB

J'ai lu quelques articles qui donnaient une méthode pour récupérer une vidéo enregistrée avec la fonction Share de la PS4 (cf ici pour savoir comment ça marche)

Le méthode était de publier la vidéo sur Facebook en mode publique pour ensuite utiliser un outil pour la récupérer sur son ordi.. un peu long et pas forcément très simple

Pourquoi se faire tant de mal alors qu'on peut utiliser une clé USB ?

En effet, une fois votre enregistrement fini, votre clip est enregistré dans la partie Galerie des images,
1. allez-y


2. Branchez une clé USB dans le port qui se trouve à l'avant


3. Cherchez la vidéo que vous souhaitez récupérer. Une fois dessus appuyez sur la touche Option de la manette, puis sélectionnez Copier sur un périphérique de stockage USB


4. Vous pourrez alors choisir les clips à récupérer (vous pouvez en récupérer plusieurs à la fois), puis faites OK.


5. Une fois le téléchargement fini, vous pouvez récupérer votre clé USB. Un dossier PS4 est créé à la racine avec vos clips et images :-)

Enjoy !
Lire →

Personnaliser vos scrollbars

Si comme moi, vous trouvez les barres de défilement par défaut (scrollbar) des navigateurs moches, ce post est pour vous !

Je vous propose ici un plugin javascript qui permet de personnaliser vos scrollbars de façon très simple. jQuery custom content scroller, dont vous trouverez toutes les informations utiles ici.

Voici le résultat (à gauche la barre classique, à droite une scrollbar personnalisée) :



Avant de commencer, nous avons besoin de

1. Importer les librairies


Dans le zip que vous récupérez, 2 fichiers sont utiles : jquery.mCustomScrollbar.concat.min.js et jquery.mCustomScrollbar.css

<script src="./jquery-2.0.0.min.js"></script>
<script src="./jquery.mCustomScrollbar.concat.min.js"></script>
<link href="./jquery.mCustomScrollbar.css" rel="stylesheet" type="text/css" />

2. Parties HTML et JS

<div id="intro">
Lorem ipsum dolor sit amet, consectetur adipiscing elit....
</div>

$(function () {

  $("#intro").mCustomScrollbar({ // on choisit la div "intro"
    verticalScroll:true, // barre verticale
    theme:"dark-thick", // thème pour la barre, personnalisable
    set_height:"500px", // on fixe la hauteur à 500 pixels
    set_width:"400px", // et la largeur à 400 pixels
    scrollButtons:{
      enable: true // on choisit d'afficher les flèches haut et bas
    }
  });

});

Et voilà ! Rien de plus à faire :)

Vous pouvez davantage personnaliser votre barre avec les options proposées, comme le thème de la scrollbar (vous trouverez les thèmes ici, il suffit ensuite de changer la variable theme dans le code JS).

Retrouvez l'exemple sur jsFiddle.
Lire →

Créer une table HTML éditable en javascript avec EditableGrid 2/2

Cette article est la suite de l'article précédent sur la création d'une table HTML éditable. Je vous conseille de le lire si ce n'est pas déjà fait, puisque je ne reviendrai pas sur les notions déjà vues.

Ce que nous allons voir ici servira surtout à la création de tableaux statistiques.

Voici le résultat que nous obtiendrons


Les totaux sont donc calculés automatiquement, on peut donc éditer que les lignes "oui" et "non".

Avant de commencer, nous avons besoin de


1. Partie HTML

Je n'ai pas cherché très compliqué, méthode à l'ancienne, un gros tableau englobant mes autres tableaux :D

Mon tableau principal

<table style="float:left;" id="datatable">
 <thead>
 <tr>
  <th>Col / Ligne</th>
  <th>Hommes</th>
  <th>Femmes</th>
 </tr>
 </thead>
 <tbody>
 <tr id="1">
  <td>Oui</td>
  <td>30</td>
  <td>83</td>
 </tr>
 <tr id="2">
  <td>Non</td>
  <td>43</td>
  <td>60</td>
 </tr>
 </tbody>
</table>

Mes 2 autres tableaux pour les totaux (total par lignes, total par colonnes). On oublie pas le total des totaux.

<table style="width:50px;" id="ligne_total">
 <tr><th>Total</th></tr>
 <tr id="l1"><td>00</td></tr>
 <tr id="l2"><td>00</td></tr>
</table>

<table style="width:100%">
 <tr id="colonne_total">
  <th>Total</th>
  <td id="c1">00</td>
  <td id="c2">00</td>
 </tr>
</table>
<div style="font-size:1.5em;" id="total"></div>
A vous ensuite de les organiser comme vous voulez !

2. Partie Javascript


Commencez par inclure les 2 librairies (editableGrid et jQuery).
editableGrid possède des fonctions assez intéressantes comme le fait de pouvoir obtenir le nombre de lignes et de colonnes d'un tableau, obtenir la valeur d'une case avec un simple get, mais aussi éditer une case tout aussi simplement. On va utiliser ces méthodes pour les calculs de nos totaux.

Pour commencer, on va rendre éditable 2 de nos tableaux pour utiliser les fonctions décrites ci-dessus.

var editableGrid = new EditableGrid("tabPrincipal",
{
 enableSort:false,
 // modelChanged : fonction appelée quand une valeur est modifiée
    // ici, on recalcule les totaux à chaque fois
    modelChanged: function(rowIndex, columnIndex, oldValue, newValue, row) {
  calculTotal();
 }
});
// notre tableau pour le total par ligne
var ligneGrid = new EditableGrid("ligneGrid",{enableSort:false});


Ensuite, nous allons les fonctions pour ajouter une ligne et pour calculer les totaux (par colonne, par ligne et le total général). Pour les fonctions disponibles, rendez-vous sur la doc.

// on doit ajouter une ligne sur 2 de nos tableaux.
// on appelle pour cela la méthode append
function ajouterLigne(){
  editableGrid.append(editableGrid.getRowCount()+1,{},false,false);
  ligneGrid.append("l"+(ligneGrid.getRowCount()+1),{},false,false);
}

// on calcule nos différents totaux
function calculTotal(){
  total=0;
  var x = 0;

  // le total par colonne
  for(i=1;i<editableGrid.getColumnCount();i++){
    x=0;
    for(j=0;j<editableGrid.getRowCount();j++){
   x += editableGrid.getValueAt(j,i);
    }
    $("#c"+i).html(x);
  }

  // le total par ligne
  for(i=0;i<editableGrid.getRowCount();i++){
    x=0;
    for(j=1;j<editableGrid.getColumnCount();j++){
   x += editableGrid.getValueAt(i,j);
    }
    ligneGrid.setValueAt(i,0,x);
    total+=x;
  }
  $("#total").html(total); // le super total :D
}

Une fois que nous avons nos 2 méthodes, il ne reste plus qu'à afficher tout ça :)

$(function () {

//notre tableau éditable
 editableGrid.load({ metadata: [
  { name: "X", datatype: "string", editable: true },
  { name: "Hommes", datatype: "integer", editable: true },
  { name: "Femmes", datatype: "integer", editable: true },
 ]});
 editableGrid.attachToHTMLTable('datatable');
 editableGrid.renderGrid();
 
 // tableau total lignes
 ligneGrid.load({ metadata: [
  { name: "Total", datatype: "integer", editable: false },
 ]});
 ligneGrid.attachToHTMLTable('ligne_total');
 ligneGrid.renderGrid();

//on lance le calcul des totaux une première fois, ensuite on l'appelle à chaque modification
 calculTotal();

// bouton ajouter une ligne
 $("#ajoutLigne").click(function() {
  ajouterLigne();
 });
});

Voilà, nous avons notre beau tableau statistique !

Si vous avez des questions ou remarques, n'hésitez pas :)

Je posterai bientôt un article pour associer un graphique à notre tableau, qui évoluera en fonction des modifications.
Lire →

Créer une table HTML éditable en javascript avec EditableGrid 1/2

Nous allons voir ici comment créer en toute simplicité une table HTML éditable. Je vais organiser le tutoriel en deux articles pour plus de clarté, dans un premier temps nous verrons un cas simple de table éditable. Ensuite, nous verrons l'édition d'un tableau statistique, avec les totaux calculés automatiquement.
Cela permettra de voir les différentes fonctionnalités de la librairie utilisée !

Librairie utilisée

J'ai testé différentes librairies pour créer et éditer des tables, et j'ai décidé de m'orienter vers EditableGrid que je trouve très puissant et simple à utiliser.

Vous pouvez déjà regarder le site et voir les nombreuses possibilités offertes (il y a même une gestion des graphiques si vous voulez).

Voici le premier résultat que nous obtiendrons:


Ici, chaque case est éditable en cliquant simplement dessus. Ça devient déjà intéressant de voir qu'on peut intégrer des listes ou des cases à cocher en plus de la gestion des cases de type string ou integer.

Avant de commencer, nous avons besoin de


1. Partie HTML


On crée ici un tableau classique. La gestion des pays et des inscriptions se fera dans la partie javascript. True ou false pour les cases à cocher, un identifiant pour les pays.

On trouve également le bouton pour ajouter une ligne.

<h1>Tournoi des Super Héros</h1>
  
<a onclick="editableGrid.ajouterLigne();">Ajouter une ligne</a>

<table id="htmlgrid" class="testgrid">
 <tr>
  <th>Pseudo</th>
  <th>Niveau</th>
  <th>Pays</th>
  <th>Inscription</th>
  <th>Confirmée</th>
 </tr>
 <tr id="1">
  <td>Tintin</td>
  <td>9</td>
  <td>be</td>
  <td>10/04/2013</td>
  <td>false</td>
 </tr>
 <tr id="2">
  <td>Batman</td>
  <td>10</td>
  <td>us</td>
  <td>02/04/2013</td>
  <td>false</td>
 </tr>
 <tr id="3">
  <td>Fantômette</td>
  <td>8</td>
  <td>fr</td>
  <td>06/04/2013</td>
  <td>true</td>
 </tr>
</table>


2. Partie Javascript


La configuration va se faire assez vite et très simplement :)

window.onload = function() {

   // on crée notre EditableGrid
   // pour les options, enableSort si on peut trier (cliquer sur les colonnes)
   // shortMonthNames pour les noms francais des mois
 editableGrid = new EditableGrid("DemoGridAttach",
  {
   enableSort:true,
   shortMonthNames: ["Janvier", "Fevrier", "Mars", "Avril", "Mai", "Juin", "Juillet", "Août", "Septembre", "Octobre", "Novembre", "Décembre"],
  }
 ); 

   // on charge les données, on indique le nom de la colonne,
   // son type (string, integer, boolean..)
   // si la colonne est éditable
   // les valeurs pour les listes (ici les pays)
 editableGrid.load({ metadata: [
  { name: "pseudo", datatype: "string", editable: true },
  { name: "niveau", datatype: "integer", editable: true },
  { name: "pays", datatype: "string", editable: true, values: 
   { 'Europe': { "be" : "Belgique", "fr" : "France", "uk" : "Angleterre"},
     'Amerique du Nord': { "ca": "Canada", "us" : "Etats-Unis" },
   }
  },
  { name: "lastvisit", datatype: "date", editable: true },
  { name: "freelance", datatype: "boolean", editable: true }
  
 ]});
   // on attache notre EditableGrid au tableau HTML (avec son id)
 editableGrid.attachToHTMLTable('htmlgrid');
 editableGrid.renderGrid();
 
   // fonction qui permet d'ajouter une ligne
 editableGrid.ajouterLigne = function()
 {
  this.append(this.getRowCount()+1,{},false,false);
 };
}

Voilà, il en faut pas plus pour créer notre beau tableau d'inscription !

Retrouvez l'exemple sur jsFiddle.

Pour aller plus loin, je vous propose de lire l'article sur la création d'un tableau statistique éditable. Le principe est le même qu'ici, sauf que nous avons quelques fonctions supplémentaires pour les calculs des totaux.

N'hésitez pas à commenter l'article afin de l'améliorer !
Lire →

Carte interactive en HTML5

Comment créer une carte interactive en HTML 5 ?

Comme d'habitude, je fonce sur Google voir ce qui se fait déjà, et je tombe sur ce tutoriel.

Je décide de le suivre puisque c'est globalement ce qu'il me faut. Il me reste à l'adapter pour mes besoins personnels. Je vais essayer de vous donner quelques conseils complémentaires qui pourront vous être utiles.

Le principe est de combiner l'utilisation du SVG, un format de données conçu pour décrire des ensembles de graphiques vectoriels (basé sur XML) avec Raphaël, une bibliothèque javascript qui va permettre d'associer des événements javascript à nos données SVG.

Le SVG

Les coordonnées, dimensions et structures des objets vectoriels sont indiquées sous forme numérique dans le document XML. On ne peut pas ouvrir le fichier avec Paint par exemple. Mais avec Notepad, voici à quoi cela ressemble:

<svg width="300" height="300" xmlns="http://www.w3.org/2000/svg">
 <g>
  <title>Exemple cercle</title>
  <path fill="#000000" fill-opacity="0" stroke="#0978ab" stroke-width="2" stroke-dasharray="null" stroke-linejoin="round" stroke-linecap="square" d="m174.3175,50c0,-24.68646 19.99603,-44.6825 44.6825,-44.6825c24.68646,0 44.6825,19.99604 44.6825,44.6825c0,24.68646 -19.99603,44.6825 -44.6825,44.6825c-24.68646,0 -44.6825,-19.99604 -44.6825,-44.6825z" id="svg_32"/>
 </g>
</svg>
Ce code affiche un simple cercle. On aurait pu utiliser la balise circle, mais je garde cet exemple pour la suite.

Avant de commencer, nous avons besoin de

Voici le résultat simple que nous obtiendrons à la fin. L'affichage d'information se verra au passage de la souris sur les cercles.


1. Création de la carte

Ouvrez SVG editor. Il ressemble à Paint, et est donc assez facile à utiliser. Je ne rentre pas dans les détails, amusez-vous avec et vous comprendrez vite.
Une fois votre belle carte créée, il faudra la sauvegarder. J'ai surement une technique assez brute et surement pas la plus efficace, mais je n'ai pas cherché plus loin :D
Cliquez sur le bouton "SVG"



Copiez tout et collez dans un fichier .svg (il ne sera pas utile par la suite, c'est plus une sauvegarde si vous voulez modifier la carte par la suite).

2. Partie HTML

Dans notre exemple, la carte est composée de 2 parties distinctes: une zone (ici l'île de la Réunion), où aucune interaction ne sera possible, et une autre partie où on affichera une zone explicative lorsqu'on passera la souris dessus.

<div id="canvas_carte"></div>
<div class="info" id="z1">
 <h2>Saint Denis</h2>
 <p>Youhou !</p>
</div>

Vous avez compris, la div canvas_carte contient la carte entière, et le div info notre explication de notre zone interactive. Remarquez l'id = z1 pour notre première zone interactive.
On oublie pas d'inclure nos fichiers javascript, la librairie raphaël et notre script où nous allons travailler maintenant.


<script src="raphael-min.js" charset="utf-8" ></script>
<script src="script.js" charset="utf-8" ></script>

3. Partie JS

J'essaie de décrire un maximum les choses en commentaire dans le code.

window.onload = function() {
  // création de notre map, qui appelle notre div canvas_carte
  var paper = new Raphael(document.getElementById('canvas_carte'), 436, 416);

// quelques paramètres pour notre zone interactive, testez pour les changements
var attr = {
    fill: "#f5f5f5",
    stroke: "green"
    "stroke-width": 1,
    "stroke-linejoin": "round",
  };
  var zone = {}; // tableau de nos zones interactives
  
  // ouvrez votre fichier svg, trouvez la balise "path" correspondant au contour 
  // de votre carte. Il faut sélectionner tout l'attribut d (du m au z).
  // Copiez le ensuite comme ci-dessous..
  grandeCarte = paper.path("m58.6567,...,0l0,0z").attr(attr);
  // De meme pour les autres zones, sauf que cette fois,
  //on les ajoute au tableau zone
  zone.z1 = paper.path("m200,334c-68,...,17 29,-39 29,-39z").attr(attr);
  // gestion des zones interactives
  var current = null;
  for (var state in zone) {
    zone[state].color = "green";
      (function (st, state) {
          st[0].style.cursor = "pointer";
          st[0].onmouseover = function () {
       current && (document.getElementById(current).style.display = "");
       st.animate({fill: st.color, stroke: "green"}, 300);
              paper.safari();
              document.getElementById(state).style.display = "block";
              current = state;
          };
          st[0].onmouseout = function () {
              st.animate({fill: "#f5f5f5", stroke: "green"}, 300);
              paper.safari();
          };
          
      })(zone[state], state);
  }
}

Vous trouverez l'exemple sur jsFiddle ici.

Pour aller plus loin...

Il se peut que vous ayez à créer des zones de différentes couleurs etc...

Vous pouvez alors créer plusieurs tableaux, avec des paramètres différents.
Ensuite, refaire une boucle for (var state in zone) en changeant zone par votre nouveau tableau..

Une fois le principe compris, vous irez très vite à faire de belles cartes interactives. Vous pourrez ensuite personnaliser davantage, en changeant le mode d'interaction (clic..), le mode d'apparition des explications (pop-up) etc...

J'espère que cette article vous intéressera et vous sera utile. N'hésitez pas à dire ce qu'il manque afin de faire profiter les autres.. Soyez indulgent, c'est mon premier article :D
Lire →