[Supporto] Tutorial PyGTK e Glade (1 parte)

Linguaggi di programmazione: php, perl, python, C, bash, ecc.

[Supporto] Tutorial PyGTK e Glade (1 parte)

Messaggioda Alkatron » martedì 30 marzo 2010, 19:26

Ho trovato questo tutorial e il successivo su internet e li ho trovati veramente illuminanti, tanto che ho deciso di tradurli.
Ho usato google per una prima passata e poi l'ho ripassato piu' volte correggendo la sintassi, il senso ecc. per renderlo abbastanza fedele all'originale.
Questo è il primo, si rivolge a degli utenti che abbiano gia un po di conoscenza della programmazione in generale, e almeno una infarinatura di python.
E qui trovate il successivo

Nel seguirlo ho usato una macchina cosi configurata:
Jaunty 2.6.28-18-generic
Glade 3.6.3
Python 2.6.2
gtk+ 1.2.10
PyGTK 2.16.1

Funziona perfettamente anche facendolo in windows, basta installare i pacchetti necessari.

Le immagini si riferiscono ad una versione precedente di glade ma cambia solo la disposizione grafica, si ritrovano facilmente nella versione nuova....qualora ci fosserro troppi problemi posso mettere le immagini di quella nuova....ma queste erano gia pronte :-)

il file glade usato a me non funzionava, l'ho rifatto da capo facendo il tutorial e sta in allegato.

Dopo averlo letto e riletto tante volte per me ormai e tutto scontato quindi non mi rendo conto se alcuni passi sono poco chiari....siano benvenuti consigli, precisazioni, correzioni.

Fatemi anche sapere se lo trovate interessante, altrimenti è inutile che traduco anche la 2 parte.



Tutorial PyGTK e Glade 1 parte


La prima cosa da fare è avviare un nuovo progetto Glade nella directory di progetti chiamata PyWine. Creare una nuova finestra, che chiameremo `mainWindow` e impostare il titolo a `PyWine`.
Quindi aggiungiamo un handler per l`evento destroy.

Immagine

Successivamente aggiungere un box verticale alla finestra con 4 righe, (dall`alto verso il basso)
  • Una riga per la barra dei menu
  • Una riga per la barra degli strumenti
  • Una riga per la Tree/List View
  • L`ultima per la barra di stato
Nome della Tree/List View `wineView`

Immagine

La Tree/List View che abbiamo aggiunto alla finestra verrà utilizzata per visualizzare le informazioni dei vini per l`utente. Quindi la prima cosa da fare è permettere all`utente di aggiungere un vino con una finestra di dialogo. Per farlo useremo un comando di menu e un pulsante della Toolbar.

La prima cosa da aggiungere è un pulsante alla toolbar, basta selezionare l`area della toolbar appena aggiunta e cliccare sul pulsante edit e si apre il tool bar editor.
Ora andiamo sul tag Hierarchy aggiungiamo il pulsante e modifichiamo le sue proprieta'. Diamogli nome `tbAddWine`, e label `Add wine`, scegliendo l`icona da aggiungere tra quelle `stock`.

[img width=345 height=600]http://www.learningpython.com/images/pywine_01/pywine_02.png[/img]

Aggiungeremo poi un handler per l`evento click del pulsante tbAddWine, ma questa volta, invece di chiamarlo il default `on_tbAddWine_clicked` lo chiameremo `on_AddWine`.

Barra dei menu

Ora lavoreremo sul menu, dal momento che vogliamo che l`utente sia in grado di aggiungere vini dal pulsante della toolbar o dalla barra del menu.
Fare clic sulla barra dei menu nella finestra  poi Edit e poi il tag Hierarchy.
Ora, fare clic sul pulsante Add per aggiungere una nuova voce di menu di livello superiore, e dargli label `_Add`.
Cliccando con il destro sulla voce appena aggiunta selezionare 'Add child normal', questo creerà una sotto-menu all`interno del menu _Add.
Impostare la label a `_Wine ` e l'handler per l'evento activate su `on_AddWine`.

Si noterà che l'handler del pulsante e del menu sono gli stessi. Questo perchè entrambi i widget avranno lo stesso identico compito, l`aggiunta di un vino alla nostra lista dei vini.

