Pagine più lunghe

Vengono mostrati sotto 500 risultati dal 1 al 500.

Vedi (precedenti 500 | successivi 500) (20 | 50 | 100 | 250 | 500).

  1. (cron) ‎Guide della comunità ‎[104 918 byte]
  2. (cron) ‎Alsa e Gambas: Invio dati con l'uso delle Strutture ‎[56 410 byte]
  3. (cron) ‎Lezioni: introduzione generale ‎[43 267 byte]
  4. (cron) ‎Un contributo sulle funzioni esterne in Gambas a cura di Doriano B. ‎[41 747 byte]
  5. (cron) ‎Gestire con un Puntatore le Strutture esterne ‎[38 490 byte]
  6. (cron) ‎Creare una finestra mediante le funzioni del API di X11 ‎[35 565 byte]
  7. (cron) ‎Convertire i formati audio mediante il Componente gb.media ‎[35 265 byte]
  8. (cron) ‎Creare una finestra mediante le funzioni del API di SDL ‎[34 747 byte]
  9. (cron) ‎Gestire con sicurezza le Strutture esterne ‎[33 783 byte]
  10. (cron) ‎Generare un file immagine da una DrawingArea ‎[33 039 byte]
  11. (cron) ‎Eseguire onde sonore con Alsa ‎[30 937 byte]
  12. (cron) ‎ALSA e Gambas - Il Tempo della coda ‎[29 158 byte]
  13. (cron) ‎Gestione delle Strutture esterne ‎[28 822 byte]
  14. (cron) ‎Eseguire un file MIDI mediante il componente gb.media ‎[28 807 byte]
  15. (cron) ‎Conoscere con le funzioni esterne di ALSA i dispositivi Midi presenti nel sistema ‎[28 686 byte]
  16. (cron) ‎Gli Oggetti e le Classi ‎[28 602 byte]
  17. (cron) ‎Gestione dei dati media con GStreamer ‎[27 654 byte]
  18. (cron) ‎Alsa e Gambas: Ricezione dei dati Midi con l'uso dei File Descriptor ‎[26 917 byte]
  19. (cron) ‎La gestione dei file audio mediante il componente gb.openal ‎[26 903 byte]
  20. (cron) ‎Creare report con il componente gb.report2 ‎[26 698 byte]
  21. (cron) ‎Alsa e Gambas: Invio dei dati senza connessione della porta del programma con il Softsynth ‎[26 664 byte]
  22. (cron) ‎Alsa e Gambas: Invio dati con l'uso di un'area di memoria allocata ‎[25 999 byte]
  23. (cron) ‎Mostrare sulla MapView disegni, immagini e Controlli senza l'uso del Metodo Map.AddShape() ‎[25 961 byte]
  24. (cron) ‎Scrivere una Funzione ‎[25 918 byte]
  25. (cron) ‎Colorare testo e sfondo in Console o Terminale ‎[25 630 byte]
  26. (cron) ‎Indirizzare dati da un programma ad un altro e ad un Terminale ‎[24 839 byte]
  27. (cron) ‎Apertura del subsistema PCM in modalità Registrazione ‎[24 123 byte]
  28. (cron) ‎Mostrare la mappa topografica IGM 1 25000 fornita dal Geoportale Nazionale del Ministero dell'Ambiente ‎[23 771 byte]
  29. (cron) ‎Intercettare i dati del mouse dai file-device mouse, mice, event ‎[23 727 byte]
  30. (cron) ‎ALSA e Gambas - Subsistema Seq: introduzione ‎[23 152 byte]
  31. (cron) ‎Strutture: dichiarazione ed uso ‎[22 817 byte]
  32. (cron) ‎Audio ed Alsa: apertura del subsistema PCM ‎[22 595 byte]
  33. (cron) ‎Eseguire i file audio mediante la Classe ''MediaPipeline'' del componente gb.media ‎[22 213 byte]
  34. (cron) ‎Riproduzione standard dei file video con le funzioni esterne di GStreamer ‎[22 057 byte]
  35. (cron) ‎Eseguire file audio mediante le funzioni esterne del API di VLC ‎[21 983 byte]
  36. (cron) ‎Extern: richiamare funzioni esterne a Gambas ‎[21 896 byte]
  37. (cron) ‎Modificare l'aspetto del cursore del mouse ‎[21 890 byte]
  38. (cron) ‎Creare da codice una Classe specifica ‎[21 512 byte]
  39. (cron) ‎Disegnare in una DrawingArea dei punti ‎[21 000 byte]
  40. (cron) ‎Estrarre informazioni da un file .wav ‎[20 998 byte]
  41. (cron) ‎La gestione dei dati Midi senza l'uso delle funzioni di Alsa ‎[20 517 byte]
  42. (cron) ‎Inserire un Oggetto grafico su una MapView ‎[20 447 byte]
  43. (cron) ‎Creare file GIF con le funzioni esterne del API di Libplot ‎[20 444 byte]
  44. (cron) ‎Importare ed utilizzare librerie .gambas ‎[20 265 byte]
  45. (cron) ‎Catturare con il componente gb.media quanto mostrato dalla finestra di un programma e farne un file video ‎[20 197 byte]
  46. (cron) ‎Eseguire i file audio mediante la Classe ''MediaPlayer'' del componente gb.media ‎[19 266 byte]
  47. (cron) ‎Il protocollo Midi ‎[19 130 byte]
  48. (cron) ‎Conoscere con le funzioni esterne di ALSA i dispositivi audio presenti nel sistema ‎[19 090 byte]
  49. (cron) ‎Verificare le tessere dei livelli delle Map tiles ‎[19 034 byte]
  50. (cron) ‎Inviare dati Midi da Arduino a Gambas ‎[18 947 byte]
  51. (cron) ‎Alsa e Gambas: Invio dati con l'uso di una Classe specifica ‎[18 721 byte]
  52. (cron) ‎ALSA e Gambas - Inviarsi una Eco~ nel futuro ‎[18 715 byte]
  53. (cron) ‎Creare da una carta topografica i file delle tessere di una mappa e utilizzarli con MapView ‎[18 687 byte]
  54. (cron) ‎Eseguire i file video con il Componente gb.media ‎[18 595 byte]
  55. (cron) ‎Eseguire un file audio WAV con le sole funzioni esterne di Alsa ‎[18 243 byte]
  56. (cron) ‎Eseguire un file audio mediante le funzioni esterne del API di SDL 2 ‎[17 891 byte]
  57. (cron) ‎Ottenere un file WAV da un file Midi con le funzioni esterne del API di WildMidi ‎[17 713 byte]
  58. (cron) ‎Elenco delle istruzioni HTML compatibili ‎[17 708 byte]
  59. (cron) ‎Eseguire i file video con le funzioni esterne del API di VLC ‎[17 683 byte]
  60. (cron) ‎Scaricare una immagine da un sito internet ‎[17 676 byte]
  61. (cron) ‎Gli Eventi ‎[17 511 byte]
  62. (cron) ‎La struttura di un file Midi ‎[17 460 byte]
  63. (cron) ‎Ottenere un'immagine del Form ‎[17 252 byte]
  64. (cron) ‎Creare un'immagine senza avere un file immagine ‎[17 209 byte]
  65. (cron) ‎Creare una finestra mediante le funzioni del API di SDL2 ‎[17 088 byte]
  66. (cron) ‎Disegnare un poligono su una MapView usando l'Oggetto "Figlio" DrawingArea ‎[16 874 byte]
  67. (cron) ‎Installazione Server PostgreSQL ‎[16 755 byte]
  68. (cron) ‎Creare un semplice Client di Jack con le risorse della libreria libjack ‎[16 551 byte]
  69. (cron) ‎Eseguire un file Midi mediante le funzioni esterne del API di VLC ‎[15 997 byte]
  70. (cron) ‎Uso della classe Application ‎[15 856 byte]
  71. (cron) ‎Struttura e gestione del file di tipo PNM ‎[15 613 byte]
  72. (cron) ‎Array multidimensionali con numero indeterminato di elementi ‎[15 205 byte]
  73. (cron) ‎Approfondimento sull'accesso alle porte USB ‎[15 204 byte]
  74. (cron) ‎Creare il blocco d'intestazione di un file WAV avendo dati audio grezzi ‎[15 193 byte]
  75. (cron) ‎Ottenere l'immagine di una pagina web ‎[14 937 byte]
  76. (cron) ‎Eseguire un file audio mediante le funzioni esterne dell'API di SDL ‎[14 902 byte]
  77. (cron) ‎Uso del dispositivo /dev/sequencer2 ‎[14 892 byte]
  78. (cron) ‎Creare un file PDF con le funzioni esterne del API di Haru ‎[14 873 byte]
  79. (cron) ‎Oggetti grafici e di testo che supportano il codice HTML ‎[14 615 byte]
  80. (cron) ‎Registrare il sonoro da una fonte esterna e salvarlo in un file audio mediante il Componente gb.media ‎[14 583 byte]
  81. (cron) ‎Eseguire una traccia di un CD audio con le funzioni esterne del API di libcdio e di ALSA ‎[14 509 byte]
  82. (cron) ‎Eseguire un file WAV mediante le funzioni esterne del API di libaudiofile e di Alsa ‎[14 504 byte]
  83. (cron) ‎La gestione dei file audio mediante il componente gb.sdl2.audio ‎[14 478 byte]
  84. (cron) ‎Mostrare una immagine JPEG in una finestra con le funzioni del API di X11 e di Libjpeg ‎[14 451 byte]
  85. (cron) ‎Utilizzo base di Gambas e Sqlite3 ‎[14 267 byte]
  86. (cron) ‎Realizzare un misuratore di picco audio con le sole funzioni esterne di Alsa ‎[14 264 byte]
  87. (cron) ‎"Dal testo al parlato" mediante le funzioni esterne del API di Pico TTS ‎[14 171 byte]
  88. (cron) ‎Write ‎[13 932 byte]
  89. (cron) ‎Unire più file ODT in un unico file ODT ‎[13 922 byte]
  90. (cron) ‎Spostare con il mouse il testo in una DrawingArea ‎[13 862 byte]
  91. (cron) ‎Inserire nella libreria condivisa esterna .so anche codice Assembly ‎[13 740 byte]
  92. (cron) ‎Sapere se un file di nome sconosciuto è stato creato o distrutto ‎[13 541 byte]
  93. (cron) ‎Inserire le password per lanciare comandi ‎[13 440 byte]
  94. (cron) ‎Le Variabili ‎[13 414 byte]
  95. (cron) ‎Creare un grafico con il componente gb.chart ‎[13 304 byte]
  96. (cron) ‎Alsa e Gambas: Client e porte in Invio dati ‎[13 303 byte]
  97. (cron) ‎InvBox ‎[13 281 byte]
  98. (cron) ‎Convertire un file WAV in formato OggVorbis con le funzioni esterne del API di libvorbisfile, libvorbisenc e libogg ‎[13 183 byte]
  99. (cron) ‎Utilizzare in una MapView mappe fornite secondo lo standard WMS (Web Map Service) ‎[12 969 byte]
  100. (cron) ‎Estrarre l'icona di un tipo di file ‎[12 836 byte]
  101. (cron) ‎Attivare un Componente dinamicamente da codice ‎[12 786 byte]
  102. (cron) ‎Alsa e Gambas - Dai Messaggi Midi standard all'Evento Midi di ALSA ‎[12 744 byte]
  103. (cron) ‎Eseguire una scansione e riconoscimento caratteri (OCR) con l'API di Sane, Tesseract e Leptonica ‎[12 629 byte]
  104. (cron) ‎"Dal testo al parlato" mediante le funzioni esterne del API di eSpeack ‎[12 547 byte]
  105. (cron) ‎Leggere e scrivere direttamente nell'area di memoria di una Struttura accedendovi con la classe Object ‎[12 487 byte]
  106. (cron) ‎Intercettare ed inviare dati Midi grezzi con le funzioni esterne del API di PortMidi ‎[12 375 byte]
  107. (cron) ‎Ottenere con il Componente gb.media un file audio dai dati Midi grezzi intercettati da un dispositivo Midi esterno ‎[12 318 byte]
  108. (cron) ‎Generare un'onda sinusoidale con le sole funzioni di Gambas ‎[12 136 byte]
  109. (cron) ‎Generare un'onda sinusoidale con le funzioni esterne della libreria PortAudio ‎[11 987 byte]
  110. (cron) ‎Ottenere informazioni generali e metadati da file audio-video con le risorse del API di VLC ‎[11 973 byte]
  111. (cron) ‎Riproduzione dell'audio di radio WEB con le funzioni esterne del API di GStreamer ‎[11 949 byte]
  112. (cron) ‎Metodi nascosti ‎[11 872 byte]
  113. (cron) ‎Individuare ed estrarre l'ID della finestra di un programma ‎[11 847 byte]
  114. (cron) ‎Ricevere dati Midi senza funzioni di ALSA e inviarli mediante le funzioni di Alsa ‎[11 710 byte]
  115. (cron) ‎Effettuare una ripresa video mediante una WebCam con il Componente gb.media ‎[11 576 byte]
  116. (cron) ‎Creare una finestra mediante le funzioni del API di XCB ‎[11 522 byte]
  117. (cron) ‎Confronto Array di Strutture verso Collezione di Classi ‎[11 511 byte]
  118. (cron) ‎Metodi New() e Free() degli oggetti ‎[11 476 byte]
  119. (cron) ‎Usare ALSA per far comunicare due o più programmi Gambas ‎[11 427 byte]
  120. (cron) ‎Individuare i tasti della tastiera intercettando i dati grezzi dal suo file-device ‎[11 338 byte]
  121. (cron) ‎Array: creazione, modifica e riempimento ‎[11 242 byte]
  122. (cron) ‎Ottenere una schermata ("screenshot") con Gambas ‎[11 227 byte]
  123. (cron) ‎Conversione del Tempo Delta fra due eventi Midi dai secondi nel valore esadecimale in formato "a lunghezza variabile" ‎[11 209 byte]
  124. (cron) ‎ALSA e Gambas - La marcatura temporale degli eventi: il Timestamp ‎[11 201 byte]
  125. (cron) ‎Utilizzare una DrawingArea o una ImageView con gb.map anziché una MapView ‎[11 151 byte]
  126. (cron) ‎Calcolare l'area e il perimetro di poligoni disegnati sulla mappa con le risorse di gb.map ‎[10 961 byte]
  127. (cron) ‎Registrare in un file audio una fonte sonora esterna usando una linea di pipeline con la funzione 'gst parse launch()' ‎[10 932 byte]
  128. (cron) ‎Aggiungere l'effetto Eco ad un file audio WAV con le funzioni esterne del API di Sox ‎[10 891 byte]
  129. (cron) ‎Disegnare un cerchio o un punto su una MapView ‎[10 812 byte]
  130. (cron) ‎Eseguire un file Video con le funzioni esterne del API di Libmpv ‎[10 770 byte]
  131. (cron) ‎Passare direttamente ad un oggetto Image i dati grezzi dei pixel di una DrawingArea mediante le risorse del API di X11 ‎[10 765 byte]
  132. (cron) ‎Read ‎[10 718 byte]
  133. (cron) ‎Conoscere le caratteristiche di CD e DVD con le funzioni del API di libcdio ‎[10 687 byte]
  134. (cron) ‎Eseguire un file WAV con le funzioni esterne del API di LibAo ‎[10 588 byte]
  135. (cron) ‎Ottenere informazioni generali sui dispositivi network mediante le risorse del API di Libnm-glib ‎[10 531 byte]
  136. (cron) ‎Eseguire un file audio mediante le funzioni esterne del API di Allegro 5 ‎[10 490 byte]
  137. (cron) ‎Estrarre informazioni e TAG da un file MP3 con le sole funzioni di Gambas ‎[10 455 byte]
  138. (cron) ‎Come creare un Componente scritto in linguaggio Gambas ‎[10 376 byte]
  139. (cron) ‎Estrarre informazioni da un file MP3 con le funzioni esterne del API di Id3tag ‎[10 333 byte]
  140. (cron) ‎Chiudere programmi esterni ‎[10 325 byte]
  141. (cron) ‎Alsa e Gambas: Ricezione dei dati Midi con un programma esterno di supporto ‎[10 204 byte]
  142. (cron) ‎Eseguire un file mp3 usando le API di mpg123 e di Alsa ‎[10 191 byte]
  143. (cron) ‎Eseguire una scansione con lo Scanner mediante le funzioni esterne di libsane ‎[10 158 byte]
  144. (cron) ‎Estrarre e salvare singole immagini da una ripresa video mediante WebCam effettuata con il Componente gb.media ‎[10 123 byte]
  145. (cron) ‎Come creare una Libreria condivisa (Shared Library) .so ‎[9 994 byte]
  146. (cron) ‎Riproduzione dell'audio di radio WEB mediante il Componente gb.media ‎[9 987 byte]
  147. (cron) ‎Saluti ‎[9 979 byte]
  148. (cron) ‎Eseguire un file audio mediante le funzioni esterne del API di PortAudio e SndFile ‎[9 957 byte]
  149. (cron) ‎Tutorial - creare un componente: il frame ‎[9 932 byte]
  150. (cron) ‎Stampare il contenuto di una DrawingArea ‎[9 910 byte]
  151. (cron) ‎Eseguire una traccia di un CD audio mediante le risorse del Componente gb.media ‎[9 905 byte]
  152. (cron) ‎Impostare il volume dei singoli due canali del mixer di ALSA ‎[9 869 byte]
  153. (cron) ‎Ridurre a 8-bit la risoluzione di campionamento di un file audio WAV con le funzioni esterne del API di Sox ‎[9 842 byte]
  154. (cron) ‎Alsa e Gambas: Ricevere dati Midi da uno Standard Midi File ‎[9 800 byte]
  155. (cron) ‎Uso della Classe System ‎[9 755 byte]
  156. (cron) ‎Scrivere nell'area di memoria puntata da un Puntatore ‎[9 714 byte]
  157. (cron) ‎Intercettare quanto viene scritto manualmente nella console o in un Terminale ‎[9 665 byte]
  158. (cron) ‎Definizione ed uso dei Memory Stream ‎[9 636 byte]
  159. (cron) ‎Eseguire i file Midi con le funzioni esterne dell'API di Alure ‎[9 583 byte]
  160. (cron) ‎Codifica del parlato mediante le funzioni esterne del API di Speex ‎[9 544 byte]
  161. (cron) ‎Convertire un file PNG in PDF con le funzioni del API di Cairo ‎[9 491 byte]
  162. (cron) ‎Utilizzare il Geoportale del Servizio Geologico d'Italia dell'I.S.P.R.A. ‎[9 484 byte]
  163. (cron) ‎Eseguire un file audio mediante le funzioni esterne del API di Sox ‎[9 460 byte]
  164. (cron) ‎Disegnare un percorso su una MapView e calcolarne la lunghezza ‎[9 432 byte]
  165. (cron) ‎Convertire un file WAV in formato MP3 con le funzioni esterne del API di Lame ‎[9 426 byte]
  166. (cron) ‎Articolo ezine ‎[9 373 byte]
  167. (cron) ‎CREATE PRIVATE...CREATE STATIC ‎[9 323 byte]
  168. (cron) ‎Alsa e Gambas: Ricezione dei dati Midi con un ciclo ‎[9 322 byte]
  169. (cron) ‎Individuare i nomi e le rispettive posizioni degli strumenti musicali in un file sf2 con le sole risorse di Gambas ‎[9 280 byte]
  170. (cron) ‎Estrarre da un file MP3 i soli dati audio grezzi mediante la libreria Libmad ‎[9 250 byte]
  171. (cron) ‎Catturare un'immagine con una webcam mediante le funzioni esterne del API di libsane ‎[9 210 byte]
  172. (cron) ‎Mostrare un'immagine nella finestra di Gedit con funzioni del API di X11 e Imlib2 ‎[9 201 byte]
  173. (cron) ‎Variare il volume di un file audio MP3 o WAV con le funzioni esterne del API di Sox ‎[9 186 byte]
  174. (cron) ‎Invio della posta elettronica ‎[9 181 byte]
  175. (cron) ‎Eseguire una traccia di un CD-Audio con le risorse di linux/cdrom.h e le funzioni esterne di ALSA ‎[9 179 byte]
  176. (cron) ‎Eseguire un file WAVE mediante le funzioni delle librerie libopenal e libaudio ‎[9 162 byte]
  177. (cron) ‎Estrarre un'immagine da un file video con le funzioni esterne del API di GStreamer ‎[9 135 byte]
  178. (cron) ‎Ottenere un file WAV da un file Midi con le funzioni esterne del API di FluidSynth ‎[9 072 byte]
  179. (cron) ‎Eseguire un file audio WAV con le sole funzioni esterne di C e di ALSA ‎[9 058 byte]
  180. (cron) ‎Scan ‎[9 012 byte]
  181. (cron) ‎Modificare la frequenza di campionamento di un file audio con l' API di Libsamplerate e Libsndfile ‎[8 984 byte]
  182. (cron) ‎Catturare un'immagine con una webcam mediante le funzioni esterne del API di libv4l2 ‎[8 941 byte]
  183. (cron) ‎Impostare il volume principale del mixer di ALSA ‎[8 936 byte]
  184. (cron) ‎Creare una finestra mediante le funzioni del API di GTK+3 ‎[8 932 byte]
  185. (cron) ‎Eseguire un file mp3 usando le risorse del API di Mpeg3 e di Alsa ‎[8 878 byte]
  186. (cron) ‎Alsa e Gambas: Client e Porte in Invio dati - Connessione della porta del programma con il Client Softsynth ‎[8 871 byte]
  187. (cron) ‎FOR...NEXT ‎[8 803 byte]
  188. (cron) ‎Leggere la posta elettronica con POP3 e SSL mediante le funzioni esterne del API di Libcurl ‎[8 763 byte]
  189. (cron) ‎Convertire un file audio mpeg in .wav con le funzioni esterne del API di mpg123 ‎[8 729 byte]
  190. (cron) ‎Mostrare un'immagine mediante il Componente gb.media ‎[8 707 byte]
  191. (cron) ‎Ricevere dati grezzi Midi attraverso il subsistema RawMidi ‎[8 695 byte]
  192. (cron) ‎Eseguire un file Midi con le risorse del API di WildMidi e di ALSA ‎[8 694 byte]
  193. (cron) ‎Decodifica dei dati precedentemente codificati mediante le funzioni esterne del API di Speex ‎[8 639 byte]
  194. (cron) ‎Convertire un file OggVorbis in WAV ed estrarne anche informazioni con le funzioni esterne del API di VorbisFile ‎[8 605 byte]
  195. (cron) ‎Assegnare ad un vettore i valori contenuti da un'area di memoria puntata da un Puntatore ‎[8 601 byte]
  196. (cron) ‎Conoscere con i Puntatori i valori contenuti in un vettore ‎[8 601 byte]
  197. (cron) ‎Creare file PNG con le funzioni esterne del API di Cairo e di Pango ‎[8 595 byte]
  198. (cron) ‎Write () ‎[8 563 byte]
  199. (cron) ‎Utilizzare come Struttura in Gambas una Struttura esterna dichiarata, come proprio membro di tipo Puntatore, da una Struttura principale esterna ‎[8 528 byte]
  200. (cron) ‎Spostare oggetti con il mouse all'interno di un contenitore senza Drag & Drop ‎[8 484 byte]
  201. (cron) ‎Estrarre informazioni generali da un file audio flac ‎[8 474 byte]
  202. (cron) ‎Generare un'onda sinusoidale con le funzioni esterne delle API di LibAo ‎[8 388 byte]
  203. (cron) ‎Convertire un file WAV in formato AAC con le funzioni esterne del API di Faac ‎[8 384 byte]
  204. (cron) ‎Ruotare il testo in una DrawingArea ‎[8 354 byte]
  205. (cron) ‎Utilizzare il tasto Tab della tastiera per spostare il cursore del mouse fra le celle di una TableView ‎[8 336 byte]
  206. (cron) ‎Conoscere le proprietà di un drive CD con le funzioni del API di libcdio ‎[8 309 byte]
  207. (cron) ‎Ottenere un unico file audio da due o più file audio mediante il componente gb.media ‎[8 286 byte]
  208. (cron) ‎Estrarre i dati audio di una traccia di un CD audio e crearne un file WAV con le risorse del API di libcdio paranoia ‎[8 281 byte]
  209. (cron) ‎Inviare dati da un programma Gambas ad un altro mediante le risorse del Componente DBus ‎[8 266 byte]
  210. (cron) ‎Analizzare il valore RMS, il picco e il decay dei dati audio mediante il plugin 'level'usando una linea di pipeline con la funzione 'gst parse launch()' ‎[8 259 byte]
  211. (cron) ‎Drag-Drop di un'immagine in una DrawingArea ‎[8 196 byte]
  212. (cron) ‎Memcpy () ‎[8 180 byte]
  213. (cron) ‎Ottenere informazioni dal proprio dispositivo wireless con le risorse del API di libiw ‎[8 140 byte]
  214. (cron) ‎Intercettare i dati inviati allo standard output da un programma C ‎[8 123 byte]
  215. (cron) ‎Stampare un file con le funzioni del API di cups ‎[8 123 byte]
  216. (cron) ‎Passare un'area riservata di memoria ad una funzione esterna ‎[8 088 byte]
  217. (cron) ‎Catturare e riprodurre immagini video mediante una WebCam con le funzioni esterne delle API di GStreamer ‎[8 042 byte]
  218. (cron) ‎Mostrare e usare in Gambas i simboli musicali forniti dal sistema UNICODE ‎[8 016 byte]
  219. (cron) ‎Scrivere una libreria esterna che ritorna una Struttura ‎[7 960 byte]
  220. (cron) ‎Leggere e scrivere in un vettore mediante i Memory Stream ‎[7 932 byte]
  221. (cron) ‎Uso delle Strutture tra Classi e Moduli ‎[7 884 byte]
  222. (cron) ‎Conversione Big-Endian/Little-Endian ‎[7 876 byte]
  223. (cron) ‎Ordinare i valori all'interno di una colonna di una GridView ‎[7 866 byte]
  224. (cron) ‎Differenza fra Assegnazione a un Puntatore di un indirizzo di memoria e Dereferenziazione di un Puntatore ‎[7 863 byte]
  225. (cron) ‎Disegnare e salvare un'immagine di tipo GIF con le funzioni del API di GifLib ‎[7 838 byte]
  226. (cron) ‎Ottenere la forma d'onda di un file audio mediante il Componente gb.media ‎[7 835 byte]
  227. (cron) ‎Ottenere un file audio da un file MIDI mediante il Componente gb.media ‎[7 790 byte]
  228. (cron) ‎Leggere il contenuto di una Directory mediante le risorse dichiarate nel file header "dirent.h" ‎[7 773 byte]
  229. (cron) ‎Eseguire un file audio mediante le funzioni di Alure ‎[7 742 byte]
  230. (cron) ‎Signal () ‎[7 738 byte]
  231. (cron) ‎Individuare il punto di intersezione degli angoli di direzione di due elementi geografici rispetto all'osservatore ‎[7 726 byte]
  232. (cron) ‎Far interagire Gambas con Arduino ‎[7 717 byte]
  233. (cron) ‎Ottenere informazioni sulle icone presenti sulla Scrivania ‎[7 711 byte]
  234. (cron) ‎Invio di posta elettronica con SMTP e SSL mediante le funzioni esterne del API di Libcurl ‎[7 705 byte]
  235. (cron) ‎Conoscere con le funzioni esterne di RtAudio i dispositivi audio presenti nel sistema ‎[7 689 byte]
  236. (cron) ‎Modificare la frequenza di campionamento di un file audio con l'API di Libresample e Libsndfile ‎[7 583 byte]
  237. (cron) ‎Salvare in un file video mediante le funzioni esterne del API di GStreamer la ripresa video effettuata con una WebCam ‎[7 569 byte]
  238. (cron) ‎Audio ed Alsa: introduzione ‎[7 545 byte]
  239. (cron) ‎Conoscere i dispositivi usb di memorizzazione di massa con le funzioni esterne di libudev ‎[7 526 byte]
  240. (cron) ‎Passaggio di un argomento per 'indirizzo' ad una Funzione ‎[7 515 byte]
  241. (cron) ‎Eseguire un file audio mediante l'oggetto MediaView del componente gb.media.form ‎[7 509 byte]
  242. (cron) ‎Convertire un file WAV in formato OggVorbis con le funzioni esterne del API di libfishsound, libsndfile e liboggz ‎[7 501 byte]
  243. (cron) ‎Uso del dispositivo /dev/sequencer ‎[7 456 byte]
  244. (cron) ‎Decomprimere e decodificare un file mp3 con le funzioni esterne del API di AVbin ‎[7 455 byte]
  245. (cron) ‎Estrarre le coordinate geografiche dai TAG GPS eventualmente presenti in un file immagine JPEG ‎[7 414 byte]
  246. (cron) ‎Catturare video e audio con una webcam ed un microfono e salvarli in un unico file video mediante le funzioni esterne del API di VLC ‎[7 363 byte]
  247. (cron) ‎Far mostrare sulla Scrivania i messaggi della specifica Desktop Notifications mediante le funzioni esterne del API di Libnotify ‎[7 328 byte]
  248. (cron) ‎Operazioni con precisione quadrupla a 128-bit con numeri in virgola mobile mediante la libreria quadmath.h ‎[7 312 byte]
  249. (cron) ‎Utilizzare le tessere di una mappa senza connessione a internet ‎[7 301 byte]
  250. (cron) ‎Sprintf () ‎[7 295 byte]
  251. (cron) ‎Conoscere la durata di un file Midi con le sole risorse di Gambas ‎[7 294 byte]
  252. (cron) ‎Ottenere informazioni da un file GEOTIFF con l'API di libgeotiff ‎[7 289 byte]
  253. (cron) ‎Controllare la temperatura dell'hardware mediante le funzioni del API di libsensors ‎[7 289 byte]
  254. (cron) ‎Ottenere un file di dati audio grezzi da un file .pat ‎[7 289 byte]
  255. (cron) ‎ALSA e Gambas: Connettere due Client mediante la sottoscrizione delle porte ‎[7 286 byte]
  256. (cron) ‎Conoscere i Client Midi di ALSA correnti attivi nel sistema ‎[7 283 byte]
  257. (cron) ‎ALSA e Gambas - Subsistema Seq: Il Client di Alsa e le sue porte ‎[7 223 byte]
  258. (cron) ‎Ottenere l'indirizzo e il valore di una Costante e di una variabile globale situate in una libreria condivisa ‎[7 198 byte]
  259. (cron) ‎Calcolare la durata di un file MP3 con le sole risorse native di Gambas ‎[7 192 byte]
  260. (cron) ‎Riproduzione e contemporanea registrazione dell'audio di radio WEB mediante il Componente gb.media ‎[7 191 byte]
  261. (cron) ‎Ruotare un triangolo in una DrawingArea ‎[7 162 byte]
  262. (cron) ‎Ottenere informazioni sulle applicazioni client in esecuzione su un display con le funzioni del API di X11 ‎[7 153 byte]
  263. (cron) ‎Stampare in Gambas ‎[7 146 byte]
  264. (cron) ‎Visualizzare un oscilloscopio di GStreamer mediante la funzione 'gst parse launch()' durante l'esecuzione di un file Midi ‎[7 134 byte]
  265. (cron) ‎Scomporre una stringa e caricare ogni parola in una variabile array ‎[7 115 byte]
  266. (cron) ‎Inviare dati grezzi Midi attraverso il subsistema RawMidi ‎[7 114 byte]
  267. (cron) ‎Configurazione, organizzazione ed impostazione dell'array secondo i sorgenti di Gambas ‎[7 070 byte]
  268. (cron) ‎Decomprimere un file immagine jpeg per ottenerne i dati grezzi mediante le funzioni esterne del API di libjpeg ‎[7 054 byte]
  269. (cron) ‎Read () ‎[7 041 byte]
  270. (cron) ‎Gestire Funzioni come oggetti ‎[6 987 byte]
  271. (cron) ‎Generare un'onda sinusoidale con il componente gb.openal ‎[6 981 byte]
  272. (cron) ‎Modificare il volume e la frequenza di campionamento di file audio WAV e AIFF con l'API di Libaudio ‎[6 972 byte]
  273. (cron) ‎Conoscere con le funzioni esterne di PortAudio i dispositivi audio presenti nel sistema ‎[6 972 byte]
  274. (cron) ‎Eseguire un file audio mediante le funzioni esterne del API di Mpv ‎[6 968 byte]
  275. (cron) ‎Visualizzare un oscilloscopio di GStreamer mediante la funzione 'gst parse launch()' durante l'esecuzione di un file audio ‎[6 964 byte]
  276. (cron) ‎Estrarre informazioni e TAG da un file audio con le funzioni esterne del API di SndFile ‎[6 941 byte]
  277. (cron) ‎Creare file PNG con le funzioni esterne del API di Cairo ‎[6 938 byte]
  278. (cron) ‎Gambas3 & SubVersion ‎[6 924 byte]
  279. (cron) ‎Estrarre con le funzioni del API di libzip i file contenuti da un file compresso .zip ‎[6 922 byte]
  280. (cron) ‎Conoscere lo stato di un lettore CD con le funzioni del API di libcdio ‎[6 921 byte]
  281. (cron) ‎Estrarre informazioni generali da un file audio con le funzioni esterne del API di Libaudiofile ‎[6 916 byte]
  282. (cron) ‎Calcolare il bitrate di un file MP3 ‎[6 915 byte]
  283. (cron) ‎Ottenere dati grezzi di un file immagine mediante le funzioni del API di GDK-PixBuf ‎[6 887 byte]
  284. (cron) ‎Richiamare funzioni esterne di librerie scritte in C++ ‎[6 860 byte]
  285. (cron) ‎Eseguire un file mp3 usando l'API di Smpeg ‎[6 825 byte]
  286. (cron) ‎Ruotare qualsiasi elemento da disegnare in una DrawingArea ‎[6 821 byte]
  287. (cron) ‎Ruotare la mappa ‎[6 815 byte]
  288. (cron) ‎Ottenere il puntatore di una variabile di tipo Struttura ‎[6 800 byte]
  289. (cron) ‎Alsa e Gambas: Gestione dei dati Midi in Ricezione - Introduzione ‎[6 776 byte]
  290. (cron) ‎Impedire l'avvio di un programma.gambas già avviato ‎[6 770 byte]
  291. (cron) ‎Creare Menu da codice e non con l'Editor-Menu ‎[6 767 byte]
  292. (cron) ‎ALSA e Gambas: Esempio di semplice Commutatore Midi con Alsa ‎[6 750 byte]
  293. (cron) ‎Individuare il colore di un determinato pixel ‎[6 725 byte]
  294. (cron) ‎Segnalatore del puntatore del mouse sullo schermo usando le funzioni esterne del API di X11 ‎[6 704 byte]
  295. (cron) ‎Eseguire un file MIDI mediante il componente gb.sdl2.audio ‎[6 700 byte]
  296. (cron) ‎Individuare ed estrarre il PID di un programma ‎[6 671 byte]
  297. (cron) ‎Estrarre e salvare singole immagini durante l'esecuzione di un file video mediante il Componente gb.media ‎[6 656 byte]
  298. (cron) ‎Adattare la dimensione di un Oggetto grafico al testo contenuto ‎[6 636 byte]
  299. (cron) ‎Left..Right..Mid ‎[6 623 byte]
  300. (cron) ‎Ottenere il valore di un pixel in una DrawingArea ‎[6 601 byte]
  301. (cron) ‎Analizzare il valore RMS, il picco e il decay dei dati audio mediante gb.media ‎[6 599 byte]
  302. (cron) ‎Ioctl() ‎[6 596 byte]
  303. (cron) ‎Convertire una coordinata geografica dal sistema UTM al sistema EPSG:4326 WGS 84 e viceversa ‎[6 588 byte]
  304. (cron) ‎Modificare il volume generale mediante le funzioni esterne del API di PulseAudio ‎[6 557 byte]
  305. (cron) ‎Creare una finestra ed inserirvi del testo con le funzioni esterne di Libcaca ‎[6 529 byte]
  306. (cron) ‎Convertire la frequenza di campionamento di un file WAV con le funzioni esterne del API di SDL2 ‎[6 524 byte]
  307. (cron) ‎La gestione dei file audio mediante le funzioni esterne del API di Canberra ‎[6 516 byte]
  308. (cron) ‎Modificare la dimensione di un Oggetto grafico con il mouse impostando i punti di contatto intorno al suo perimetro ‎[6 496 byte]
  309. (cron) ‎Eseguire un file MIDI mediante il componente gb.openal ‎[6 479 byte]
  310. (cron) ‎Conoscere la dimensione di un file ‎[6 463 byte]
  311. (cron) ‎Ottenere alcune informazioni sulla CPU mediante l'API di Libcpuid ‎[6 452 byte]
  312. (cron) ‎Codificare e decodificare un flusso audio Opus mediante la libreria Libopus ‎[6 445 byte]
  313. (cron) ‎Simulare il tasto premuto del mouse usando le funzioni esterne del API di X11 ‎[6 442 byte]
  314. (cron) ‎Mostrare un'immagine con funzioni del API di GStreamer ‎[6 441 byte]
  315. (cron) ‎Application ‎[6 428 byte]
  316. (cron) ‎Eseguire un file audio usando l'API di SndFile e di Alsa ‎[6 421 byte]
  317. (cron) ‎Individuare le stampanti presenti nel proprio sistema ‎[6 412 byte]
  318. (cron) ‎Stat () ‎[6 400 byte]
  319. (cron) ‎Gestire numeri superiori al limite massimo supportato dal tipo Long ‎[6 386 byte]
  320. (cron) ‎Modificare il colore di sfondo di un'immagine GIF con le funzioni del API di GifLib ‎[6 386 byte]
  321. (cron) ‎Estrarre i TAG ID3v1 e ID3v2 dai file MP3 con le funzioni esterne del API di libmpg123 ‎[6 362 byte]
  322. (cron) ‎Estrarre informazioni e TAG da file audio con le funzioni esterne del API di Libtag c ‎[6 360 byte]
  323. (cron) ‎Creare un file PDF con le funzioni esterne della libreria PDFGen ‎[6 354 byte]
  324. (cron) ‎Creare file SVG con le funzioni esterne del API di Cairo ‎[6 338 byte]
  325. (cron) ‎La classe Action ‎[6 311 byte]
  326. (cron) ‎Configurazione, organizzazione ed impostazione dell'oggetto Image secondo i sorgenti di Gambas ‎[6 302 byte]
  327. (cron) ‎Creare una finestra e disegnarvi una scacchiera con le funzioni del API di SDL2 ‎[6 302 byte]
  328. (cron) ‎Trasmissione di dati fra due o più programmi Gambas mediante la Classe Socket del Componente gb.net ‎[6 260 byte]
  329. (cron) ‎Creare un file PDF con le funzioni esterne del API di Cairo ‎[6 250 byte]
  330. (cron) ‎Estrarre informazioni e TAG da un file MP3 con le funzioni esterne del API di Avbin ‎[6 226 byte]
  331. (cron) ‎Estrarre e salvare una porzione di dati da un file audio mediante il Componente gb.media ‎[6 219 byte]
  332. (cron) ‎Estrarre informazioni da un file OggVorbis con le funzioni esterne del API di Vorbisfile ‎[6 198 byte]
  333. (cron) ‎ALSA e Gambas: Esempio di semplice Client Midi di Alsa in ricezione ed invio dati ‎[6 179 byte]
  334. (cron) ‎Assegnare da codice più oggetti ad un Gruppo di eventi ‎[6 130 byte]
  335. (cron) ‎ALSA e Gambas: Un programma con due Client e due porte diverse ‎[6 117 byte]
  336. (cron) ‎Emulare in Gambas le macro IOC, IOR, IOW e IOWR usate con la funzione ioctl() ‎[6 103 byte]
  337. (cron) ‎Creare un file immagine da dati immagine grezzi mediante le funzioni del API di Imlib2 ‎[6 091 byte]
  338. (cron) ‎Ruotare un quadrato ed un rettangolo in una DrawingArea ‎[6 086 byte]
  339. (cron) ‎Realloc () ‎[6 076 byte]
  340. (cron) ‎Inviare il testo, colorato e ruotato, in un Terminale con l'API di libcaca ‎[6 075 byte]
  341. (cron) ‎"Dal testo al parlato" mediante le funzioni esterne del API di Speech-Dispatcher ‎[6 053 byte]
  342. (cron) ‎Leggere un file di testo ‎[6 027 byte]
  343. (cron) ‎Inizializzazione di GStreamer ‎[6 023 byte]
  344. (cron) ‎Disegnare un Button contenente un'icona e un testo mediante la DrawingArea ‎[6 012 byte]
  345. (cron) ‎Ottenere mediante le funzioni esterne della libreria Libudev un elenco degli oggetti hidraw collegati al sistema ‎[5 998 byte]
  346. (cron) ‎Rendere vettore una variabile inizialmente di tipo Oggetto ‎[5 994 byte]
  347. (cron) ‎Convertire un file OggVorbis in WAV con le funzioni esterne del API di Libvorbisidec ‎[5 963 byte]
  348. (cron) ‎Scanf() ‎[5 944 byte]
  349. (cron) ‎Ottenere informazioni generali sull'audio e sul video con le funzioni esterne del API di Libquicktime ‎[5 932 byte]
  350. (cron) ‎Estrarre da un file sf2 i dati audio di ciascun suono campionato e creare un file wav ‎[5 918 byte]
  351. (cron) ‎Calcolare la potenza di picco e di ampiezza di un file WAV con le funzioni esterne del API di Libaudiofile ‎[5 908 byte]
  352. (cron) ‎Eseguire un file WAVE mediante le funzioni della libreria libopenal ‎[5 901 byte]
  353. (cron) ‎Convertire un file video in un formato OGG, Matroska e MP4 mediante il Componente gb.media ‎[5 894 byte]
  354. (cron) ‎IF...THEN...ELSE...ENDIF ‎[5 880 byte]
  355. (cron) ‎Acquisire il codice HTML di una pagina web ‎[5 868 byte]
  356. (cron) ‎Convertire un file immagine SVG in un file immagine di altro formato con le funzioni esterne delle librerie librsvg e libgdk pixbuf ‎[5 863 byte]
  357. (cron) ‎Catturare e riprodurre immagini video mediante una WebCam con le funzioni esterne delle API di VLC ‎[5 863 byte]
  358. (cron) ‎Uso della classe Clipboard ‎[5 828 byte]
  359. (cron) ‎Fread () ‎[5 782 byte]
  360. (cron) ‎Scrivere una libreria esterna contenente una Funzione di Callback che chiama una Funzione Callback in Gambas ‎[5 778 byte]
  361. (cron) ‎Guida ai report ‎[5 776 byte]
  362. (cron) ‎Inviare dati stringa da un programma Gambas a un programma esterno avente un'area di testo o a un Terminale ‎[5 760 byte]
  363. (cron) ‎Creare Menu popup utilizzando l'Editor di menu ‎[5 733 byte]
  364. (cron) ‎Eseguire un file MIDI mediante il codice html ‎[5 730 byte]
  365. (cron) ‎Individuare i colori dei pixel di una immagine ‎[5 718 byte]
  366. (cron) ‎Inserire un'immagine come marcatore di coordinate su una MapView ‎[5 706 byte]
  367. (cron) ‎Creare un file immagine GIF con sfondo colorato mediante le funzioni del API di GIFLIB ‎[5 698 byte]
  368. (cron) ‎Copie di variabili array ‎[5 681 byte]
  369. (cron) ‎Inserire un'immagine all'interno di un'altra immagine mediante le funzioni esterne del API di Libgdk pixbuf ‎[5 679 byte]
  370. (cron) ‎Ottenere la durata di un file audio con le funzioni esterne del API di VLC ‎[5 675 byte]
  371. (cron) ‎Ottenere la durata di un file Midi con le funzioni esterne del API di VLC ‎[5 671 byte]
  372. (cron) ‎Scrivere in un file i dati presenti in un vettore di tipo Byte ‎[5 661 byte]
  373. (cron) ‎Creare un Client di Jack con le funzioni esterne del API di libJack e GStreamer ‎[5 657 byte]
  374. (cron) ‎Utilizzare il metodo 'System.GetExternSymbol()' per richiamare funzioni esterne di librerie condivise ‎[5 654 byte]
  375. (cron) ‎GUI ‎[5 652 byte]
  376. (cron) ‎Visualizzare il tempo trascorso dall'ultimo avvio del sistema ‎[5 650 byte]
  377. (cron) ‎Utilizzare una MediaView con gb.map anziché una MapView ‎[5 642 byte]
  378. (cron) ‎Ottenere la durata di un file video con le funzioni esterne del API di VLC ‎[5 641 byte]
  379. (cron) ‎Eseguire un file WAVE mediante le funzioni di OpenAL Utility Toolkit ‎[5 629 byte]
  380. (cron) ‎Agire sulla finestra di un qualunque programma ‎[5 620 byte]
  381. (cron) ‎Fork () ‎[5 615 byte]
  382. (cron) ‎Mostrare in tempo reale i decibel dell'audio catturato con le funzioni esterne del API di ALSA ‎[5 614 byte]
  383. (cron) ‎Conoscere con le funzioni esterne di TSE3 le porte Midi disponibili nel sistema ‎[5 612 byte]
  384. (cron) ‎La gestione dei file MIDI mediante le funzioni esterne del API di SDL 2 ‎[5 580 byte]
  385. (cron) ‎Ottenere alcune informazioni generali sui file ‎[5 576 byte]
  386. (cron) ‎Conoscere la dimensione del Dispositivo a blocchi ‎[5 575 byte]
  387. (cron) ‎Eseguire un file MIDI mediante le funzioni esterne del API di Fluidsynth ‎[5 564 byte]
  388. (cron) ‎Inserire del testo su una MapView ‎[5 559 byte]
  389. (cron) ‎Il linguaggio Gambas ‎[5 547 byte]
  390. (cron) ‎Intercettare dati Midi grezzi con le funzioni esterne del API di RtMidi ‎[5 535 byte]
  391. (cron) ‎Usare la ScrollArea ‎[5 517 byte]
  392. (cron) ‎Lettura dati da un Processo e scrittura dati in un Processo mediante Process ‎[5 512 byte]
  393. (cron) ‎INHERITS ‎[5 510 byte]
  394. (cron) ‎Estrarre una traccia di un CD audio convertendola in un file WAV con il Componente gb.media ‎[5 501 byte]
  395. (cron) ‎Eseguire un file WAV mediante le funzioni esterne del API di libaudio e di Alsa ‎[5 498 byte]
  396. (cron) ‎Convertire un file audio da un formato audio in un altro con le funzioni esterne del API di Sox ‎[5 497 byte]
  397. (cron) ‎Georeferenziare una mappa ‎[5 483 byte]
  398. (cron) ‎Ottenere alcune informazioni sul file immagine con le funzioni del API di GTK+3 e GDK-PixBuf ‎[5 465 byte]
  399. (cron) ‎Ottenere un file audio da un file Midi con le funzioni esterne del API di VLC ‎[5 458 byte]
  400. (cron) ‎ALSA e Gambas - L'accodamento degli eventi ‎[5 427 byte]
  401. (cron) ‎Spostare con il mouse un triangolo in una DrawingArea ‎[5 425 byte]
  402. (cron) ‎Eseguire un file audio mediante il codice html ‎[5 419 byte]
  403. (cron) ‎Ottenere alcune informazioni su un file immagine PNG con le funzioni del API di libpng ‎[5 411 byte]
  404. (cron) ‎Convertire i formati immagine mediante il Componente gb.media ‎[5 395 byte]
  405. (cron) ‎Gestire un oggetto Image agendo direttamente sulle risorse dei sorgenti Gambas ‎[5 395 byte]
  406. (cron) ‎Conoscere la data di accesso e di modifica di un file con le funzioni esterne del API di libgio-2.0 ‎[5 377 byte]
  407. (cron) ‎Aggiungere schede in una TabStrip successivamente alla sua creazione ‎[5 367 byte]
  408. (cron) ‎Registrare il sonoro e salvarlo in un file audio con le funzioni esterne del API di VLC ‎[5 350 byte]
  409. (cron) ‎Creare una GIF animata con le funzioni esterne del API di Libplot ‎[5 345 byte]
  410. (cron) ‎Array multidimensionali con numero determinato di elementi ‎[5 344 byte]
  411. (cron) ‎Scrivere una libreria esterna che chiama una funzione esterna puntata ‎[5 335 byte]
  412. (cron) ‎Ottenere mediante le funzioni esterne del API di Libusb la lista di tutti i dispositivi USB attivi nel sistema ‎[5 327 byte]
  413. (cron) ‎Struttura del formato BMP ‎[5 320 byte]
  414. (cron) ‎Ottenere mediante le funzioni esterne del API di Libgusb la lista di tutti i dispositivi USB attivi nel sistema ‎[5 303 byte]
  415. (cron) ‎Ruotare un'immagine sul proprio asse centrale in una DrawingArea ‎[5 299 byte]
  416. (cron) ‎Creare array di oggetti ‎[5 288 byte]
  417. (cron) ‎Salvare in un file video con il Componente gb.media quanto mostrato sullo schermo ‎[5 286 byte]
  418. (cron) ‎Conoscere in tempo reale con "proc...fdinfo" la quantità dei dati elaborati di un file audio ‎[5 267 byte]
  419. (cron) ‎Usare la ScrollView ‎[5 261 byte]
  420. (cron) ‎Suddividere in due o più parti coerenti e funzionali un file audio mp3 ‎[5 257 byte]
  421. (cron) ‎Leggere le informazioni di una Image dalle sue risorse dei sorgenti di Gambas ‎[5 255 byte]
  422. (cron) ‎Curvare il testo in una DrawingArea ‎[5 241 byte]
  423. (cron) ‎Eseguire un file WAV mediante le funzioni esterne del API di PulseAudio ‎[5 238 byte]
  424. (cron) ‎Proprietà particolari degli oggetti ‎[5 236 byte]
  425. (cron) ‎Fondere insieme un file video ed un file audio mediante le funzioni esterne del API di VLC ‎[5 226 byte]
  426. (cron) ‎Usare uno pseudoterminale per far comunicare bidirezionalmente due programmi ‎[5 225 byte]
  427. (cron) ‎Leggere un valore generato da un codice HTML/JavaScript ‎[5 214 byte]
  428. (cron) ‎Conoscere caratteristiche generali dei file ‎[5 211 byte]
  429. (cron) ‎Estrarre con le funzioni esterne del API di VLC l'audio di un file video e salvarlo in un file audio ‎[5 194 byte]
  430. (cron) ‎Scrivere un file di testo ‎[5 192 byte]
  431. (cron) ‎Salvare in un file OGV una ripresa video mediante una WebCam con il Componente gb.media ‎[5 177 byte]
  432. (cron) ‎Proprietà ReadOnly dell'Array (proprietà di sola lettura) ‎[5 168 byte]
  433. (cron) ‎Conoscere le coordinate correnti del mouse sullo schermo ‎[5 161 byte]
  434. (cron) ‎Ruotare un'immagine mediante le funzioni esterne del API di ImageMagick ‎[5 153 byte]
  435. (cron) ‎Disegnare in una DrawingArea l'intersezione perpendicolare di due linee ‎[5 152 byte]
  436. (cron) ‎Codice essenziale per mostrare un file PDF con le risorse del Componente gb.poppler ‎[5 141 byte]
  437. (cron) ‎Scrivere nello Standard Input di un Terminale con un programma Gambas 'a riga di comando' ‎[5 139 byte]
  438. (cron) ‎Individuare i valori RGBA dei pixel di una immagine ‎[5 137 byte]
  439. (cron) ‎Estrarre da un file MP3 i soli dati audio grezzi mediante la libreria libmpeg3 ‎[5 136 byte]
  440. (cron) ‎Conoscere con le funzioni esterne di RtMidi le porte Midi disponibili nel sistema ‎[5 097 byte]
  441. (cron) ‎Calcolare i beat per minuto (BpM) di un file audio con le funzioni esterne del API di Libaubio ‎[5 095 byte]
  442. (cron) ‎Eseguire un file audio usando una linea di pipeline con la funzione 'gst parse launch()' ‎[5 093 byte]
  443. (cron) ‎Drag-Drop di un testo in una DrawingArea ‎[5 092 byte]
  444. (cron) ‎Usare due programmi Gambas contemporaneamente mediante Process, lo standard Output e lo standard Input ‎[5 090 byte]
  445. (cron) ‎Variabili di tipo Puntatore e loro dereferenziazione ‎[5 075 byte]
  446. (cron) ‎Ruotare e ribaltare sul proprio asse una immagine con le funzioni del API di FreeImage ‎[5 074 byte]
  447. (cron) ‎Ottenere un file audio da un file video con le funzioni esterne del API di VLC ‎[5 069 byte]
  448. (cron) ‎Ottenere informazioni sugli schermi disponibili mediante le funzioni del API di X11 ‎[5 062 byte]
  449. (cron) ‎Alsa e Gambas: Ottenere informazioni da ALSA ‎[5 050 byte]
  450. (cron) ‎Eliminare la traccia audio da un file video con le funzioni esterne del API di VLC ‎[5 045 byte]
  451. (cron) ‎Printf () ‎[5 045 byte]
  452. (cron) ‎Gestione dei dati media creando una libreria .so personalizzata con le funzioni esterne del API di GStreamer ‎[5 005 byte]
  453. (cron) ‎Distruggere i Controlli grafici posti in un Contenitore ‎[5 001 byte]
  454. (cron) ‎Eseguire un file audio mediante le funzioni esterne del API di Alsa e SndFile ‎[5 000 byte]
  455. (cron) ‎Mmap () ‎[4 992 byte]
  456. (cron) ‎Usare il Metodo .AddPolygon di gb.map ‎[4 971 byte]
  457. (cron) ‎Ottenere la frequenza corrispondente ad una nota Midi e viceversa ‎[4 964 byte]
  458. (cron) ‎Cancellare una immagine in una PictureBox o in una ImageView ‎[4 944 byte]
  459. (cron) ‎Duplicare il flusso dei dati audio di una pipeline della Classe ''MediaPipeline'' del componente gb.media ‎[4 937 byte]
  460. (cron) ‎Visualizzare la forma d'onda di un file WAV ‎[4 932 byte]
  461. (cron) ‎Ottenere una schermata (screenshot) del desktop con le risorse del API di X11 e di Imlib2 ‎[4 900 byte]
  462. (cron) ‎ALSA e Gambas - Registrare messaggi Midi ‎[4 896 byte]
  463. (cron) ‎Ottenere Metadati Exif da un'immagine JPEG con le risorse del API di libexif ‎[4 880 byte]
  464. (cron) ‎Exit () - exit () ‎[4 857 byte]
  465. (cron) ‎Dereferenziare un Puntatore con un vettore ‎[4 857 byte]
  466. (cron) ‎Inserire un ulteriore testo in una GridView sempre nell'ultima riga ‎[4 856 byte]
  467. (cron) ‎Porre a zero i valori contenuti dall'area di memoria puntata da un Puntatore ‎[4 849 byte]
  468. (cron) ‎Disegnare un misuratore analogico su una DrawingArea ‎[4 835 byte]
  469. (cron) ‎GridBox ‎[4 832 byte]
  470. (cron) ‎Creare un file Midi con le funzioni esterne del API di Libsmf ‎[4 819 byte]
  471. (cron) ‎Utilizzare un Componente obsoleto ‎[4 802 byte]
  472. (cron) ‎Individuare le frequenze presenti in un'onda audio con le funzioni esterne della libreria Libaubio ‎[4 798 byte]
  473. (cron) ‎Estrarre da un file WAV i dati audio grezzi mediante le sole risorse di Gambas ‎[4 792 byte]
  474. (cron) ‎Estrarre immagini da un file PDF con le risorse del API di libpoppler-glib e di libcairo ‎[4 779 byte]
  475. (cron) ‎Creare un file immagine trasparente di tipo GIF con le funzioni del API di GIFLIB ‎[4 779 byte]
  476. (cron) ‎Modificare i colori dei pixel di un'immagine con la proprietà .Data della Classe Image ed i Memory Stream ‎[4 776 byte]
  477. (cron) ‎ALSA e Gambas: Creare 16 Client ciascuno avente 16 porte in Uscita e 16 porte in Entrata ‎[4 774 byte]
  478. (cron) ‎Ottenere un file Midi da un file XMI con le funzioni esterne del API di WildMidi ‎[4 743 byte]
  479. (cron) ‎Cercare una parola in una stringa ‎[4 737 byte]
  480. (cron) ‎Ottenere la rappresentazione come stringa in memoria di un valore numerico ‎[4 727 byte]
  481. (cron) ‎La gestione dei file MIDI mediante le funzioni esterne del API di SDL ‎[4 727 byte]
  482. (cron) ‎Ridimensionare la larghezza della finestra a cascata di un ComboBox in base alla lunghezza testuale di un elemento della lista ‎[4 719 byte]
  483. (cron) ‎Eseguire un file audio ed estrarne informazioni mediante le funzioni esterne del API di libcsfml ‎[4 700 byte]
  484. (cron) ‎Ottenere un file RTF da un file UTF8 e viceversa con le funzioni esterne del API di Librtfcomp ‎[4 699 byte]
  485. (cron) ‎Caricare i dati di un vettore scritto in C in un vettore di un'applicazione Gambas ‎[4 698 byte]
  486. (cron) ‎Ruotare una immagine sul proprio asse centrale ‎[4 690 byte]
  487. (cron) ‎Convertire un'immagine a colori in un'immagine a scala di grigi mediante le funzioni esterne del API di Libgdk pixbuf ‎[4 682 byte]
  488. (cron) ‎Copiare uno o più caratteri di un testo da una Label o da una TextLabel e incollarli in un altro Controllo di testo ‎[4 681 byte]
  489. (cron) ‎Registrare una sorgente sonora esterna le funzioni esterne del API di Sndio ‎[4 672 byte]
  490. (cron) ‎Creare con i Memory Stream un'area di memoria simile ad una Struttura avente come membro un'altra Struttura ‎[4 656 byte]
  491. (cron) ‎Estrarre il file thumbnail contenuto nel file odt ‎[4 651 byte]
  492. (cron) ‎Eseguire una traccia di un CD-Audio con le risorse del API di libvlc ‎[4 649 byte]
  493. (cron) ‎Fgets () ‎[4 646 byte]
  494. (cron) ‎Assegnare ad un Puntatore un'area di memoria riservata con Alloc() ‎[4 646 byte]
  495. (cron) ‎Ottenere i "reali" valori numerici da una lettura di tipo Stringa di un flusso di dati ‎[4 612 byte]
  496. (cron) ‎Emulare in Gambas la funzione memcpy() di C ‎[4 610 byte]
  497. (cron) ‎Chmod ‎[4 609 byte]
  498. (cron) ‎Convertire un file audio da un formato in formato .wav con le funzioni esterne del API di Allegro 5 ‎[4 607 byte]
  499. (cron) ‎WAIT ‎[4 604 byte]
  500. (cron) ‎Uso della classe DesktopWatcher ‎[4 574 byte]

Vedi (precedenti 500 | successivi 500) (20 | 50 | 100 | 250 | 500).

Estratto da "https://www.gambas-it.org/wiki/index.php/Speciale:PaginePiùLunghe"