IN QUESTO BLOG PARLEREMO DI TUTTE LE DISTRIBUZIONI LINUX E LE LORO CARATTERISTICHE, GRAZIE E BUONA PERMANENZA!!!

Benvenuti Da....

LINUX

LINUX
The World Linux

Corsi ad Orvieto di Linux Base.

Corsi di CSCO di Linux ad Orvieto.

Finalmente Linux sta prendendo il via, persino ad orvieto iniziano i corsi per impararlo.

La Fondazione per il Centro Studi “Città di Orvieto”, in collaborazione con l’Associazione culturale di promozione sociale OrvietoLUG – Linux User Group, organizza una serie di corsi di formazione in informatica su tecnologie libere ed “open source”.

I primi a partire, intorno alla metà di novembre, saranno i corsi “Linux – livello base” e “CoderDojo – Palestra per giovani programmatori”.

Il primo sarà un Corso d’introduzione ed avviamento al sistema operativo GNU / LINUX, il esponente primario del software cosiddetto “libero” (Open Source) che viene distribuito con una licenza che ne permette non solo l’utilizzo da parte di chiunque ed in qualsiasi circostanza, ma anche la modifica, la copia e l’analisi.

Il corso “Linux base” è rivolto a quanti siano interessati a conoscere i concetti fondamentali del sistema operativo nelle diverse distribuzioni, installare Linux sul PC e gestire moduli e periferiche, configurare una rete di base.

Quanti intenderanno proseguire il percorso di formazione su Linux potranno frequentare i successivi Corsi di livello intermedio ed avanzato avendo l’opportunità di acquisire competenze sistemistiche per padroneggiare le diverse distribuzioni Linux e configurare ed amministrare server e reti locali.

Il Corso BASE è articolato in quattro lezioni, della durata di due ore ciascuna, che si terranno nelle giornate di venerdì 18 e 25 novembre, 2 e 16 dicembre 2016, dalle ore 19 alle 21. Termine per le iscrizioni: 14 novembre.

I CoderDojo sono club il cui obiettivo è l’insegnamento della programmazione informatica ai più piccoli. Le attività di formazione dei club ruotano intorno al gioco, lo scambio reciproco ed il peer learning (apprendimento tra pari).

Non ci resta che provarlo e per molte persone sarà una grande soddisfazione per cercare di capire che il mondo di linux non è poi cosi complicato naturalmente nelle distribuzioni quelle più facili da usare.

Per sapere di più su Linux=https://www.facebook.com/groups/416785168484322/









Player musicale per Android.

Come usare  Player musicale per Android.

Su Android non ci sono molti programmi che riproducano in loop delle scalette musicali, cosa che potrebbe risultare utile durante feste o sessioni di allenamento, ad esempio. Ma possiamo realizzarne una noi con C++ e le librerie Qt: il programma che realizzeremo funziona sia su un sistema GNU/Linux desktop che su Android. Affinché il nostro programma funzioni, dobbiamo avere installato i pacchetti di QtMultimedia: sudo apt-get install libqt5multimedia5-plugins qtmultimedia5-dev libqt5multimediawidgets5 libqt5multimedia5 su un sistema Debian-like. Il file di intestazione della nostra finestra, chiamato mainwindow.h, contiene le definizioni di tutti gli oggetti più importanti. Il codice vero e proprio del programma è contenuto nel file mainwindow.cpp:

#include "mainwindow.h"
#include "ui_mainwindow.h"


Le prime righe includono il file di intestazione e il codice dell'interfaccia grafica: il file ui_mainwindow.h viene infatti prodotto automaticamente da QtCreator sulla base dell'interfaccia che abbiamo disegnato nell'apposito designer (l'interfaccia è memorizzata nel file mainwindow.ui).

void MainWindow::on_openFolder_clicked()
{
QString dir = QFileDialog::getExistingDirectory(this, tr("Open Directory"), "/home", QFileDialog::ShowDirsOnly);
ui->lineEdit->setText(dir);
}


Quando il pulsante Open viene premuto, viene eseguita la funzione on_openFolder_clicked(). Questa funzione deve permettere all'utente di selezionare una cartella: possiamo farlo grazie alla libreria QFileDialog::getExistingDirectory, specificando tra i suoi argomenti che debbano essere visualizzate solo le cartelle. Il percorso della cartella scelta può poi essere impostato come testo all'interno della casella (chiamata lineEdit) presente nell'interfaccia grafica.

QStringList dirList(dir.entryList());
for(int i = 0; i < dirList.count(); i++)
{


Costruiamo una lista dei file della cartella che chiamiamo dirList. Si tratta di una QStringList, ovvero un array di stringhe QString. Possiamo scorrere questo array con un semplice ciclo for che parte dall'elemento 0 e arriva all'ultimo elemento dell'array stesso.

QListWidgetItem *dirItem=new QListWidgetItem();
dirItem->setText(dirList.at(i));
ui->listWidget->insertItem(i, dirItem);


Siamo all'intero del ciclo for che scorre tutti gli elementi della array di stringhe: la stringa attuale si trova chiamando la funzione at della dirList. Dobbiamo trasformarla in un elemento (QListWidgetItem) della lista dei file, ovvero l'oggetto QListWidget.

QString filename = ui->lineEdit->text() + "/" + dirList.at(i);
playlist->addMedia(QUrl::fromLocalFile(filename));
}