Immagine

Quindi quando l'utente clicchera sul pulsante o sul menu si aprira una finestra di dialogo che gli permettera' di inserire i dettagli sul vino. Se si sceglie il pulsante `Ok` per terminare la finestra, le informazioni inserite saranno aggiunte alla ListView.

Creazione di una finestra di dialogo

Ora dobbiamo creare la finestra di dialogo che l`utente dovrà utilizzare per aggiungere un nuovo vino.  Per questo esempio permetteremo all`utente di inserire il nome del vino, la cantina, l`anno di imbottigliamento, e la varietà di uva.

Quindi, per creare una nuova finestra di dialogo è sufficiente fare clic sul pulsante di dialogo sulla finestra Glade palette. Ciò dovrebbe aprire una nuova finestra di dialogo. Ora, impostare il nome della finestra a `wineDlg` ed il titolo a `Add Wine`.

Useremo una table per disporre le cose nel nostro wineDlg, aggiungere la tabella alla finestra di dialogo e impostare il numero di righe da 4 e il numero di colonne a 2. Poi riempiremo gli spazi della tabella con label  e widget per l`inserimento di testo fino a quando la finestra di dialogo sara' simile a questa:

Immagine


Ho aggiunto tre pixel di spaziatura tra le righe della tabella, questa impostazione si trova tra le proprietà della tabella. Se hai problemi per selezionare la tabella è possibile selezionare View | Inspector dal menu nella finestra Glade principale e selezionare la tabella nella struttura dei widget.

Nominare quindi le quattro caselle di testo come: enWine, enWinery, enGrape, e enYear.

Ndt
Aggiungere anche i due pulsanti stock e assegnargli response Id -5 per OK e -6 per Cancel (tra le proprieta del pulsante)
Il nome non è importante ma è cmq buona norma dare sempre dei nomi sensati a variabili e widget


Il codice Python

Ora ci occuperemo del codice per farlo funzionare, chiameremo il nostro file pywine.py e lo creeremo nel nostro
/progetti/PyWine (la stessa directory in cui abbiamo creato il nostro file glade).  Di seguito è riportato il codice di base che useremo (la maggior parte di esso preso da PyGTK/Glade tutorial ):
Codice: Seleziona tutto
#!/usr/bin/env python

import sys
try:
import pygtk
pygtk.require("2.0")
except:
pass
try:
import gtk
import gtk.glade
except:
sys.exit(1)

class pyWine:
"""This is the PyWine application"""

def __init__(self):

#Set the Glade file
self.gladefile = "pywine.glade"
self.wTree = gtk.glade.XML(self.gladefile, "mainWindow")

#Create our dictionay and connect it
dic = {"on_mainWindow_destroy" : gtk.main_quit
, "on_AddWine" : self.OnAddWine}
self.wTree.signal_autoconnect(dic)

def OnAddWine(self, widget):
"""Called when the use wants to add a wine"""

print "OnAddWine"

if __name__ == "__main__":
wine = pyWine()
gtk.main()


Ci sono alcune novita' in questo codice, una è l'handler per on_AddWine, se si esegue questo codice si noterà che "OnAddWine" verrà stampato quando si fa clic sul pulsante Add wine e quando si seleziona Add | Wine dal menu. L'altra novita'  è che si passa il nome della finestra principale a gtk.glade.XML. Questo ci consente di caricare solo quella finestra ed i suoi child.
Ora creeremo una classe Wine che useremo per memorizzare le informazioni dei vini:
Codice: Seleziona tutto
class Wine:
"""This class represents all the wine information"""

def __init__(self, wine="", winery="", grape="", year=""):

self.wine = wine
self.winery = winery
self.grape = grape
self.year = year


Abbastanza semplice.... ora creeremo una classe che useremo per la nostra finestra di dialogo, che chiameremo wineDialog:
Codice: Seleziona tutto
class wineDialog:
"""This class is used to show wineDlg"""

