Può risultare utile, a volte, “oscurare” alcuni menu dell’amministrazione di WordPress, soprattutto se si è sviluppato un sito/blog per un cliente e non si vuole permettere l’accesso a funzionalità particolarmente delicate. Esistono Plugin che svolgono questa già funzione ma, per avere un controllo personale e completo, vediamo come funziona in dettaglio questa caratteristica.
Come sempre sfruttiamo le utilissime Action messe a disposizione da WordPress, in questo caso admin_menu. Tramite la variabile globale $menu possiamo accedere alla lista dei menu dell’amministrazione. Possiamo individuare il menu da “eliminare” in due modi: tramite l’etichetta o tramite il link a cui punta (vedi parti commentati nell’esempio qui sotto). Nell’esempio proposto vengono “oscurate” le voci di menu Design, Impostazioni e Plugins:
1
2
3
4
5
6
7
8
9
10
11
12
13
| function remove_menu_item () {
global $menu;
// tramite label
$removes = array( 'Design', 'Impostazioni', 'Plugins' );
// tramite link
// $removes = array( 'themes.php', 'options-general.php', 'plugins.php' );
foreach( $removes as $todel )
foreach($menu as $key => $sm) if($sm[0] == $todel ) { unset( $menu[$key] ); break; }
// tramite link
// foreach($menu as $key => $sm) if($sm[2] == $todel ) { unset( $menu[$key] ); break; }
}
//
add_action ('admin_menu', 'remove_menu_item'); |
L’uso del link come chiave per la rimozione ($sm[2] nelle parti commentate nel codice qui sorpra), è utile quando non si ha certezza della lingua – localizzazione – con cui è stato installato WordPress. Con questa tecnica, tuttavia, il menu è rimosso solo a livello di interfaccia, quindi sarà possibile ancora accedere alla pagina tramite una link diretto.
Continua...
Partendo dal post WordPress: come creare passo passo un proprio login, eseguita la procedura di login potrebbe essere utile indicare all’interno del nostro blog un link per effettuare la disconnessione, ovvero il logout. Non useremo anche in questo caso le procedure standard di WordPress, ma vedremo come eseguire il logout a basso livello. Prima di tutto dobbiamo capire se un utente è loggato o meno. Questo è possibile interrogando semplicemente la variabile $user_ID di WordPress. Ad esempio:
1
2
3
| if( $user_ID != '' ) { // oppure if( is_user_logged_in() ) {
// un utente risulta "loggato" ...
} |
Una volta che sappiamo che un utente è “loggato” nel sistema, possiamo inserire un semplice link ad una nostra pagina di logout. Creiamo quindi una pagina, ad esempio logout.php, e inserendo il seguende codice:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| /**
* Esegue il logout
*
* @author Giovambattista Fazioli
* @email g.fazioli@undolog.com
* @web http://www.undolog.com
*/
// Invoke WordPress bootstrap
@require_once('wp-config.php');
@require_once('wp-includes/pluggable.php');
// wp logout
wp_logout ();
// carico qualsiasi altra pagina
header( "Location: /" ); |
E sufficiente quindi “linkare” alla nostra pagina per fornire una procedure di logout:
1
2
3
| if( $user_ID != '' ) {
echo 'Esegui il <a href="logout.php">logout</a>';
} |
Continua...
Mozilla FireFox permette di gestire più profili, funzionalità utile a chi, come me, sviluppa siti web e necessita di tutta una serie di estensioni dedicate al debug e all’analisi delle pagine Web. Tramite l’uso dei profili è possibile configurare differenti impostazioni di FireFox:
Firefox salva le informazioni personali come i segnalibri, le password e le preferenze in un gruppo di file chiamato profilo situato in una posizione diversa rispetto ai file di programma di Firefox.
Su Windows Vista (vedi qui per altri sistemi operativi) è possibile accedere alla gestione dei profili dal comando Esegui usando:
Uno dei vantaggi nell’uso dei profili è quello di poter avere un FireFox per navigare, senza quindi tutte le toolbar e le estensioni per il debug e un FireFox per sviluppare, corredato da FireBug e tutti gli altri tool di sviluppo.
Continua...
Esiste una forma abbreviata per assegnare “al volo” una valore ad una variabile se un’altra non è definita (undefined), usando l’operatore di OR logico (||) – doppio pipe:
1
2
3
4
5
| // pluto risulta undefined
var pluto;
var pippo = pluto || '5';
alert( pippo );
// risultato: 5 |
Continua...
Qualcuno sostiene che la programmazione è un arte e, in ultima analisi, non posso che essere d’accordo soprattutto quando si scovano soluzioni estremamente diverse per un medesimo problema. Per capire quanto sia vero questo, ecco come un’identica necessità nel medisimo linguaggio (Javascript) può essere risolta con approcci assolutamente diversi ed originali.
Left Pad zero
Un numero, ma il discorso è valido anche per una qualsiasi stringa, come 123 può essere riempito a sinistra – per pareggiarlo – con un certo numero di zeri, ad esempio: 00123. Questa necessità si presenta in varie occasioni e risulta utile per incolonnare – o comunque mostrare – un numero in maniera pulita, indicandone implicitamente il suo valore massimo. Nei videogame, ad esempio, il classico punteggio (lo score) viene spesso indicato con 001234, indicando che al massimo si arriverà a 999999. Ecco come lo stesso problema è stato risolto da vari sviluppatori:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| /**
* Left Pad String
*
* @from http://snipplr.com/view/8423/left-pad-string/
* @author-web http://www.mechanicmatt.com/
*
* @param num - Striga da riempire
* @param totalChars - Numero totale di caratteri, comprensivo degli "zeri"
* @param padWidth - Carattere usato per riempire, default "0"
*/
function leadingZeros(num, totalChars, padWith) {
num = num + "";
padWith = (padWith) ? padWith : "0";
if (num.length < totalChars) {
while (num.length < totalChars) {
num = padWith + num;
}
} else {}
if (num.length > totalChars) { //if padWith was a multiple character string and num was overpadded
num = num.substring((num.length - totalChars), totalChars);
} else {}
return num;
}
alert(leadingZeros("asdf", 10, "0")); |
Questa soluzione è estremamente articolata, tuttavia permette di aggiungere un numero indefinito di 0 al numero num scegliendo anche il tipo di carattere da usare tramite padWidth, invece del default 0.
Decisamente originale, invece, questa soluzione:
1
2
3
4
5
6
7
8
9
10
11
12
13
| /**
* string_pad
*
* @from http://snipplr.com/view/700/stringpad/
* @author http://d.hatena.ne.jp/brazil/20060721/1153489937
*
* @param str - Striga da riempire
* @param len - Numero totale di caratteri, comprensivo degli "zeri"
* @param ch - Carattere usato per riempire
*/
function pad(str, len, ch){return new Array(len-(''+str).length+1).join(ch) + str}
alert(pad(56, 4, '0')); // 0056 |
Stesso risultato, con un approccio completamente diverso. Anche in questo caso abbiamo la possibilità di decidere il numero di caratteri padding tramite il parametro len e il tipo di carattere da usare tramite ch. Manca però l’uso del default previsto nella precedente funzione.
Quella che uso io, invece…:
1
2
3
4
5
6
7
8
9
10
11
12
| /**
* string_pad
*
* @author Giovambattista Fazioli
* @web http://www.undolog.com
*
* @param s - Striga da riempire
* @param l - Stringa che indica sia il carattere che la lunghezza
* ad esempio "0000" = carattere "0" lunghezza 4
*/
function padding(s,l) { return( l.substr(0, (l.length-s.length) )+s ); }
alert( padding('123','0000') ); |
Se avete altre soluzioni interessanti non esitate a commentare 
Continua...
Nel post 3D CountDown con FIVe3D (vedi anche How I Did It: scrivere un countdown in Flash), veniva proposta una classe per la creazione di un oggetto CountDown in Actionscript, eccone una versione simile in Javascript:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
| /**
* CountDown Class
*
* @author Giovambattista Fazioli
* @email g.fazioli@undolog.com
* @web http://www.undolog.com
*
* @param dd (string) 'month day, year'
*
*/
function countDown( dd ) {
// init target time
var target = new Date( dd );
this.targetTime = target.getTime();
/**
* refresh countdown
*/
this.refresh = function() {
var today = new Date();
var currentTime = today.getTime();
// time left
this._leftMilliseconds = (this.targetTime - currentTime);
this._leftSeconds = Math.floor( this._leftMilliseconds / 1000 );
this._leftMinutes = Math.floor( this._leftSeconds / 60 );
this._leftHours = Math.floor( this._leftMinutes / 60 );
// no module
this.leftDays = Math.floor( this._leftHours / 24 );
// for print
this.leftMilliseconds = this._leftMilliseconds % 1000;
this.leftSeconds = this._leftSeconds % 60;
this.leftMinutes = this._leftMinutes % 60;
this.leftHours = this._leftHours % 24;
}
this.refresh();
} |
Esempio
1
2
3
| var cd = new countDown( '1 1, 2009' );
// mostra quanti giorni, ore, minuti, secondi e millisecondi al primo gennaio 2009
document.write( cd.leftDays + "," + cd.leftHours + "," + cd.leftMinutes + "," + cd.leftSeconds + "," + cd.leftMilliseconds ); |
Continua...
Se non vogliamo che una funzione PHP emetta un qualsiasi errore o warning, basta inserire prima della chiamata alla funzione il carattere chiocciola – o at – (@):
1
2
3
4
| // invece di usare la forma canonica
$res = miaFunc();
// è possibile usare
$res = @miaFunc(); |
Continua...
In PHP è possibile usare una forma abbreviata, o contratta, per visualizzare variabili o ritorni di funzioni:
1
2
3
4
5
6
7
8
| // al posto di
<?php echo $miavar ?>
// è possibile scrivere
<?=$miavar?>
// al posto di
<?php echo miaFunc() ?>
// è possibile scrivere
<?=miaFunc()?> |
Continua...
Questa è la prima release, la 0.8 (allineata con la versione online), di Skype Emotions Editor – Skypemote – in versione Adobe AIR. Per adesso le funzionalità sono le medisime della versione online, con il vantaggio di essere un’applicazione desktop, installabile quindi su Windows, Mac e Linux.
Prima dell’installazione ricordatevi di aggiornare e/o installare per la prima volta le runtime di Adobe AIR, se non l’avete già fatto in precedenza.
Download
Potete scaricare Air Skypemote da Google Code.
Continua...
Continuiamo l’analisi dell’esempio del gioco Tic Tac Toe, presentato in Actionscript 3.0 for beginners: lesson #2. Eravamo arrivati alla funzione che crea la griglia di gioco:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
| /**
* Disegno graficamente la griglia (3x3) a video
*
* @param void
* @return void
* @private
*/
private function createGrid ():void {
// puntatore temporaneo ad uno oggetto MovieClip
// nota: qui si sarebbe potuto usare anche un oggetto Sprite
// ma in questo caso mi serve di poter estendere l'oggetto
// aggiungendo alcune proproetà personali. L'oggetto Sprite
// è una classe chiusa e quindi non estendibile runtime, mentre
// la classe MovieClip è una classe dinamica e quindi rende
// possibile l'aggiunta di proprietà runtime
var tm :MovieClip, i :uint = 0;
// aggiungo in uno schema 3x3 i MovieClip
for(; i < 9; i ++) {
tm = new MovieClip();
addChild( tm );
tm .x = OFFSETX +( (i %3 )*(PLAYER_WIDTH +PLAYER_OFFSET ) )
tm .y = OFFSETY +Math.floor(i /3)*(PLAYER_HEIGHT +PLAYER_OFFSET )
tm ._index = i ;
drawPlayer ( tm , 0 );
}
// disegno le 2 linee veriticali e le 2 orizzontali
with( this.graphics ) {
lineStyle(6,0x666666 );
moveTo(OFFSETX ,OFFSETY +(PLAYER_HEIGHT +15));
lineTo(OFFSETX +( (PLAYER_WIDTH +20)*3 ),OFFSETY +(PLAYER_HEIGHT +15));
moveTo(OFFSETX ,OFFSETY +(PLAYER_HEIGHT +20)*2);
lineTo(OFFSETX +( (PLAYER_WIDTH +20)*3 ),OFFSETY +(PLAYER_HEIGHT +20)*2);
moveTo(OFFSETX +(PLAYER_WIDTH +15),OFFSETY );
lineTo(OFFSETX +(PLAYER_WIDTH +15),OFFSETY +( (PLAYER_HEIGHT +20)*3 ));
moveTo(OFFSETX +(PLAYER_WIDTH +20)*2,OFFSETY );
lineTo(OFFSETX +(PLAYER_WIDTH +20)*2,OFFSETY +( (PLAYER_HEIGHT +20)*3 ));
}
} |
Continua...
Ultimi Commenti
Giovambattista Fazioli: @Nik: Sono contento! In bocca al lupo dunque!!
Nik: Lunedì ho l’esame di informatica su java, grazie mi sei stato utilissimo, il libro che ho era poco chiaro...
Marco: Ti ringrazio moltissimo, mi hai illuminato
ho risolto impostando [cc_objc] //OptionViewController.m -...
Giovambattista Fazioli: @Marco: Ti consiglio un approccio credo più corretto. Se hai eseguito il subclass del tab...
luigi: molto chiaro e semplice devo ammettere che anche scrivendo da un pà difficilmente uso delegati creati da...