Il percorso del file viene ottenuto unendo il percorso della cartella e il nome del file attuale, e può essere aggiunto alla playlist con la funzione addMedia. Il ciclo for si può quindi concludere.

playlist->setPlaybackMode(QMediaPlaylist::Loop);
connect(playlist, SIGNAL(currentIndexChanged(int)), this, SLOT(currentIndexChanged(int)));
player->setPlaylist(playlist);
}
}


Ora la playlist contiene tutti i file musicali della cartella indicata dall'utente. Possiamo quindi importarla come playlist del nostro player. Prima però dobbiamo indicare che vogliamo che questa playlist vada in loop continuo, ovvero che venga ripetuta più volte ricominciando dall'inizio quando termina la riproduzione dell'ultimo file. E colleghiamo anche un segnale della playlist a una funzione: è il segnale lanciato ogni volta che comincia la riproduzione di un nuovo file musicale.

void MainWindow::on_play_clicked()
{
if (ui->listWidget->count()>0) {


Per avviare la riproduzione, l'utente può cliccare il pulsante play. Quando ciò avviene, un'apposita funzione viene lanciata automaticamente: questa deve prima di tutto verificare che ci sia almeno un file all'interno della lista dei file, altrimenti è ovvio che non si possa riprodurre nulla.

int inizio = 0;
if (ui->listWidget->currentRow()>0) inizio = ui→listWidget→currentRow();


È importante capire da quale elemento dobbiamo cominciare la riproduzione della playlist: in teoria si comincia sempre dall'elemento 0, ma se l'utente ha selezionato un elemento (currentRow) del listWidget utilizziamo questo file per cominciare la riproduzione.

player->setVolume(ui->volume->value());
player->playlist()->setCurrentIndex(inizio);
player->play();
}
}


Ora possiamo concludere la funzione avviando davvero la riproduzione: impostiamo il volume, impostiamo il file di partenza e lanciamo la riproduzione della playlist con la funzione play del player.
Per sapere di più su Linux=https://www.facebook.com/groups/416785168484322/










Programmare con C++.

Come Programmare con C++.

Far comunicare due computer è abbastanza facile: esistono molti programmi progettati appositamente per questo scopo. Potremmo però avere bisogno di qualcosa che sia costruito specificatamente attorno alle nostre esigenze. Per fare un esempio, potrebbe essere utile un server che rimanga in attesa sul nostro Raspberry Pi e che, quando ci connettiamo ad esso, ci invii un'immagine scattata in tempo reale dalla webcam: un semplice sistema di sorveglianza remota. Per realizzare il nostro server TCP utilizzeremo soltanto librerie standard C++, ma per semplificare la compilazione possiamo ricorrere a QtCreator, l'ambiente di sviluppo ufficiale delle librerie Qt. Il file del progetto, serverTCP.pro, è il seguente:

(QT += core
QT -= gui
TARGET = serverTCP
CONFIG += console
CONFIG -= app_bundle
TEMPLATE = app
HEADERS = base64.h
SOURCES += serverTCP.cpp \
base64.cpp)


Specifichiamo che non ci servono le librerie grafiche, che stiamo realizzando un programma per console, e che il codice sorgente è contenuto nel file serverTCP.cpp. Aggiungiamo anche due file con le funzioni base64, una libreria che sfrutteremo per codificare i file. Ora possiamo cominciare a scrivere il nostro codice sorgente:

#include <cstdlib>
#include <iostream>
...
#include <fstream>
#include "base64.h"
using namespace std;


Le prime righe del codice, come negli esempi che abbiamo scritto in Python, servono a includere le librerie. Le librerie necessarie sono tante, perché il programma è ovviamente più complesso di quelli che abbiamo visto finora.

int BUFFERSIZE = 4096;

Definiamo in una variabile, come numero intero, la dimensione massima del buffer per i messaggi che possiamo ricevere.

void dostuff (int sock, sockaddr_in cli_addr, pid_t pid);
std::string decToDotIP(long num);
void handleSIGCHLD(int n);
void error(const char *msg)
{
perror(msg);
exit(1);
}


Definiamo tre funzioni che scriveremo tra poco, mentre ne definiamo una semplice immediatamente: serve solo a far apparire un messaggio di errore sullo schermo se qualcosa va storto.

int main(int argc, char *argv[])
{


La funzione principale di un programma C++ è main.

signal(SIGCHLD, handleSIGCHLD);

Il nostro server costruirà dei "figli": praticamente, il programma si clona ogni volta che un nuovo client lo contatta. E ogni clone deve essere terminato quando il client interrompe la comunicazione: in quel momento il clone invia il segnale SIGCHLD, e dobbiamo assegnargli una funzione per gestirlo correttamente.

int sockfd, newsockfd, portno;
socklen_t clilen;
struct sockaddr_in serv_addr, cli_addr;
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) error("ERROR opening socket");
std::cout << "This is my server.\n";


Una connessione TCP avviene tramite un socket, che deve essere aperto tramite la funzione socket(). Il socket che realizziamo è basato sulla famiglia di indirizzi IP AF_INET, ovvero gli indirizzi IPv4.

bzero((char *) &serv_addr, sizeof(serv_addr));
if (argc < 2) {
portno = 1612;
}
if (argc > 1) portno = atoi(argv[1]);
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(portno);