def __init__(self, wine="", winery="", grape="", year=""):

#setup the glade file
self.gladefile = "pywine.glade"
#setup the wine that we will return
self.wine = Wine(wine,winery,grape,year)


ora aggiungiamo una funzione alla nostra classe wineDialog che caricherà il widget wineDlg dal file glade e lo mostrera'. Useremo questa funzione anche per restituire il risultato della finestra di dialogo, che sarà un gtk.RESPONSE, si può leggere di più su questo sul sito PyGTK..

Ecco la funzione:

Codice: Seleziona tutto
def run(self):
"""This function will show the wineDlg"""

#load the dialog from the glade file
self.wTree = gtk.glade.XML(self.gladefile, "wineDlg")
#Get the actual dialog widget
self.dlg = self.wTree.get_widget("wineDlg")
#Get all of the Entry Widgets and set their text
self.enWine = self.wTree.get_widget("enWine")
self.enWine.set_text(self.wine.wine)
self.enWinery = self.wTree.get_widget("enWinery")
self.enWinery.set_text(self.wine.winery)
self.enGrape = self.wTree.get_widget("enGrape")
self.enGrape.set_text(self.wine.grape)
self.enYear = self.wTree.get_widget("enYear")
self.enYear.set_text(self.wine.year)

#run the dialog and store the response
self.result = self.dlg.run()
#get the value of the entry fields
self.wine.wine = self.enWine.get_text()
self.wine.winery = self.enWinery.get_text()
self.wine.grape = self.enGrape.get_text()
self.wine.year = self.enYear.get_text()

#we are done with the dialog, destroy it
self.dlg.destroy()

#return the result and the wine
return self.result,self.wine


Noterete che si carica la finestra di dialogo dal file glade nello stesso modo in cui abbiamo caricato la finestra principale. Chiamiamo gtk.glade.XML () passandogli il nome del widget che vogliamo caricare.  Questo mostrerà automaticamente la finestra di dialogo (nello stesso modo della nostra finestra principale), ma per noi non è sufficientei, vogliamo che la funzione di esecuzione attenda finché l'utente ha terminato prima di tornare al chiamante. Per farlo chiameremo get_widget del widget tree (self.dlg = self.wTree.get_widget("wineDlg")) e la  GTkDialogs run function

Lascio alla documentazione PyGTK descrivere ciò che questa funzione fa:
   The run() method blocks in a recursive main loop until the dialog either emits the “response” signal, or is destroyed. If the dialog is destroyed, the run() method returns gtk.RESPONSE_NONE; otherwise, it returns the response ID from the “response” signal emission. Before entering the recursive main loop, the run() method calls the gtk.Widget.show() on the dialog for you. Note that you still need to show any children of the dialog yourself.

   During the run() method, the default behavior of “delete_event” is disabled; if the dialog receives a “delete_event”, it will not be destroyed as windows usually are, and the run() method will return gtk.RESPONSE_DELETE_EVENT. Also, during the run() method the dialog will be modal. You can force the run() method to return at any time by calling response() to emit the “response” signal. Destroying the dialog during the run() method is a very bad idea, because your post-run code won’t know whether the dialog was destroyed or not.

   After the run() method returns, you are responsible for hiding or destroying the dialog as needed.


Il pulsante OK ritornera gtk.RESPONSE_OK (-5) e il pulsante Cancel tornerà gtk.RESPONSE_CANCEL (-6), per il resto a noi ci interessa soltanto il vino che viene restituito da questa finestra di dialogo se l'utente fa clic sul pulsante Ok.

Si può anche vedere che abbiamo utilizzato i widgets GtkEntry della finestra di dialogo, al fine di ottenere e impostare il loro testo. In fondo questa funzione è abbastanza semplice.

Tree views e List Stores


Ora che abbiamo il vino che l'utente ha voluto aggiungere alla lista dobbiamo aggiungerlo al gtk.TreeView.

La caratteristica principale dei GTKTreeViews è che visualizzano i propri dati in qualsiasi modo i loro modelli dicano loro di farlo. Possono utilizzare un gkt.ListStore, gtk.TreeStore, gtk.TreeModelSort, o un gtk.GenericTreeModel. Per questo esempio abbiamo intenzione di utilizzare un gtk.ListStore.

