wpTOGo

Je n’ai pas encore vendu les mérites d’une application android sur ce blog. Ce sera maintenant chose faites puisque j’ai aujourd’hui découvert une petite app sur l’android market à savoir wpToGo. Cette application permet de gèrer son blog wordpress, hébergé sur wordpress.con ou non, depuis son mobile android. L’application est rapide et bien réalisée dans l’ensemble.
L’application demande la mise en place de l’option xmlrpc qui permet à des programmes externes d’accéder à wordpress en administration (activable dans les options écriture).
Pour les utilisateurs de blogs sur wordpress.com, notez que cette option est active par default et le lien est donc : nomDuBlog.wordpress.com/xmlrpc.php

FrAndoird propose des invitations à ses lecteurs pour la soirée SFR Android :
http://www.frandroid.com/2647/10-nouvelles-invitations-pour-la-soiree-sfr-android/

Une petite soirée à ne pas manquer !

HaXe est une plateforme de développement web RIA. Il permet au final de générer du javascript, du flash, du php ou du code neko (même si je n’ai pas testé ces 2 derniers).

Il reprend les packages flash, javascript, propose une programmation orientée objet. Néanmoins, je trouve qu’il manque cruellement de documentation. Il n’y a que très peu de tutoriaux sur internet et une connaissance préalable de javascript ou action script est nécessaire pour réaliser quelque chose (ce que je n’ai pas).

Néanmoins, cette solution permet de coder tant au niveau serveur que client et permet de nous affranchir de licence Adobe onéreuse.

Pour installer HaXe, il faut téléchager le compilateur sur le site officiel.

A l’écriture de ce billet, l’IDE FlashDevelop supporte complètement HaXe (mis à part la conversion des librairies xml vers swf qui ne fonctionne pas, alors que FlashDevelop intègre swfMill, qui permet simplement de réaliser cela…).

En ce qui concerne la documentation, il n’y a malheureusement qu’une bien faible documentation en ligne, et l’absence d’un forum ou d’un bon wiki fait réellement défaut lors de l’apprentissage.

On notera tout de même la présence d’une mailing list, où les développeurs même de HaXe interviennent et surtout la doc de l’api.

Cet article évoluera pour devenir à terme un petit tutorial, une aide, une base…

Mise à jour 17/12/08 : HaXe ayant une très mauvaise documentation (il manque surtout un forum à mon avis.), j’arrête d’étudier HaXe. Cet article restera dans l’état pour l’instant. Je vais par contre me tourner vers Flex d’Adobe, qui m’apparait une meilleure solution pour développer des RIA.

Logo IrrLicht

Il faut dans un premier temps,

