Inserisco il cd di xp, “Add Windows Components”, seleziono “Message Queuing” e faccio partire l’installazione..risultato:

“The Message Queuing service depends on the following nonexistent service: MSDTC!”

Inizio ad indagagare sul come risolvere il problema e trovo questo link!

Quindi eseguo “msdtc -install” e nella pagina dei servizi faccio partire il servizio Distributed Transaction Coordinator!
(Grazie Marco per l’aiuto =D )

Riprovo l’installazione ma ancora errore, sta volta però sembra un problema di configurazione.
Mi rimetto a cercare e trovo quest’altro link che spiega come impostare il MSDTC.

Per farlo basta andare su

Pannello di controllo -> Administrative Tools -> Component Service, espandere Component Service, poi Computers e selezionare le proprietà di My Computer. A questo punto selzionare la TAB MSDTC e cliccare su “Security Configuration”

Nel link di prima è indicato come impostare correttamente la security.. sarò onesto..avendone le palle piene io ho attivato qualsiasi cosa si potesse abilitare!!

Finalmente ho integrato un oggetto SL in una mia pagina, ne invoka un JS che visualizza una tastiera digitale e.. la tastiera appare sotto il mio SL :S

Dopo un momento di terrore (sì terrore, perchè sarei stato rovinato se non si fosse potuto far nulla ) ho trovato questo post!

alla fine è più banale di quanto pensassi..e mi son risparmiato diverse ore di lavoro

<asp:Silverlight ID="Xaml1" runat="server" Source="~/ClientBin/MySLPage.xap" MinimumVersion="2.0.30523" Width="100%" Height="100%" Windowless="true" />

Per farlo è sufficiente impostare un metodo sul onbeforeunload

<script language="javascript" type="text/javascript">
window.onbeforeunload = checkUnload;
</script>


e poi definire tale metodo (checkUnload).
function checkUnload()
{
if(IsDataChanged())
{
return ("There are unsaved changes in the page! Do you want to continue?");
}
}

Questo metodo ritorna(solo nel caso in cui i dati risultino modificati) la frase che, al momento della chiusura/aggiornamento del webbrowser, verrà proposta all’utente che dovrà scegliere se continuare o annullare!

Nel caso in cui invece i dati non siano stati modificati non ritornerà nulla e la navigazione continuerà normalmente.

Se ad esempio avessimo una classe

namespace PlayWithSTYLE.Item
{
public class Person
{
public string Name { get; set; }
public string SName { get; set; }
}
}

nel caso in cui faccia parte dello stesso Assembly dello xaml per poterla utilizzare si deve aggiungere il riferimento al Namespace

(local è il prefisso per il mapping del namespace PlayWithXMLNS.Oject.Item che ci permetterà di accedere alle classi).

A questo punto possiamo utilizzare la nostra classe:

e associarla a qualche controllo

Se si vuole invece far riferimento a un namespace di una dll esterna è necessario definire anche l’assembly (in questo caso l’assembly esterno si chiama EXTClass).

Così facendo però leghiamo il XAML anche al nome dell’assembly oltre che al namespace: per evitarlo, l’assembly esterno deve definire l’attributo System.Windows.Markup.XmlnsDefinition che permette di associare un xmlNameSpace al nostro clrNamespace.

[assembly: XmlnsDefinition("MyExtClass", "EXTClass.Object.Item")]

Così ora per far riferimento al namespace EXTClass.Object.Item dell’assembly esterno EXTClass è sufficiente:

Da notare però che questo attributo funziona solo tra assembly diversi per via dell’ordine di compilazione degli elementi come spiegato qui.

Oltre al/ai carattere/i separatore/i gli si può passare il parametro RemoveEmptyEntries (StringSplitOption) che causa l’eliminazione di tutti gli elementi “vuoti”.
string myList = "pippo,paperino,,pluto,franco";
string[] mySplittedList;
mySplittedList = myList.Split(
new char[]{','},
StringSplitOptions.RemoveEmptyEntries );