Le relazioni tra Tree View e modelli sono un po complicate, ma una volta che si inizia ad usarlo si inizierà a capire perché l'hanno fatto in questo modo. Molto semplicemente, il modello rappresenta i dati, e la Tree view è semplicemente un modo per visualizzare i dati. Cosi' potete avere viste multiple per visualizzare gli stessi dati (modello) in modi totalmente diversi. Dal manuale di riferimento GTK+:

   To create a tree or list in GTK+, use the GtkTreeModel interface in conjunction with the GtkTreeView widget. This widget is designed around a Model/View/Controller design and consists of four major parts:
   The tree view widget (GtkTreeView)
   The view column (GtkTreeViewColumn)
   The cell renderers (GtkCellRenderer etc.)
   The model interface (GtkTreeModel)

   The View is composed of the first three objects, while the last is the Model. One of the prime benefits of the MVC design is that multiple views can be created of a single model. For example, a model mapping the file system could be created for a file manager. Many views could be created to display various parts of the file system, but only one copy need be kept in memory.


La prima cosa che dobbiamo fare è aggiungere del codice alla funzione __init__ della classe pyWine subito dopo la connessione automatica del dizionario al widget tree:

Codice: Seleziona tutto
#Here are some variables that can be reused later
self.cWine = 0
self.cWinery = 1
self.cGrape = 2
self.cYear = 3

self.sWine = "Wine"
self.sWinery = "Winery"
self.sGrape = "Grape"
self.sYear = "Year"

#Get the treeView from the widget Tree
self.wineView = self.wTree.get_widget("wineView")
#Add all of the List Columns to the wineView
self.AddWineListColumn(self.sWine, self.cWine)
self.AddWineListColumn(self.sWinery, self.cWinery)
self.AddWineListColumn(self.sGrape, self.cGrape)
self.AddWineListColumn(self.sYear, self.cYear)


Questo codice è piuttosto semplice, in primo luogo abbiamo creato poche variabili che agiscono come 'define' per noi (in modo che possiamo facilmente cambiare le cose in seguito), quindi otteniamo la nostra gtk.TreeView dal widget tree. Dopo di che  chiamiamo una nuova funzione per aggiungere le colonne di cui abbiamo bisogno nella lista AddWineListColumn che ci evita di dover replicare la colonna e di riscrivere il codice ogni volta:

Codice: Seleziona tutto
def AddWineListColumn(self, title, columnId):
"""This function adds a column to the list view.
First it create the gtk.TreeViewColumn and then set
some needed properties"""

column = gtk.TreeViewColumn(title, gtk.CellRendererText()
, text=columnId)
column.set_resizable(True)
column.set_sort_column_id(columnId)
self.wineView.append_column(column)


Questo codice è un po più complicato, prima creiamo un nuovo gtk.TreeViewColumn che utilizza un gtk.CellRendererText e il suo gtk.CellRenderer. Maggiori informazioni dal manuale di riferimento GTK+:

   Once the GtkTreeView widget has a model, it will need to know how to display the model. It does this with columns and cell renderers.

   Cell renderers are used to draw the data in the tree model in a way. There are a number of cell renderers that come with GTK+ 2.x, including the GtkCellRendererText, GtkCellRendererPixbuf and the GtkCellRendererToggle. It is relatively easy to write a custom renderer.

   A GtkTreeViewColumn is the object that GtkTreeView uses to organize the vertical columns in the tree view. It needs to know the name of the column to label for the user, what type of cell renderer to use, and which piece of data to retrieve from the model for a given row.


Quindi, in pratica quello che stiamo facendo è creare una colonna con un titolo specifico, precisando che esso deve utilizzare il gtk.CellRendererText (per visualizzare semplicemente il testo), e dirgli a quale elemento nel modello è collegata. Lo renderemo ridimensionabile e consentiremo all'utente di ordinare l'elenco cliccando sulla intestazione di colonna.  Dopo di che tutto quello che facciamo è aggiungere la colonna alla visualizzazione.