• soit récupérer le package Irrlicht déjà compilé pour windows (méthode la plus simple) our ceux qui veulent les dernières sources, un site  (http://irrlicht.convextech.ca/) met à disposition un système qui compile les dernières sources et les propose en téléchargement. On choisera alors “Core, Examples and Tools”, la compression zip, et on prendra un téléchargement pour Windows x86.Sinon, il y a  le package officiel :  vous pouvez aller à l’adresse : http://irrlicht.sourceforge.net/downloads.html Il ne reste plus qu’à télécharger l’un des deux et de décompresser l’archive quelque part sur votre disque dur. 
   
• soit télécharger les dernières sources de SVN https://irrlicht.svn.sourceforge.net/svnroot/irrlicht/branches/releases/1.5/ irrlicht-1.5 , et les compiler soit même.

Ensuite il faudra indiquer à Visual Studio ou encore Code::Blocks, l’emplacement des includes et des librairies de Irrlicht (voir mises à jour de l’article).

Dans le cadre d’un de mes projets, un utilisateur devait pouvoir cliquer sur une face et une arrête d’un objet, non aligné avec les axes (x,y,z), donc avec pour moi l’impossibilité d’utiliser les Bounding Box proposée par Irrlicht.

Il fallait alors lancer le rayon depuis la souris à chaque frame, et déterminer quelle face traversée par ce rayon est la plus proche de la caméra.

Avec l’aide de rogerborg du forum d’Irrlicht, qui me donna la solution pour les arrêtes, j’ai enfin réussi à trouver le code nécessaire pour la scène node face qui permet cela.

Le voici :

/!*
*\author : Mathieu PICCIN
*\date : SEPTEMBER 2008
*\brief : a face scene node with selection from mouse
**/

#include
#include

using namespace irr;

#pragma comment(lib, "Irrlicht.lib")

class SelectableFacesNode : public scene::ISceneNode
{
core::aabbox3df Box;
std::vector Faces;
std::vector corners;
//core::array Edges;
core::array EdgeUnitVectors;
video::SMaterial Material;
int SelectedFace;

public:

SelectableFacesNode(scene::ISceneNode* parent, scene::ISceneManager* mgr, s32 id)
: scene::ISceneNode(parent, mgr, id)
{
SelectedFace = -1;
Material.Wireframe = false;
Material.Lighting = false;
// Material.TextureLayer[0].Texture[0].

corners.push_back(core::vector3df(0, 14, 0));
corners.push_back(core::vector3df(-10, 0, -10));
corners.push_back(core::vector3df(10, 0, -10));
corners.push_back(core::vector3df(0, 0, 14));

for(int corner1 = 0; corner1 < 4; ++corner1){
for(int corner2 = corner1 + 1; corner2 < 4; ++corner2)
{
for(int corner3 = corner2+1; corner3 <4; ++corner3)
{
const core::triangle3df face(corners[corner1], corners[corner2], corners[corner3]);
Faces.push_back(face);
}

}
}

/*Vertices[0] = video::S3DVertex(0,0,10, 1,1,0,video::SColor(255,0,255,255),0,1);
Vertices[1] = video::S3DVertex(10,0,-10, 1,0,0,video::SColor(255,255,0,255),1,1);
Vertices[2] = video::S3DVertex(0,20,0, 0,1,1,video::SColor(255,255,255,0),1,0);
Vertices[3] = video::S3DVertex(-10,0,-10, 0,0,1,video::SColor(255,0,255,0),0,0);*/

Box.reset(corners[0]);
for (s32 i=1; iregisterNodeForRendering(this);

ISceneNode::OnRegisterSceneNode();
}

virtual void render()
{
u16 indices[] = { 0,2,3, 2,1,3, 1,0,3, 2,0,1 };

video::IVideoDriver* driver = SceneManager->getVideoDriver();

driver->setMaterial(Material);
driver->setTransform(video::ETS_WORLD, AbsoluteTransformation);

for(u32 face = 0; face draw3DTriangle(Faces[face], video::SColor(255, 0, 255, 0));
else
driver->draw3DTriangle(Faces[face], video::SColor(255, 0, 0, 255));

}

}

virtual const core::aabbox3d& getBoundingBox() const
{
return Box;
}

virtual u32 getMaterialCount() const
{
return 1;
}

virtual video::SMaterial& getMaterial(u32 i)
{
return Material;
}

void testLineIntersectionWithEdges(const core::line3df & line)
{
core::line3df localLine(line);
core::matrix4 inverseTransform;
if(!AbsoluteTransformation.getInverse(inverseTransform))
return;

inverseTransform.transformVect(localLine.start);
inverseTransform.transformVect(localLine.end);

const core::vector3df lineUnit = localLine.getVector().normalize();

const f32 VirtualEdgeThicknessSq = 6.f * 3.f; // Thicken up the edge
f32 closestToLineSq = VirtualEdgeThicknessSq;

SelectedFace = -1;
for(u32 face = 0; face < 4; ++face)
{
/*core::vector3df normal = lineUnit.crossProduct(EdgeUnitVectors[edge]);
normal = EdgeUnitVectors[edge].crossProduct(normal);*/

core::plane3df plane = Faces.at(face).getPlane();

core::vector3df intersection;
if(Faces.at(face).getIntersectionWithLine(localLine.start, lineUnit, intersection))
{
const core::vector3df nearestPoint = Faces[face].closestPointOnTriangle(intersection);
const f32 distanceToLineSq = intersection.getDistanceFromSQ(nearestPoint);

if(distanceToLineSq <= closestToLineSq)
{
closestToLineSq = distanceToLineSq;
SelectedFace = face;
}
}
}
}
};

int main()
{
IrrlichtDevice *device =
createDevice(video::EDT_OPENGL, core::dimension2d(640, 480), 16, false);

if (device == 0)
return 1; // could not create selected driver.

video::IVideoDriver* driver = device->getVideoDriver();
scene::ISceneManager* smgr = device->getSceneManager();

smgr->addCameraSceneNode(0, core::vector3df(0,0,-40), core::vector3df(0,0,0));

SelectableFacesNode *myNode =
new SelectableFacesNode(smgr->getRootSceneNode(), smgr, 666);

scene::ISceneNodeAnimator* anim =
smgr->createRotationAnimator(core::vector3df(0.3f, 0, 0.3f));

myNode->addAnimator(anim);
anim->drop();

while(device->run())
{
core::line3df cursorRay = smgr->getSceneCollisionManager()->getRayFromScreenCoordinates(device->getCursorControl()->getPosition());

myNode->testLineIntersectionWithEdges(cursorRay);

driver->beginScene(true, true, video::SColor(0,100,100,100));
smgr->drawAll();
driver->endScene();
}

myNode->drop();
device->drop();
return 0;
}

Vous pouvez également trouver ce code avec celui pour les aretes sur le forum Irrlicht.

Irrlicht est un moteur 3D OpenGL / DirectX, en C++ très simple d’utilisation.

De plus il possède une forte communauté réuni autour du forum officiel, où vous trouverez facilement de l’aide à la plupart de vos problèmes, ainsi que des Scene Node (une sorte portion de monde 3D pour les nouveaux).

On retiendra également le blog de l’auteur d’Irrlicht

Drupal nécessite d’executer assez souvent une tâche cron. Cela permet de mettre à jour le module de recherche, de vérifier les mises à jour de sécurité, etc.

Malheureusement, la plupart des petits serveurs mutualisés ne proposent pas la programmation de tâches CRON.

On peut maintenant contourner ce problème avec un petit module Drupal : Poormanscron accessible à l’adresse :

http://drupal.org/project/poormanscron

Certain hébergeur limite la mémoire allouée à php (memory_limit), et cela pose donc problème avec des cms. Bien que Drupal soit un CMS relativement léger, une installation de Drupal 5, avec CCk, Contemplate, et un éditeur de textes comme TinyMCE ou FCKeditor (que je recommande par rapport à TinyMCE), demande au minimum 13 – 14 Mo de mémoire php.

Sous Apache, vous pouvez changer ce memory_limit directement dans php.ini :

memory_limit = 16M

Ou dans un htaccess à la racine du site :

php_value memory_limit 16M

Malheureusement il arrive que cette modification ne soit pas possible (comme par exemple chez celeonet). Il convient alors de désactiver tous les modules inutiles, et d’activer le module throttle de drupal.

Activation du module throttle dans drupal

Ce module, throttle, permet de cocher une seconde croix pour chaque module (régulation en francais). Cela permet, une fois un nombre de visiteurs dépassé de réguler certain module. J’ai ainsi pu contourner la limite imposé par mon hébergeur (même si ce n’est pas une solution miracle).

Installation de IPSEC sous GNU/Linux

Compatible Ethernet & Wifi

Récupération des fichiers nécessaires

Télécharger ce zip

Procédure d’installation

Installation des paquets nécessaires

• sous Debian :
  • ipsec-tools
  • freeswan
• sous Ubuntu :
  • ipsec-tools
  • openswan

Copie des fichiers fournis dans l’archive

(en mode super-utilisateur, pour ubuntu, précéder les commande de sudo)

Créer les dossiers si ils ne sont pas présents

cp generate_ipsec /etc/init.d/
cp ifraz /sbin/
cp interfaces.conf /etc/
mkdir /etc/ifplugd
mkdir /etc/ifplugd/action.d/
cp ipsec_start /etc/ifplugd/action.d/

Attribuer les droits d’acces aux fichiers :

sudo chmod 777 /etc/init.d/generate_ipsec
sudo chmod 777 /sbin/ifraz
sudo chmod 777 /etc/interfaces.conf
sudo chmod 777 /etc/ifplugd/action.d/ipsec_start

Attribuer les droits d’exécutions aux trois scripts

chmod +x /etc/init.d/generate_ipsec
chmod +x /sbin/ifraz
chmod +x /etc/ifplugd/action.d/ipsec_start

Configuration des interfaces réseau

vim /etc/network/interfaces

définir eth1 pour wifi et eth0 pour ethernet par exemple

Suppression du fichier ipsec.secrets

rm /etc/ipsec.secrets

Effacement des traces des précédentes connexions

/sbin/ifraz

Lancement du script

(en mode utilisateur)

/etc/ifplugd/action.d/ipsec_start ethx up

J’ai installé un gestionnaire de publicités en ligne pour un parc de sites internet. Après recherches, je n’ai trouvé que 2 moteurs de publicités exploitables

• PHPMyPup
• OpenAds

PhpMyPub n’est plus développé depuis assez longtemps, donc on s’attardera sur OpenAds uniquement.
Il est proposé en version 2.0 qui ne demande que MySQL 3 ou 2.X qui demande MySQL 4 ou supérieur.
Ce gestionnaire est à décompresser dans un dossier de son site, par exemple /openads, et on y accèdera pour la première fois, et donc pour l’installation automatisé via : www.url_de_mon_site.com/openads/

Après avoir ajouté un annonceur, une campagne, une pub et une zone, il génère un code à placer dans cette zone, qu’on peut charger au moyen d’un include par exemple.

A noter que j’ai remarqué que le site de vente de matériel informatique LDLC utilise openads pour ses publicités…