Il socket deve poi essere configurato: il dato più importante è la porta di comunicazione TCP che vogliamo assegnare al nostro server: ne dobbiamo scegliere una non utilizzata da altri programmi, ad esempio la 1612. Possiamo lasciare che la porta venga specificata all'avvio del programma server come argomento del programma (e in tal caso sarà l'elemento 1 dell'array argv, come abbiamo visto in Python). E possiamo impostarne una predefinita nel caso non sia stata indicata come argomento. Visto che stiamo realizzando un server, questo programma deve rimanere in ascolto sul socket che abbiamo aperto: possiamo farlo con la funzione listen.

while (1) {

Cominciamo un ciclo infinito (il ciclo while continua finché la condizione espressa tra parentesi è uguale ad 1, ed 1 è sempre uguale ad 1), nel quale il server attenderà l'arrivo delle connessioni.

newsockfd = accept(sockfd, (struct sockaddr *) &cli_addr, &clilen);
if (newsockfd < 0) error("ERROR on accept");


Appena arriva una richiesta di connessione da parte di un client, la accettiamo.

pid_t pid = fork();
if (pid < 0) error("ERROR on fork");


Creiamo un fork, ovvero un clone del programma server da dedicare esclusivamente alla connessione appena accettata.

if (pid != 0) {
std::cout << "Opened new child process with pid " << pid << "." << std::endl;
dostuff(newsockfd, cli_addr, pid);
close(newsockfd);
}
}


Se la creazione del figlio clonato è andata a buon termine, dobbiamo ovviamente dire al clone che cosa deve fare per gestire correttamente la connessione che gli abbiamo assegnato: lo facciamo lanciando la funzione dostuff, che vedremo tra poco.

close(sockfd);
return 0;
}


Quando il ciclo while viene interrotto, perché è successo un imprevisto, possiamo chiudere il socket e terminare il server.

void handleSIGCHLD(int n)
{
int stat;
while(waitpid(-1, &stat, WNOHANG) > 0);
}


La funzione handleSIGCHLD, che abbiamo già menzionato, si occupa proprio di gestire questo segnale emesso dai figli: la funzione rimane in attesa finché il clone non è definitivamente terminato. Se non lo facessimo, il clone potrebbe diventare un processo "zombie", che continua a utilizzare risorse del processore senza però essere più controllato dal processo padre.