Ora che questo è fatto, dobbiamo creare il nostro modello, faremo questo di nuovo nella funzione __init__ della classe pyWine:
Codice: Seleziona tutto
#Create the listStore Model to use with the wineView
self.wineList = gtk.ListStore(str, str, str, str)
#Attatch the model to the treeView
self.wineView.set_model(self.wineList)


Fondamentalmente abbiamo semplicemente creato un gtk.ListStore dicendogli che avrà quattro elementi, ciascuno dei quali sara la rispettiva stringa. Allora attacchiamo il modello alla view e questo è tutto cio che dobbiamo fare per inizializare il gtk.TreeView.

Mettere tutto insieme

L'ultima cosa che dobbiamo fare è scrivere la funzione OnAddWine (chiamata dal menu o dal pulsante della barra degli strumenti) nella classe pyWine. E 'una funzione molto semplice:

Codice: Seleziona tutto
def OnAddWine(self, widget):
"""Called when the use wants to add a wine"""
#Create the dialog, show it, and store the results
wineDlg = wineDialog();
result,newWine = wineDlg.run()

if (result == gtk.RESPONSE_OK):
"""The user clicked Ok, so let's add this
wine to the wine list"""
self.wineList.append(newWine.getList())


Così si crea un'istanza della nostra wineDialog che poi lanciamo memorizzando il risultato e le informazioni del vino che l'utente ha inserito. Poi dobbiamo controllare se il risultato è stato gtk.RESPONSE_OK (l'utente fa clic sul pulsante Ok) e nel caso poi aggiungere le informazioni del vino al nostro gtk.ListStore che sarà automaticamente visualizzato nel nostro gtk.TreeView dato che i due sono collegati.

Faremo uso della semplice funzione GetList nella nostra classe Wine per rendere questo un po più facile da leggere:

Codice: Seleziona tutto
def getList(self):
"""This function returns a list made up of the
wine information.  It is used to add a wine to the
wineList easily"""
return [self.wine, self.winery, self.grape, self.year]


Immagine

Questo è tutto per questa applicazione di esempio, non salva ancora alcuna informazione ma dimostra come creare una gui da utilizzare poi a piacimento.

Il sorgente completo e Glade file può essere trovato qui. E' possibile anche sfogliare il codice sorgente completo qui sotto:
Codice: Seleziona tutto
#!/usr/bin/env python

import sys
try:
import pygtk
pygtk.require("2.0")
except:
pass
try:
import gtk
import gtk.glade
except:
sys.exit(1)

class pyWine:
"""This is an PyWine application"""

def __init__(self):

#Set the Glade file
self.gladefile = "pywine.glade"
self.wTree = gtk.glade.XML(self.gladefile, "mainWindow")

#Create our dictionay and connect it
dic = {"on_mainWindow_destroy" : gtk.main_quit
, "on_AddWine" : self.OnAddWine}
self.wTree.signal_autoconnect(dic)

#Here are some variables that can be reused later
self.cWine = 0
self.cWinery = 1
self.cGrape = 2
self.cYear = 3

self.sWine = "Wine"
self.sWinery = "Winery"
self.sGrape = "Grape"
self.sYear = "Year"

#Get the treeView from the widget Tree
self.wineView = self.wTree.get_widget("wineView")
#Add all of the List Columns to the wineView
self.AddWineListColumn(self.sWine, self.cWine)
self.AddWineListColumn(self.sWinery, self.cWinery)
self.AddWineListColumn(self.sGrape, self.cGrape)
self.AddWineListColumn(self.sYear, self.cYear)

#Create the listStore Model to use with the wineView
self.wineList = gtk.ListStore(str, str, str, str)
#Attache the model to the treeView
self.wineView.set_model(self.wineList)

def AddWineListColumn(self, title, columnId):
"""This function adds a column to the list view.
First it create the gtk.TreeViewColumn and then set
some needed properties"""

column = gtk.TreeViewColumn(title, gtk.CellRendererText()
, text=columnId)
column.set_resizable(True)
column.set_sort_column_id(columnId)
self.wineView.append_column(column)

def OnAddWine(self, widget):
"""Called when the use wants to add a wine"""
#Cteate the dialog, show it, and store the results
wineDlg = wineDialog();
result,newWine = wineDlg.run()

if (result == gtk.RESPONSE_OK):
"""The user clicked Ok, so let's add this
wine to the wine list"""
self.wineList.append(newWine.getList())

class wineDialog:
"""This class is used to show wineDlg"""

def __init__(self, wine="", winery="", grape="", year=""):

#setup the glade file
self.gladefile = "pywine.glade"
#setup the wine that we will return
self.wine = Wine(wine,winery,grape,year)

def run(self):
"""This function will show the wineDlg"""

#load the dialog from the glade file
self.wTree = gtk.glade.XML(self.gladefile, "wineDlg")
#Get the actual dialog widget
self.dlg = self.wTree.get_widget("wineDlg")
#Get all of the Entry Widgets and set their text
self.enWine = self.wTree.get_widget("enWine")
self.enWine.set_text(self.wine.wine)
self.enWinery = self.wTree.get_widget("enWinery")
self.enWinery.set_text(self.wine.winery)
self.enGrape = self.wTree.get_widget("enGrape")
self.enGrape.set_text(self.wine.grape)
self.enYear = self.wTree.get_widget("enYear")
self.enYear.set_text(self.wine.year)

#run the dialog and store the response
self.result = self.dlg.run()
#get the value of the entry fields
self.wine.wine = self.enWine.get_text()
self.wine.winery = self.enWinery.get_text()
self.wine.grape = self.enGrape.get_text()
self.wine.year = self.enYear.get_text()

#we are done with the dialog, destory it
self.dlg.destroy()

#return the result and the wine
return self.result,self.wine

class Wine:
"""This class represents all the wine information"""

def __init__(self, wine="", winery="", grape="", year=""):

self.wine = wine
self.winery = winery
self.grape = grape
self.year = year

def getList(self):
"""This function returns a list made up of the
wine information.  It is used to add a wine to the
wineList easily"""
return [self.wine, self.winery, self.grape, self.year]

if __name__ == "__main__":
wine = pyWine()
gtk.main()
Allegati
pywine.glade.rar
(1.39 KiB) Scaricato 156 volte
Ultima modifica di Alkatron il lunedì 25 ottobre 2010, 18:51, modificato 1 volta in totale.
Avatar utente
Alkatron
Entusiasta Emergente
Entusiasta Emergente
 
Messaggi: 1187
Iscrizione: aprile 2009
Distribuzione: debian jessie 64

Re: Tutorial PyGTK e Glade (1 parte)

Messaggioda SAKO » venerdì 21 maggio 2010, 12:51

Sono il primo a ringraziarti?!?

Grazie del lavoro che hai fatto! Stasera proverò a seguire la guida.
Avatar utente
SAKO
Scoppiettante Seguace
Scoppiettante Seguace
 
Messaggi: 528
Iscrizione: ottobre 2007

Re: Tutorial PyGTK e Glade (1 parte)

Messaggioda Alkatron » venerdì 21 maggio 2010, 12:56

Si infatti la 2 parte non l'avevo neanche iniziata..... 8)

Se trovi cose poco chiare dimmele che le sistemo.

Ciao
Avatar utente
Alkatron
Entusiasta Emergente
Entusiasta Emergente
 
Messaggi: 1187
Iscrizione: aprile 2009
Distribuzione: debian jessie 64

Re: Tutorial PyGTK e Glade (1 parte)

Messaggioda Zoff » venerdì 21 maggio 2010, 15:55

@Alkatron Secondo me dovresti scriverla nel wiki questa guida.
Questa sezione è destinata alle richeiste di supporto tecnico.
Il wiki invece è fatto apposta per guide e tutorial.

Non è difficile da usare, basta iscriversi.
Prima di aprire una discussione leggi le Guide, poi vedi se c'è un HowTo nel Wiki e fai una ricerca nel Forum!
Applica semplicemente il [Risolto]! Prova: viewtopic.php?f=70&t=548821
Vuoi qualcosa di piu' dal forum? Prova i miei script: viewtopic.php?f=70&t=597066
Avatar utente
Zoff
Moderatore Globale
Moderatore Globale
 
Messaggi: 33316
Iscrizione: ottobre 2007

Re: Tutorial PyGTK e Glade (1 parte)

Messaggioda citizen70043399 » mercoledì 29 settembre 2010, 17:27

Ho visto solo ora questa guida...
Grazie!
Avatar utente
citizen70043399
Entusiasta Emergente
Entusiasta Emergente
 
Messaggi: 1010
Iscrizione: gennaio 2009

Re: Tutorial PyGTK e Glade (1 parte)

Messaggioda Alkatron » giovedì 30 settembre 2010, 15:24

Zoff ha scritto:@Alkatron Secondo me dovresti scriverla nel wiki questa guida.
Questa sezione è destinata alle richeiste di supporto tecnico.
Il wiki invece è fatto apposta per guide e tutorial.

Non è difficile da usare, basta iscriversi.


Mi sono iscritto e ho provato a fare una nuova pagina, ho aperto la mia guida in modifica copiato tutto (compresi i bbcode) e incollata nella pagina appena creata nel wiki, ma praticamente mi incolla il testo senza formattazioni, senza interpretare i bbcode.....

Sono io che sbaglio qualcosa o bisogna cmq riformattare di nuovo tutto il testo?

C'è un modo per copiarla cosi com'è direttamente nel wiki, mantenendo almeno i bbcode? Poi allegati, immagini e aggiustamenti vari quelli ovviamente me li aspetto.


Ciao e grazie
Avatar utente
Alkatron
Entusiasta Emergente
Entusiasta Emergente
 
Messaggi: 1187
Iscrizione: aprile 2009
Distribuzione: debian jessie 64

Re: Tutorial PyGTK e Glade (1 parte)

Messaggioda Zoff » giovedì 30 settembre 2010, 15:26

I wiki non usano bbcode, leggi le guide per gli autori del wiki.
Prima di aprire una discussione leggi le Guide, poi vedi se c'è un HowTo nel Wiki e fai una ricerca nel Forum!
Applica semplicemente il [Risolto]! Prova: viewtopic.php?f=70&t=548821
Vuoi qualcosa di piu' dal forum? Prova i miei script: viewtopic.php?f=70&t=597066
Avatar utente
Zoff
Moderatore Globale
Moderatore Globale
 
Messaggi: 33316
Iscrizione: ottobre 2007

Re: [Supporto] Tutorial PyGTK e Glade (1 parte)

Messaggioda Alkatron » lunedì 25 ottobre 2010, 18:51

Ho tradotto anche la seconda parte
http://forum.ubuntu-it.org/viewtopic.php?t=419273
Avatar utente
Alkatron
Entusiasta Emergente
Entusiasta Emergente
 
Messaggi: 1187
Iscrizione: aprile 2009
Distribuzione: debian jessie 64

Re: [Supporto] Tutorial PyGTK e Glade (1 parte)

Messaggioda Zoff » lunedì 25 ottobre 2010, 19:04

Una volta che lo sapevi perché non hai continuato sul wiki come ti avevo suggerito?
Prima di aprire una discussione leggi le Guide, poi vedi se c'è un HowTo nel Wiki e fai una ricerca nel Forum!
Applica semplicemente il [Risolto]! Prova: viewtopic.php?f=70&t=548821
Vuoi qualcosa di piu' dal forum? Prova i miei script: viewtopic.php?f=70&t=597066
Avatar utente
Zoff
Moderatore Globale
Moderatore Globale
 
Messaggi: 33316
Iscrizione: ottobre 2007

Re: [Supporto] Tutorial PyGTK e Glade (1 parte)

Messaggioda Alkatron » lunedì 25 ottobre 2010, 19:16

Ho provato a vedere ma ho visto che bisogna richiedere l'approvazione, entrare in un gruppo, e che, non esendoci uno strumento che traduce da html o bbcode, avrei dovuto imparare i nuovi tag....non lo avrei mai fatto sono sincero.
Mi scuso della cosa, ma penso sia piu utile averlo tradotto e pubblicato in modo non perfettamente consono che non averlo fatto proprio. In un ottica opensource e di collaborazione, se qualcuno ha voglia di portarlo sul wiki non ho problemi a dargli l'originale senza bbcode e a rimuovere le discussioni dalla stanza.

Ciao
Avatar utente
Alkatron
Entusiasta Emergente
Entusiasta Emergente
 
Messaggi: 1187
Iscrizione: aprile 2009
Distribuzione: debian jessie 64

Re: [Supporto] Tutorial PyGTK e Glade (1 parte)

Messaggioda Zoff » lunedì 25 ottobre 2010, 19:20

Ci sono tutte le istruzioni direttamente nel wiki:
GuidaWiki/Editor
GuidaWiki/RegoleStilistiche
Prima di aprire una discussione leggi le Guide, poi vedi se c'è un HowTo nel Wiki e fai una ricerca nel Forum!
Applica semplicemente il [Risolto]! Prova: viewtopic.php?f=70&t=548821
Vuoi qualcosa di piu' dal forum? Prova i miei script: viewtopic.php?f=70&t=597066
Avatar utente
Zoff
Moderatore Globale
Moderatore Globale
 
Messaggi: 33316
Iscrizione: ottobre 2007

Re: [Supporto] Tutorial PyGTK e Glade (1 parte)

Messaggioda More+ » giovedì 17 marzo 2011, 17:20

Ciao Alkatron e complimenti per questo thread


...anche se non lo hai "wikizzato"  ;D

More+
Un blog scritto da un programmatore di insuccesso per coloro che aspirano a diventare tali:  http://programmatorepercaso.blogspot.com
Avatar utente
More+
Scoppiettante Seguace
Scoppiettante Seguace
 
Messaggi: 426
Iscrizione: gennaio 2006

Re: [Supporto] Tutorial PyGTK e Glade (1 parte)

Messaggioda faustf » martedì 10 novembre 2015, 19:06

buon di scusate , ma ho sono solo io a trovare difficolta a disegnare le gui con glade o è una cosa comune ??? nessuno ha una guida su cme usare i contenitori??? , ci sto provando da giorni ma disegna sempre come caz...... gli pare :D , non cè un qualcosa di meglio di glade???
faustf
Prode Principiante
 
Messaggi: 79
Iscrizione: novembre 2010

Re: [Supporto] Tutorial PyGTK e Glade (1 parte)

Messaggioda telperion » martedì 10 novembre 2015, 21:49

faustf Immagine ha scritto: non cè un qualcosa di meglio di glade???


Si fare a mano:
http://python-gtk-3-tutorial.readthedoc ... ction.html

NOTA thread vecchio e decrepito, ha qualche valenza per chi usa le gtk2, con le gtk3 non è assolutamente adatto.
Per i container boxes e grid bastano il 99% dei casi.
http://python-gtk-3-tutorial.readthedoc ... .html#grid
Avatar utente
telperion
Rampante Reduce
Rampante Reduce
 
Messaggi: 5344
Iscrizione: luglio 2006

Re: [Supporto] Tutorial PyGTK e Glade (1 parte)

Messaggioda giulux » mercoledì 11 novembre 2015, 1:45

Appunto, thread vecchio e decrepito.
Guardare le date delle discussioni prima di postare.
Questa la chiudo, aprirne una nuova.
Ciao
con l'aiuto della comunità le cose si mettono quasi sempre a posto (e non apposto), a parte (e non apparte) qualche caso ...
Avatar utente
giulux
Amministratore
Amministratore
 
Messaggi: 19138
Iscrizione: gennaio 2010
Località: Roma
Desktop: xubuntu - ubuntu gnome
Distribuzione: Ubuntu 16.04.1 LTS x86_64
Sesso: Maschile


Torna a Programmazione

Chi c’è in linea

Visualizzano questa sezione: 0 utenti registrati e 8 ospiti