[superciuck]

Ciao a tutti.
Sono proprio a digiuno di tutto quello nominato nel titolo.
Comunque sono riuscito ad iniziare un piccolo soft che simula un semaforo.
Ho un paio di problemi da sottoporvi.
Primo- Perchè non riesco ad usare i colori nel formato classico (esempio #FFF5E006) ma devo
usare questo sistema: (solo due righe per capire)

Codice:

private SolidColorBrush giallo_acceso = new SolidColorBrush(Windows.UI.Colors.Yellow);
private SolidColorBrush arancio_fissa = new SolidColorBrush(Windows.UI.Colors.OrangeRed);
....
....
LuceGiallo1.Fill = giallo_acceso;
Button_Modo_Fase_1.Background = arancio_fissa;

Così, ad esempio, invece non funziona

Codice:

LuceGiallo1.Fill = #FFF58006;

Secondo - Vorrei che all'avvio non apparisse quella che ora è la MainPage.xaml
Ma vorrei per prima una pagina che stia aperta per tot secondi con due righe di presentazione, e poi la MainPage.

Quello che fino ad ora sono riuscito a fare (una pagina con le lanterne che lampeggiano, un pin della GPIO che accende e spegne un led, alcuni pulsanti che cambiano i colori e alcune variabili, etc etc) sono riuscito prendendo esempi qua e la.
Vi dico questo perchè se potesse inviarmi due righe di esempio riguardo i problemi sopracitati sarebbe il modo migliore per me per poter capire.
Grazie 1000
Salutoni a tutti.

[gigios]

Primo- Perchè non riesco ad usare i colori nel formato classico (esempio #FFF5E006) ma devo
usare questo sistema: (solo due righe per capire)
...
Così, ad esempio, invece non funziona

Codice:

LuceGiallo1.Fill = #FFF58006;

Secondo - Vorrei che all'avvio non apparisse quella che ora è la MainPage.xaml
Ma vorrei per prima una pagina che stia aperta per tot secondi con due righe di presentazione, e poi la MainPage.

Premetto che non ho ancora provato W10 IoT, quindi la risposta che vedrai è legata alla mia esperienza di programmazione in ambiente Windows

Primo: Il problema è che il colore nella forma '#FFF58006' è una stringa, quindi il compilatore non sa come interpretarla e di conseguenza devi essere tu a spiegarglielo. Ci sono sostanzialmente due modi per far questo.

Codice:

LuceGiallo1.Fill = new SolidColorBrush(Color.FromArgb(0xFF, 0xF5, 0x80, 0x06));

In questo caso spezzi le singole componenti del colore nei suoi elementi (canale Alfa, più R/G/B).
La seconda si avvicina di più a quello da te chiesto:

Codice:

LuceGiallo1.Fill = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#FFF58006"));

In questo caso stiamo sfruttando un converter specializzato nella conversione dei colori (ColorConverter) partendo proprio dalla scritta da te menzionata.

Io ho lavorato con WPF (XAML) è queste operazioni solitamente le si fanno direttamente lato XAML e non nel codice, il tutto sfruttando il Binding che in WPF (ma credo anche in Win10 IoT) è molto potente. In quel caso allora puoi definire direttamente delle costanti nella sezione Resources della finestra e i colori possono essere definiti proprio nella forma #AARRGGBB

Codice:

       <Grid.Resources>
           <Color x:Key="Arancione">#FFF58006</Color>
           <SolidColorBrush x:Key="BrushArancione" Color="{StaticResource Arancione}" />
       </Grid.Resources>

       <Ellipse Width="40" Height="40" Fill="{StaticResource BrushArancione}" />
...
...

L'esempio sopra definisce le risorse di una griglia, il colore e relativo brush da poter poi usare nel codice xaml.
Subito sotto creo un'ellisse (cerchi) riempita del colore arancione definito sopra.
Tutto questo forse esula da quello che stai facendo tu e, non avendo visto ancora Win10 IoT, non so se ti può essere d'aiuto.

Secondo: Per il secondo punto non ti so aiutare molto, proprio perché non ho ancora avuto modo di provare/vedere Win10 IoT. In WPF ci sono vari metodi per farlo. Prima di tutto la finestra principale è definita in App.xaml (che non so se esiste in Win10 IoT), cambiando la pagina di start potresti poi, tramite un timer definito lato codice, chiudere la finestra 'start' e visualizzare la MainPage.xaml.
Questa seconda risposta prendila con le pinze

Edit: Ho provato ad aprire un esempio scaricato dal sito Microsoft (progetto HelloBlinky) e quello che posso capire (non posso eseguire nulla non avendo con me un Rasp e tanto meno una SD con Windows IoT) le varie pagine di visualizzazione sono gestite tramite il metodo Navigate usato in rootFrame (almeno nell'esempio). Praticamente dovresti aggiungere una nuova view al progetto e chiamarla tramite il metodo rootFrame.Navigate.
Esempio, ipotizzando che la nuova view la chiami SplashPage, il codice potrebbe essere il seguente:

Codice:

               rootFrame.Navigate(typeof(SplashPage), e.Arguments);
               System.Threading.Tasks.Task.Delay(500);
               rootFrame.Navigate(typeof(MainPage), e.Arguments);

Praticamente visualizza la pagina SplashPage e blocca l'esecuzione per 500 millisecondi, poi apre la MainPage.
Ovviamente questo è un esempio brutale  , il tutto andrebbe gestito correttamente (non ho idea di come debba essere la gestione delle pagine in IoT ).
Spero che tutto questo possa esserti d'aiuto, o almeno come punto di partenza per ulteriori invesigazioni.

Ciao
Luigi

[superciuck]

Letto veloce veloce.......
Già mi basta x un grande GRAZIE!!
Poi leggerò con calma, farò prove e ti faccio sapere.
Grazie ancora

[superciuck]

Bene ho fatto alcune prove.
Riguardo i colori grazie ai tuoi suggerimenti ora riesco ad usare qualsiasi colore,
ho solo dovuto un pò modificare quanto da te suggerito
questo funzica:

Codice:

private SolidColorBrush giallo_acceso = new SolidColorBrush(Color.FromArgb(0xFF, 0xFF, 0xF3, 0x00));

Riguardo invece l'apertura delle pagine ed il ritardo ho provato ma non va.
Ho creato una pagina SplashPageXaml.
Ho inserito nella AppXaml.cs, nella riga che apre la MainPage le tue instruzioni

Codice:

rootFrame.Navigate(typeof(SplashPage), e.Arguments);
System.Threading.Tasks.Task.Delay(6000);
rootFrame.Navigate(typeof(MainPage), e.Arguments);

Aumentato il tempo di delay

Ma si apre subito la MainPage.
Sotto metto tutto il code della AppXaml.cs

Codice:

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.ApplicationModel;
using Windows.ApplicationModel.Activation;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;

// The Blank Application template is documented at http://go.microsoft.com/fwlink/?LinkId=402347&clcid=0x409

namespace Test_0._0._1
{
   /// <summary>
   /// Provides application-specific behavior to supplement the default Application class.
   /// </summary>
   sealed partial class App : Application
   {

       /// <summary>
       /// Initializes the singleton application object.  This is the first line of authored code
       /// executed, and as such is the logical equivalent of main() or WinMain().
       /// </summary>
       public App()
     
       {
           InitializeComponent();
           Suspending += OnSuspending;
       }

       /// <summary>
       /// Invoked when the application is launched normally by the end user.  Other entry points
       /// will be used such as when the application is launched to open a specific file.
       /// </summary>
       /// <param name="e">Details about the launch request and process.</param>
       protected override void OnLaunched(LaunchActivatedEventArgs e)
       {

#if DEBUG
           if (System.Diagnostics.Debugger.IsAttached)
           {
               DebugSettings.EnableFrameRateCounter = true;
           }
#endif

           Frame rootFrame = Window.Current.Content as Frame;

           // Do not repeat app initialization when the Window already has content,
           // just ensure that the window is active
           if (rootFrame == null)
           {
               // Create a Frame to act as the navigation context and navigate to the first page
               rootFrame = new Frame();
               // Set the default language
               rootFrame.Language = Windows.Globalization.ApplicationLanguages.Languages[0];

               rootFrame.NavigationFailed += OnNavigationFailed;

               if (e.PreviousExecutionState == ApplicationExecutionState.Terminated)
               {
                   //TODO: Load state from previously suspended application
               }

               // Place the frame in the current Window
               Window.Current.Content = rootFrame;
           }

           if (rootFrame.Content == null)
           {
               // When the navigation stack isn't restored navigate to the first page,
               // configuring the new page by passing required information as a navigation
               // parameter
               rootFrame.Navigate(typeof(MainPage), e.Arguments);
           }
           // Ensure the current window is active
           Window.Current.Activate();
       }

       /// <summary>
       /// Invoked when Navigation to a certain page fails
       /// </summary>
       /// <param name="sender">The Frame which failed navigation</param>
       /// <param name="e">Details about the navigation failure</param>
       void OnNavigationFailed(object sender, NavigationFailedEventArgs e)
       {
           throw new Exception("Failed to load Page " + e.SourcePageType.FullName);
       }

       /// <summary>
       /// Invoked when application execution is being suspended.  Application state is saved
       /// without knowing whether the application will be terminated or resumed with the contents
       /// of memory still intact.
       /// </summary>
       /// <param name="sender">The source of the suspend request.</param>
       /// <param name="e">Details about the suspend request.</param>
       private void OnSuspending(object sender, SuspendingEventArgs e)
       {
           var deferral = e.SuspendingOperation.GetDeferral();
           //TODO: Save application state and stop any background activity
           deferral.Complete();
       }
   }
}

Sono davvero graditi altri suggerimenti
Grazie

[gigios]

Purtroppo, come ti accennavo, non ho modo di provare in quanto non ho Win10 IoT.
A breve dovrei (vorrei) prendere un altro Raspberry per 'giocare' con python (che non conosco) e per provare, appunto, Win10 IoT. Sino ad allora l'unico consiglio che posso darti è di cercare in internet se ci sono info su come gestire la navigazione tra più pagine.

Un dubbio che mi viene è che il Delay che ti ho fatto inserire non blocchi effettivamente l'esecuzione del codice.
Dovresti provare ad aggiungere un Timer, e solo allo scattare del suo evento Tick provare a navigare alla nuova pagina.

[superciuck]

Grazie.
Ho gia un tmer sulla Main Page.
Vedo se riesco a combinare qualcosa.