void dostuff (int sock, sockaddr_in cli_addr, pid_t pid)
{
int n;
char buffer[BUFFERSIZE];
long empty = 0;
int found = 0;


Questa è la funzione che stabilisce il comportamento del server: tutto ciò che abbiamo visto finora sono le routine standard di un server, ma adesso scriveremo il codice che fa funzionare davvero il nostro server.

while (1) {
bzero(buffer,BUFFERSIZE);
n = read(sock,buffer,BUFFERSIZE-1);


Grazie ad un altro ciclo infinito leggiamo continuamente i messaggi inviati sul socket da parte del client. I messaggi vengono letti dalla funzione read, ed inseriti nella variabile buffer che è un array di caratteri inizializzato con una certa dimensione grazie alla funzione bzero.

if (n < 0) error("ERROR reading from socket");
std::string answ(buffer);
if (answ!="") std::cout << "Message from " << decToDotIP(cli_addr.sin_addr.s_addr) << ": " << answ << std::endl;


Per comodità, trasformiamo il buffer in una stringa, che è molto più gestibile di un array di caratteri.

if (answ=="") empty++;

Se la risposta del client è vuota (quindi non c'è risposta), teniamo il conto sulla variabile empty, la quale incrementa il suo valore di una unità: empty++ è un modo conciso per dire empty+1.

if (empty > 2000000) {
kill(pid, SIGTERM);
std:cout << "Killed process " << pid << "." << std::endl;
return;
}


Se il client non sta rispondendo da molto tempo, terminiamo (inviando il segnale SIGTERM) il processo clone per evitare che la connessione con il client possa rimanere aperta: è il concetto di timeout.

if (answ.substr(0,5) == "HELLO")
{
found++;
std::cout << "Sending welcome message." << std::endl;
n = write(sock,"Ìm ready to listen to your commands.",38);
if (n < 0) std::cout << "ERROR writing to socket";
}


In questo momento la stringa answ contiene il completo messaggio inviato dal client al server, quindi possiamo cercare di interpretarla per capire che cosa vuole fare l'utente. Ad esempio, se le prime 5 lettere sono la parola HELLO, probabilmente l'utente vuole solo salutare il server per assicurarsi di essere davvero connesso. Abbiamo appena definito un comando del nostro server, il comando HELLO. Si può rispondere scrivendo sul socket una frase che faccia capire che il server è davvero pronto. La frase che scriviamo è lunga 38 caratteri, quindi possiamo indicare questo numero come terzo parametro della funzione write, che si occupa di scrivere sul socket.

if (answ.substr(0,6) == "WEBCAM")
{
found++;


Ora definiamo un altro comando: WEBCAM. Questo comando deve far eseguire al server uno scatto tramite la propria webcam e poi inviare l'immagine attraverso il socket.

std::string encoded = "WEBCAM";

Prepariamo la stringa da inviare come risposta al client: comincerà con la scritta WEBCAM, così il client saprà che questa risposta contiene l'immagine della webcam.

system("streamer -s 176x144 -f jpeg -o /tmp/image.jpeg");

È ovviamente necessario ottenere l'immagine della webcam: potremmo produrla con le librerie di Video4Linux, ma sarebbe complicato. Molto meglio ricorrere a un programma a parte, che può essere installato su un sistema Debian-like con il comando sudo apt-get install streamer. Streamer produrrà per noi uno scatto dalla webcam, della risoluzione di 176x144 pixel. L'immagine verrà salvata nel file /tmp/image.jpeg.

std::ifstream infile ("/tmp/image.jpeg",std::ifstream::binary);
infile.seekg (0,infile.end);
long size = infile.tellg();
infile.seekg (0);


Possiamo quindi leggere il file immagine con la libreria ifstream. Il file è binario, naturalmente, perché è una immagine e non un semplice file di testo. Sfruttando la funzione seekg ci spostiamo all'ultimo byte dell'immagine, per calcolarne la dimensione e memorizzarla nella variabile size.

n = write(sock,encoded.c_str(),encoded.length());
encoded.clear();
if (n < 0) std::cout << "ERROR writing to socket";
}


Adesso possiamo scrivere la stringa encoded sul socket. La funzione write accetta soltanto array di caratteri, ma per fortuna è facile convertire una stringa in array di caratteri: basta usare la sua funzione c_str. Così, il client che ci aveva scritto "WEBCAM" ora riceve in risposta l'immagine della webcam in formato base64.

Il client, che dobbiamo sviluppare per fare coppia con il nostro server, è molto semplice. Il suo file di progetto, clientTCP.pro, è praticamente identico a quello del server, cambia solo il nome del file sorgente. Il suo codice sorgente, contenuto nel file clientTCP.cpp, comincia con l'inclusione delle stesse librerie che abbiamo utilizzato per il server. Poi procede:

int main(int argc, char *argv[])
{
int sockfd, portno, n;
struct sockaddr_in serv_addr;
struct hostent *server;
int BUFFERSIZE = 4096;//256;
char buffer[BUFFERSIZE];


La funzione principale (main) deve definire il buffer, l'array che utilizzeremo per i messaggi: deve avere la stessa dimensione che abbiamo indicato per il buffer del server.

if (argc < 3) {
portno = 1612;
server = gethostbyname("127.0.0.1");
}
printf("This is the client for my server. Please type HELLO or WEBCAM. \n\n");
if (argc > 2) {
portno = atoi(argv[2]);
server = gethostbyname(argv[1]);
}


Il server aveva bisogno di conoscere la porta TCP su cui lavorare. Il client ha bisogno anche dell'indirizzo IP del server da contattare (nel caso non si specificato tra gli argomenti del programma client, si da per scontato che sia localhost, ovvero 127.0.0.1).

sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (connect(sockfd,(struct sockaddr *) &serv_addr,sizeof(serv_addr)) < 0)
error("ERROR connecting");

Specificati i vari parametri, che abbiamo già visto per il server, possiamo connetterci ad esso tramite la funzione connect. Se tutto va bene, otterremo un socket chiamato sockfd per la comunicazione.

n = write(sockfd,buffer,strlen(buffer));
if (n < 0)
error("ERROR writing to socket");


Possiamo scrivere il comando impartito dall'utente sul socket, e dunque inviarlo al server, grazie alla funzione write.

std::string received;
unsigned long long int bytes= 20*1024*1024;
received.resize(bytes);

Il server risponderà qualcosa: dobbiamo preparare una stringa per memorizzarlo. Ne impostiamo la dimensione massima a 20 MB.

int bytes_received = read(sockfd, &received[0], bytes-1);
if (bytes_received<0) {
std::cout << "Failed to read data from socket.\n";
}


Utilizzando la funzione read possiamo leggere la risposta del server e memorizzarla nella stringa received. Alla funzione read non passiamo l'intera stringa, ma solo il puntatore al suo primo carattere (con il simbolo &). Questo significa che la funzione read comincerà a copiare la risposta del server in tutte le celle della RAM che il sistema operativo ha assegnato alla variabile received, a partire dalla prima.

std::cout << received.c_str() << "\n";

Adesso possiamo far apparire sullo schermo il testo della risposta ricevuta dal server.

if (received.substr(0,6) == "WEBCAM"){

Quando per un qualsiasi motivo il ciclo infinito che permette l'invio dei comandi al server termina, significa che il client non ha più motivo di essere attivo e quindi possiamo chiudere il socket e terminare il programma client con l'istruzione return 0 (che restituisce il valore 0, indicante una corretta chiusura del programma). Server e client sono ora pronti: basta compilarle i due progetti con qmake, avviamo poi entrambe i programmi (prima il server, poi il client) per provarli.










Programmare con Linux Parte 4.

Come Programmare con Linux Python parte 2.

È il momento di realizzare il nostro primo programma a interfaccia grafica per GNU/Linux: un browser Web molto semplice e rapido, senza memorizzazione della cronologia e dunque comodo per la navigazione in incognito. Lo realizzeremo con Python utilizzando le librerie grafiche PyQt4 (installabili su un sistema Debian-like con il comando "sudo apt-get install python-qt4 pyqt4-dev-tools qt4-designer". Si tratta della versione Python delle librerie Qt.

import sys
from PyQt4 import QtCore, QtGui, QtWebKit


Come nell'esempio precedente, le prime righe riguardano l'inclusione di librerie utili per il nostro programma.

Dichiariamo una "classe", che rappresenterà la nostra finestra grafica. Una classe è l'insieme del codice necessario per un particolare oggetto (nel nostro caso la finestra del browser), e ci permetterà di utilizzare la finestra in modo comodo. La finestra viene costruita sulla base di un QMainWindow, un componente delle librerie PyQt che per l'appunto propone un modello di finestra grafica.

def __init__(self):

Ogni classe ha una funzione chiamata __init__. Questa è il "costruttore" della classe, ovvero la funzione che viene automaticamente chiamata ogni volta che qualcuno decide di realizzare un nuovo oggetto con la classe in questione. Nel nostro caso, questa funzione deve disegnare l'interfaccia grafica della finestra, così sarà poi possibile mostrarla.

QtGui.QMainWindow.__init__(self)

Prima di tutto, avviamo la funzione di costruzione di QMainWindow, così il grosso del lavoro verrà svolto dalle librerie Qt.

self.resize(800,600)

Dobbiamo dare una dimensione di partenza alla finestra: poi sarà comunque possibile ridimensionarla, ma cominciamo con una finestra grande 800x600 pixel.

self.centralwidget = QtGui.QWidget(self)
self.mainLayout = QtGui.QHBoxLayout(self.centralwidget)
self.mainLayout.setSpacing(0)
self.mainLayout.setMargin(1)


Ogni finestra deve avere un elemento centrale: lo chiamiamo mainLayout, ed è per l'appunto un "layout orizzontale" (QHBoxLayout). Un layout orizzontale è un oggetto grafico che contiene tutti gli altri oggetti e li dispone automaticamente sulla finestra in modo ordinato su una sola linea orizzontale. Questo primo Layout in realtà ci serve solo come contenitore generale, perché poi realizzeremo altri layout per disporre i vari elementi come vogliamo.

self.frame = QtGui.QFrame(self.centralwidget)
self.gridLayout = QtGui.QVBoxLayout(self.frame)
self.gridLayout.setMargin(0)
self.gridLayout.setSpacing(0)


Ci serve un layout verticale, per poter posizionare la barra degli strumenti. In poche parole, ciò che faremo sarà inserire questo layout verticale in una colonna del layout orizzontale generale. È in questo layout verticale che verranno inserite la barra degli strumenti e il visualizzatore HTML, una sopra l'altro.

self.horizontalLayout = QtGui.QHBoxLayout()
self.tb_url = QtGui.QLineEdit(self.frame)
self.bt_back = QtGui.QPushButton(self.frame)
self.bt_ahead = QtGui.QPushButton(self.frame)


La barra degli strumenti è anch'essa un semplice layout orizzontale: ogni colonna del livello verrà occupata da un pulsante (bt_back o bt_ahead) o dalla casella dell'indirizzo Web (tb_url).

self.bt_back.setIcon(QtGui.QIcon().fromTheme("go-previous"))
self.bt_ahead.setIcon(QtGui.QIcon().fromTheme("go-next"))


Costruiamo i due pulsanti necessari: uno per andare indietro nella cronologia temporanea, l'altro per andare avanti. Potremmo inserire un testo in ciascun pulsante, ma è meglio ricorrere a un'immagine, un'icona. E possiamo prelevarla direttamente dal set di immagini standard fornito dalle librerie Qt: basta indicare i loro nomi, go-previous e go-next.

self.connect(self.tb_url, QtCore.SIGNAL("returnPressed()"), self.browse)
self.connect(self.bt_back, QtCore.SIGNAL("clicked()"), self.html.back)
self.connect(self.bt_ahead, QtCore.SIGNAL("clicked()"), self.html.forward)
self.connect(self.html, QtCore.SIGNAL("urlChanged(const QUrl)"), self.url_changed)


Abbiamo inserito i vari elementi nella finestra. Però devono anche fare qualcosa: dovremo associare a ciascun elemento una specifica funzione. Questo si può fare collegando con la funzione connect il segnale emesso da uno degli elementi della finestra e le funzioni che costruiremo per le varie operazioni. Ad esempio, quando viene premuto il tasto Invio o Return sulla casella di testo dell'URL deve essere lanciata la funzione self.browse, che scriveremo. Quando vengono premuti i due pulsanti vengono lanciate direttamente le funzioni del QWebKit che si occupano di andare avanti o indietro nella cronologia temporanea. Infine, quando la pagina visualizzata dal QwebKit cambia, viene lanciata la funzione self.url_changed. Questo avviene tipicamente quando l'utente ha cliccato su un link.

self.default_url = "http://www.linux-magazine.it/"
self.tb_url.setText(self.default_url)
self.browse()


Per concludere la funzione iniziale della classe che stiamo scrivendo, impostiamo un URL di default, praticamente la nostra home page. Questo URL è impostato nella casella di testo apposita, e poi si può lanciare la funzione browser per ordinare la visualizzazione della pagina Web indicata nella casella di testo.

def browse(self):
url = self.tb_url.text() if self.tb_url.text() else self.default_url
self.html.load(QtCore.QUrl(url))
self.html.show()

if __name__ == "__main__":


La classe browser è ora terminata, quindi possiamo procedere a scrivere il codice principale del programma (__main__).

app = QtGui.Qapplication(sys.argv)

Prima di tutto vogliamo creare una applicazione Qt, cioè un'app grafica tramite le librerie Qt, che gestiranno per noi la visualizzazione sullo schermo e i rapporti con il server grafico.

main = Browser()
main.show()


Poi, possiamo creare un oggetto che rappresenti la classe Browser definita poco fa: basta inventare un nuovo oggetto (che chiamiamo main) e associarlo alla classe. Da questo momento main sarà la finestra grafica della nostra applicazione, e possiamo farla apparire sullo schermo chiamando la sua funzione show. La funzione show non era stata manualmente definita nel codice che abbiamo presentato: questo perché faceva già parte del set di funzioni predefinite di QMainWindow, la libreria da cui la nostra classe Browser ha ereditato funzioni e attributi.

app.exec_()

Infine, ordiniamo il lancio (exec_()) dell'applicazione che abbiamo appena terminato di scrivere. Ci si può chiedere perché si usi la dicitura exec_ invece di exec. Il fatto è che fino alla versione 2 di Python, la parola exec era riservata e non poteva essere usata per le funzioni. È stato quindi necessario aggiungere un underscore per mantenere la compatibilità con Python 2.












Programmare con Linux parte 3.

Come Programmare con Linux con Python.

Passiamo ora ad un programma leggermente più complesso da sviluppare in Python. Lo realizziamo per applicare automaticamente un watermark, ovvero una firma, su una fotografia.

Prima di iniziare, però occorre una piccola precisazione sull'indentazione in Python.

L'indentazione sarebbe l'identificazione di porzioni di codice tramite spazi a inizio riga. Ad esempio, possiamo decidere di aggiungere due spazi all'inizio di ogni riga contenuta in un ciclo if. In questo modo si riconoscono a colpo d'occhio le righe del ciclo if da quelle ad esso esterne, perché le altre non hanno gli spazi iniziali. Su quasi tutti i linguaggi di programmazione l'indentazione è facoltativa, anche se fortemente consigliata per migliorare la leggibilità del codice. In Python, invece, no: è obbligatoria, perché è l'unico modo per distinguere le varie porzioni di codice.

Invitiamo ad analizzare il codice completo dell'esempio per una corretta visualizzazione delle indentazioni, in quanto potrebbero non essere correttamente visualizzate qui sul sito.

Cominciamo dunque con il codice del nostro esempio:

[import sys
import os
import Image]


Le prime righe sono dedicate alle librerie necessarie per il funzionamento del programma. Si tratta di normali librerie Python, presenti di default su tutte le principali distro GNU/Linux.

[def modifica(filename, watermarkname)]:

Ora, definiamo una funzione: gli attributi sono due stringhe di testo, ovvero filename e watermarkname. Si tratta dei nomi dell'immagine su cui applicare il watermark e di quello dell'immagine che costituisce il watermark stesso. Banalmente, incolleremo l'immagine watermark sopra l'altra immagine, posizionandola al centro. Ma per farlo ci servono i nomi delle due immagini.

[photo = Image.open(filename)
watermark = Image.open(watermarkname)]


Ecco quindi che all'interno della funzione apriamo le due immagini ricevute come argomento: d'ora in poi potremo accedere alle immagini utilizzando i loro oggetti di riferimento, ovvero photo per la fotografia e watermark per il watermark.

[Pwidth = photo.size[0]
Pheight = photo.size[1]
Wwidth = watermark.size[0]
Wheight = watermark.size[1]]


Memorizziamo in quattro variabili larghezza (width) e altezza (height) di entrambe le immagini. La dimensione di ogni immagine è fornita dalla sua funzione size, quindi photo.size ci dice le dimensioni dell'immagine photo. Però, la dimensione viene fornita come una "tupla", ovvero una coppia di numeri (per l'appunto larghezza ed altezza).

[x = (Pwidth/2)-(Wwidth/2)]
[y = (Pheight/2)-(Wheight/2)]


Ora, calcoliamo la posizione in cui dovremo apporre il watermark. L'idea è semplice: se vogliamo che il watermark sia posto al centro delle foto, basta calcolare il centro della foto. Le cui coordinate sono banalmente la larghezza e l'altezza divise a metà, ovvero Pwidth/2 e Pheight/2. Però non basta: per tutte le immagini, il conteggio viene fatto dall'angolo in alto a sinistra. Quindi se utilizziamo questo semplice calcolo, il watermark si troverà con il proprio angolo alto a sinistra sul centro della fotografia, e quindi non risulterà allineato. Noi vogliamo, infatti, che il centro del watermark coincida con il centro della foto. Basta sottrarre ai numeri calcolati per il centro della foto, i valori che possiamo calcolare per il centro del watermark (larghezza e altezza del watermark divise a metà).

[photo.paste(watermark, (x, y), watermark)]

Ora possiamo incollare l'immagine watermark sopra l'immagine photo. La posizione è quella indicata dalla tupla (x,y), ovvero la coppia di coordinate che abbiamo calcolato.

[photo.save(filename.split(".")[0]+"_watermark.jpg")]

Dobbiamo poi salvare l'immagine così prodotta, che è contenuta nell'oggetto photo. La funzione save richiede come argomento il nome del file su cui vogliamo salvare l'immagine: possiamo ricavarlo dal nome originale della fotografia. Il nome originale è contenuto nella variabile filename, ma questo nome contiene anche l'estensione del file (per esempio .jpg). Noi vogliamo rimuoverla, quindi dividiamo il filename con la funzione split prelevando tutto ciò che si trova a sinistra (0) del punto. Estratto soltanto il nome, aggiungiamo con l'operatore più la scritta "_watermark.jpg". Quindi, se la fotografia originale si chiamava foto.jpg ora la versione modificata si chiamerà foto_watermark.jpg.

[if len(sys.argv) < 3:
print "Esempio d'uso: python watermark.py foto.jpg watermark.png"
sys.exit()]


La funzione è terminata: cominciamo a scrivere il codice principale. Dobbiamo prima di tutto verificare che al programma siano stati forniti gli argomenti necessari: ci servono il nome della fotografia e quello del watermark. Abbiamo bisogno di avere almeno 3 argomenti: il primo è sempre il nome stesso del programma, il secondo e il terzo possono essere ciò che vogliamo (i nomi delle due immagini). Gli argomenti sono inseriti in un "array", ovvero un elenco di variabili (stringhe di testo nel nostro caso), chiamato sys.argv. Se i suoi elementi sono meno di 3, il programma è stato lanciato in modo errato e quindi facciamo apparire sul terminale un messaggio con il comando print per spiegare come funziona il nostro programma. Naturalmente, poi il programma deve terminare con sys.exit() perché non è in grado di funzionare correttamente.













Programmare con Linux Parte 2.

Come Programmare con Linux con il Linguaggio Bash.

Oggi parleremo come programmare con il linguaggio bash incominceremo dalle cose semplici, da uno script dal terminale bash e lavoreremo dalla riga di comando, quindi apriremo un editor di testo dato da terminale come Nano.

(nano estrai-url.sh)

Il codice dello script è abbastanza semplice.

(pagina=$1)

Prima di tutto costruiamo una variabile in cui memorizzare l'URL della pagina che è stata indicata come argomento dello script (il primo argomento è $1).

(if [ ${pagina:0:4} = "http" ]; then)

Adesso ci serve un semplice ciclo "if" per vedere se la pagina web si trova su internet o se è in locale. Basta controllare le prime 4 lettere "dalla 0 alla 4 non inclusa" e vedere se corrispondono ad http"se le prime lettere iniziano con questa stringa è ovvio che abbiamo a che fare con una pagina presente sul Web".

(curl $pagina | grep -o 'href=['"'"'"][^"'"'"']*['"'"'"]' | sed -e 's/^href=["'"'"']//' -e 's/["'"'"']$//' >> links.txt)

In questo caso, dobbiamo scaricare la pagina web usando il programma "curl."
poi passiamo il codice "html" della pagina direttamente al programma "grep",
per estrarre tutte le righe che contengono la dicitura href seguita dal simbolo = e dalle virgolette. Questa formula, infatti, presuppone la presenza di un link, selezionate le righe che contengono dei link ed utilizziamo ancora la pipe "il simbolo |" per passare queste righe al comando sed. È quest'ultimo ad occuparsi di estrarre tutto il testo contenuto tra href=" e ". Significa che se nella riga su cui si sta lavorando è scritto href=http://www.linux-magazine.it/test.png, ciò che sed estrarrà sarà http://www.linux-magazine.it/test.png. Proprio ciò che volevamo.

Dopo aver salvato lo script con "Ctrl+O" e di aver chiuso il Nano con "Ctrl+X", possiamo rendere lo script eseguibile con "chmod":

(chmod +x estrai-url.sh)

Lo script può poi essere lanciato dove indichi la pagina Web che vogliamo leggere:

(./estrai-url.sh http://www.linux-magazine.it/)

Otterremo il file di testo "links.txt" con tutti gli URL dei file da scaricare, che poi possiamo dare in pasto a programmi come:

[JDownloader[http://jdownloader.org/download/index]].
















Programmare con Linux.

Come programmare con Linux.

Questo argomento parleremo di come programmare su Linux, e vedremo i vari procedimenti per capire come funziona, questa guida sarà la gloria dei programmatori di Linux e anche molto utile per i principianti, quindi fate attenzione.

1) Intanto per programmare bisogna usare un programma sarebbe questo : "QTCreator" che naturalmente va installato e per installarlo basta digitare sul Terminale:(sudo apt-get install qtcreator) questo procedimento viene installato automaticamente compreso le librerie QT, ed e uguale anche su Debian.

2) Per utilizzare tutti i componenti della Libreria QT, quindi avere la libreria completa digitare da Terminale:(sudo apt-get install 'libqt5*').

3) Adesso non ci resta che aprire QTcreator cliccate su "new projet" o se aprire un progetto che abbiamo già un po elaborato.

4)
Quando dobbiamo aprire un progetto, dobbiamo cliccare il menu "Build" e scegliere la voce "Run" e se vogliamo solo compilare il programma clicchiamo sulla voce "Build all".

5) Con QTCreator possiamo anche modificare l'interfaccia grafica e anche il codice Python.

Per farlo, apriamo QtCreator e dal menu File scegliamo Nuovo file. Indichiamo che vogliamo realizzare un nuovo file di tipo Qt, un Qt Designer Form. Basta selezionarlo e cliccare sul pulsante Avanti per cominciare a disegnare.

6) Quando abbiamo completato e salvato l'interfaccia grafica con il formato ".ui", possiamo tradurla con il codice Python usando il comando:"pyuic4 mainwindow.ui -o mainwindow_ui.py" dove in pratica il primo che finisce con ".ui" e il secondo e il risultato del file che devi ottenere.

Questo programma viene utilizzato per i vari linguaggi di programmazione come Bash, Python, C++ ecc... E' molto utile sia per gli esperti sia per i principianti, l'ho pure provato non è affatto male quindi non ci resta che voi utenti ci provate.














Il Bullismo!!!

Diciamo NO al Bullismo, sia nel Web e sia nella Vita di tutti i giorni.















La Parola di Jim Zemlin.

Il Direttore Esecutivo di Linux Foundation parla per il 25 anni di Linux.

Jim Zemlin ha parlato per i 25 anni di Linux, le sue parole sono state constati e precise e dice che: "Ci si può migliorare rendendo gli altri migliori allo stesso tempo, per questo Linux ci rende migliori" in questa frase dove molta gente in conferenza stampa e rimasta a bocca aperta, dove ognuno di noi sa cosa significa e queste sono state le parole del direttore esecutivo di Linux Foundation prima delle varie domande.

Gli ecosistemi sostenibili.

"Non è una frase vuota, né un banale slogan di marketing. Zemlin ci tiene a rimarcarlo anche quando ho l’occasione di parlare con lui poche ore dopo il suo intervento d’apertura della LinuxCon Europe, la conferenza organizzata dalla Linux Foundation che si tiene dal 4 al 6 ottobre a Berlino. (C’è così tanto software da scrivere! Non è possibile che un solo soggetto da solo riesca a farlo. L’Open Source ormai è diventato la norma, più che l’eccezione. E le aziende che non accettano questa realtà saranno sempre più inadatte a competere sul mercato)."

Le vere ragioni del successo.

"La necessità di creare ecosistemi sostenibili, che si inseriscano in questo grande circolo virtuoso, è solo uno dei tre elementi principali che hanno reso possibile l’incredibile successo di Linux e dell’Open Source. C’è da mettere in conto anche la crescita di Internet e dei servizi online, spesso basati su infrastrutture software a sorgente aperta. L’altro elemento è la trasformazione della natura dei modelli di business del settore IT: (Il software e le licenze software non sono più il prodotto da cui si estrae un profitto diretto. Il profitto è nei servizi», spiega Zemlin. «In altre parole le componenti software sono diventate un centro di costo, più che un centro di profitto. E’ facile intuire perché chi offre codice gratuitamente è dalla parte vincente)."

Il software più aggiornato.

"Come ben sapiamo Linux è sempre in aggiornamento, sopratutto il kernel il cuore del sistema operativo, dove dice che sono ad un buon punto. Ogni giorno gli sviluppatori aggiungono mediamente 10800 linee di codice, ne rimuovono 5300, ne modificano 1875. (Il kernel di Linux cambia 78 volte al minuto», dice ancora Zemlin. «Questi numeri ci dicono che ormai viviamo in un mondo in cui sappiamo trovare nuove modalità sempre più efficaci di collaborazione. Le organizzazioni ormai capiscono la necessità di una cooperazione sostenibile che da una parte permette loro di creare prodotti e servizi migliori, ma che allo stesso tempo possa migliorare la società)."

E' stata una bella e lunga chiacchierata che è stata molto interessante e noi siamo fieri di questo Sistema allora cercheremo con il tempo grazie al direttore esecutivo di linux vedere i progressi che faranno, non ci resta che attendere e vedremo i grandiosi risultati.

Per sapere di più su Linux=https://www.facebook.com/groups/416785168484322/













Forum.

Il Forum di Ubuntu Software Libero.

Salve ragazzi sul sito Ubuntu Software Libero ci sono grosse novità, dato che il blog con il tempo sta crescendo ho diversi visitatori anche nuovi, ho avuto in mente di inserire una cosa simpatica, ma anche pratica.

Come ben sappiamo il blog si collega anche al gruppo che ho creato io "Distribuzioni Linux In Italia" in modo da approfondire i vari argomenti all'interno del sito, l'idea che ho avuto in mente è stata quella di creare un Forum dove potremmo parlare di Linux e delle sue distribuzoni, dove approfondiremo anche l'argomento di Unix e le varie presentazioni dove ogni singolo utente, si presenterà come seconda scelta il moderatore che per qualsiasi problema vi aiuterà all'interno del forum.

Dove si trova questo forum? su internet non si trova, allora dovrete andare sul blog Ubuntu Software Libero.
Cliccando "Forum" uscirà dalla stessa finestra ciò che avrete cliccato e lì potete vedere il vero volto del Forum.

Qua potete iscrivervi, parlare di qualsiasi argomento che riguarda Linux e domande più importanti e più dettagliate rispetto al gruppo che le domande sono generali e sopratutto per chi vuole imparare seriamente e molto difficoltoso, allora qua in questo forum avrete la massima serietà e voglia di fare le cose come un vero moderatore, quindi la gente che dà noia possiamo tranquillamente toglierla.

Questo è il quanto saluti da Nicola Barboni.


Per sapere di più su Linux=https://www.facebook.com/groups/416785168484322/