Ottenendo il risultato:

Quello che fino ad oggi non sapevo è che c’è anche un metodo che si occupa di ri-costruire la stringa partendo da un array

Questo è il metodo statico Join della classe String.

string newList = String.Join(",", mySplittedList);

Creiamo un’applicazione WPF e dividiamo la Grid base della window principale in due righe di uguale altezza:

nella prima riga metteremo il contenuto(una grid nominata myContainer) della nostra finestra (liste, bottoni e chi più ne ha ne metta) mentre nella seconda riga metteremo il pannello(myReflector) che riflette il contenuto di myContainer .

Ora aggiungiamo dei controlli a myContainer (una lista sulla sinistra e a destra una textbox e un bottone che aggiunge il testo della textbox nella lista) .

Ci aggiungiamo il codice per gli l’aggiunta del testo.
private void btnInsert_Click
(object sender, RoutedEventArgs e)
{
if (txtInsert.Text.Trim() != "")
{
lstBox.Items.Add(txtInsert.Text.Trim());
}
}


ottenendo così questo risultato

Ora non ci resta che far riflettere al pannello sotto (myReflector) il contenuto della griglia superiore(myContainer).

Per fare questo lo xaml mette a disposizione Il VisualBrush.
Questo controllo può essere utilizzato per visualizzare i suoi componenti figli in modo visuale (ma in tal caso questi perdono tutte le loro funzionalità) oppure per creare un’immagine dell’oggetto visual di destinazione (ovvero quello che vogliamo noi).

Quindi aggiungiamo come background del myReflector un visualBrush che punta al nostro myContainer.

ottenendo

MyReflector verrà aggiornato ad ogni modifica ottenendo così un riflesso in realtime. Essendo la copia dell’immagine fatta “pixel per pixel” il numero di controlli contenuti in myContainer non va a influire sulle prestazioni del VisualBrush (ovvero se ci sono 2 o 3 o n controlli.. visualbrush richiede sempre le stesse risorse )

Per concludere non ci resta che capovolgere il riflesso e sfumarlo

La rotazione si ottiene con:
ScaleTransform ScaleX="1" ScaleY="-1"
mentre con
RenderTransformOrigin="0.5, 0.5"
si imposta il di origine su cui viene calcolata la rotazione in modo che il pannello myReflector rimanga nella sua posizione originale invece che spostarsi a causa della rotazione.

Mentre la sfumatura (con la trasparenza che va in aumentando ) la si ottiene settando un LinearBrush come opacitymask del myReflector.

Riassumendo myReflector sarà così:

e questo il risultato finale:

Una cosa da notare è che il VisualBrush sposta l’immagine che visualizza in alto a sinistra. Il modo più semplice per risolvere il problema è impostare uno sfondo praticamente invisibile (background con visibilità 1%) del myContainer. In questo modo si evitano problemi inutili riguardo al posizionamento del riflesso. (Nel nostro caso questo problema non si pone perchè i controlli coprono completamente l’area).

Partiamo da un semplice enum

public enum eMyEnum
{
Val0=0,
Val1=1,
Val2=2
}

Supponiamo ora di volere associare ad ogni elemento di questo enum una descrizione e un colore.
Creiamo una classe che estende l’interfaccia System.Attribute e che contiene tutti i valori che vogliamo associare agli elementi del enum.

public class MyAttribute : System.Attribute
{
public MyAttribute(string description, string color)
{
_description=description;
_color = color;
}
private string _description;
public string Description
{
get { return _description; }
set { _description = value; }
}
private string _color;
public string Color
{
get { return _color; }
set { _color = value; }
}
}

Ora dobbiamo aggiungere gli attributi agli elementi del nostro enum.

public enum eMyEnum
{
[MyAttribute ("Questo è il valore 0","#FFAAFF")]
Val0=0,
[MyAttribute("Questo è il valore 1", "#FFAAAA")]
Val1=1,
[MyAttribute("Questo è il valore 2", "#AAAAAA")]
Val2=2
}

In questo modo ad ogni elemento dell’enum è associata un’istanza della classe MyAttribute contenente dei valori; non ci resta che recuperare questa istanza:

Importiamo prima di tutto il namespace System.Reflaction

using System.Reflection;

..e successivamente implementiamo il metodo che recupera gli attributi

public static MyAttribute GetAttribute(eMyEnum value)
{
try
{
Type t = typeof(eMyEnum);
FieldInfo fi = t.GetField(value.ToString());
MyAttribute[] att =
(MyAttribute[])fi.GetCustomAttributes(
typeof(MyAttribute),
false);
if (att.Length > 0)
{
return att[0];
}
else
{
return null;
}
}
catch (Exception ex)
{
return null;
}
}

Grazie alla reflection è possibile andare a recuperare tutti gli attributi associati alle property,campi ecc di un tipo. In questo caso mi faccio restituire tutti gli attributi del tipo MyAttribute e prendo il primo della lista (se c’è, altrimenti restituisco null)

Non ci resta che verificare che il tutto funzioni

public void Test()
{
eMyEnum myEnum = eMyEnum.Val1;
MyAttribute att = MyAttribute.GetAttribute(myEnum);
if (att != null)
{
MessageBox.Show(att.Description + " [ Color=" + att.Color + "];");
}
}


Ed ecco il risultato

Quanto mi piace la reflection!!

Quindi partendo da questo XAML

associato a questo codice per la gestione degli eventi

private void grdBlue_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
MessageBox.Show("Blue grid click");
}
private void grdRed_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
MessageBox.Show("Red grid click");
}

otteniamo che cliccando sul rettangolino rosso appare prima la messagebox con “Red grid click” e successivamente la messagebox con “Blue grid click”.

per evitare che scatti anche l’evento sulla grdBlue è sufficiente settare come gestite l’evento

private void grdRed_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
MessageBox.Show("Red grid click");
e.Handled = true;
}

In questo modo il routing dell’evento si fermerà alla grdRed.
(In realtà è sufficiente sottoscriversi ad un evento tramite il metodo void UIElement.AddHandler(RoutedEvent routedEvent, Delegate handler, bool handledEventsToo) passando handledEventsToo a true per intercettare mettodi già gestiti.
Metodo UIElement..::.AddHandler (RoutedEvent, Delegate, Boolean)
)

Se invece volessimo ottenere l’opposto, ovvero che venga ignorata la grdRed quando viene cliccata ci basterebbe settare la proprietà IsHitTestVisible=”False” nello XAML.

Cliccando sulla griglia rossa ora verrà lanciato solo l’evento della griglia padre (ovvero il click sulla grdBlue).

Un’altra cosa che si può fare è utilizzare un gestore per un evento di tutti i figli sfruttando gli eventi indirizzati(Routed Events)
Cenni preliminari sugli eventi indirizzati

Supponiamo il caso di avere una griglia con n bottoni al suo interno e di voler utlizzare lo stesso handler per tutti i bottoni.

Una soluzione potrebbe essere quella di sottoscrivere l’evento click bottone per bottone all’handler scrivendo però parecchio codice in più.
La soluzione migliore è quella di impostare il handler nel padre (nell’esempio sopra ButtonBase.Click=”grdBlue_btnClick”), in questo modo tutti i suoi figli usufruiranno di questa sottoscrizione.


private void grdBlue_btnClick(object sender, RoutedEventArgs e)
{
Button btn = (Button)e.OriginalSource ;
MessageBox.Show("Blue grid click: " + btn.Name);
}

Il sender dell’evento sarà la griglia che ha definito l’handler; mentre il button che ha lanciato l’evento è memorizzato in e.OriginalSource.