/// <summary>
/// Removes the pages below the current page is necessary, depending on the overlapping code
/// </summary>
/// <param name="overlapping">overlapping code</param>
private void SetOverlapping(byte overlapping)
{
// XHtmlDrawing drawing = Window.MainCanvas.Children.OfType<XHtmlDrawing>().FirstOrDefault();
switch (overlapping)
{
case 1: // effacement partiel
// on parcourt la liste des pages de la fenêtre et on efface les pages recouvertes totalement par la page en cours
foreach (XHtmlPage page in Window.ListOfPages.Where(page => page != this && page.JeSuisAffichee == true))
{
if (page.left >= left
&& page.top >= top
&& (page.left + page.OriginalWidth) <= (left + OriginalWidth)
&& (page.top + page.OriginalHeight) <= (top + OriginalHeight))
{
// On ne peut pas supprimer les Handlers sinon on ne les a plus lors d'un réaffichage de la page (ajoutés uniquement dans le constructeur)
//Window.MainCanvas.SizeChanged -= page.SizeChangedHandler;
//Window.MainCanvas.SizeChanged -= page.PositionChangedHandler;
// Window.MainCanvas.Children.Remove(page);
UnParametreEnvoye p = new UnParametreEnvoye();
Html.Envois.Ajouter("retirerPage", Html.CalculerIdPage(page.Id));
page.JeSuisAffichee = false;
////Effacement de la zone recouverte par la page dans Ygraph
//if (drawing != null)
// //drawing.ClearScreenArea(this);
// drawing.ClearScreenArea(new Rect(new Point(page.left, page.top), new Size(page.OriginalWidth, page.OriginalHeight)));
}
}
break;
case 2: // effacement complet
// on parcourt la liste des pages de la fenêtre et on efface toutes les pages trouvées
foreach (XHtmlPage page in Window.ListOfPages.Where(page => page != this && page.JeSuisAffichee == true))
{
// On ne peut pas supprimer les Handlers sinon on ne les a plus lors d'un réaffichage de la page (ajoutés uniquement dans le constructeur)
//Window.MainCanvas.SizeChanged -= page.SizeChangedHandler;
//Window.MainCanvas.SizeChanged -= page.PositionChangedHandler;
// Window.MainCanvas.Children.Remove(page);
Html.Envois.Ajouter("retirerPage", this.Html.CalculerIdPage(page.Id));
page.JeSuisAffichee = false;
}
////RAZ du canvas de dessin de Ygraph
//if (drawing != null) drawing.ClearDrawing();
// en effacement complet, la fenêtre prend la couleur de fond de la page
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! a faire !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// Window.SetBinding(BackgroundProperty, new Binding("Background") { Source = this, Mode = BindingMode.OneWay });
break;
case 3: // pas d'effacement
// on ne fait rien vu qu'on n'efface rien.
// en fait si : on met le fond à null (et vive la bidouille !!!) - "null" et non pas "transparent" car avec "transparent" le canvas trappe les clics quand même
// Style = Resources["PageTransStyle"] as Style;
break;
}
}
public void GetProperties(DVBuffer buffer)
{
string idPage; //stockage temporaire des id page, menuItem et toolbarItem
ProprietesWpf property;
XHtmlWindow window;
XHtmlPage page = null;
XHtmlDataGrid dataGrid;
ushort? index = null; //pour renvoi d'un index colonne dans un tableau
ushort? nbRows = null; //pour renvoi du nombre de lignes affichées dans un tableau
string horizontalScrollbarTooltip = null; //pour renvoi de la bulle de l'ascenseur horizontal dans un tableau
string verticalScrollbarTooltip = null; //pour renvoi de la bulle de l'ascenseur vertical dans un tableau
int codepageBulleAscHor = 0, codepageBulleAscVer = 0;
buffer.Get(out property);
while (property != ProprietesWpf.CLIENTLEGER_FIN)
{
switch (property)
{
case ProprietesWpf.CLIENTLEGER_DEBUT:
break;
case ProprietesWpf.MENU_SYSTEME_APERCU_ETAT:
byte printPreview;
buffer.Get(out printPreview);
IsPrintPreviewEnabled = (printPreview == 1);
// if (StackOfWindows.Any()) StackOfWindows.ToList()[0].UpdatePrintPreviewItem(IsPrintPreviewEnabled);
break;
case ProprietesWpf.MENU_SYSTEME_TRADUCTIONS:
buffer.GetString(out PrintPreviewText);
buffer.GetString(out CloseAllText);
buffer.GetString(out PrintCloseAllText);
buffer.GetString(out SavePrintPreviewText);
break;
case ProprietesWpf.COULEUR_CREATION_DEBUT:
XHtmlColor.Create(buffer,this.Html);
break;
case ProprietesWpf.POLICE_CREATION_DEBUT:
XHtmlFont.Create(buffer,this.Html);
break;
case ProprietesWpf.BORDURE_CREATION_DEBUT:
XHtmlBorder.Create(buffer,this.Html);
break;
case ProprietesWpf.PADDING_CREATION_DEBUT:
XHtmlPadding.Create(buffer,this.Html);
break;
#region Fenêtre
case ProprietesWpf.FENETRE_DEBUT: // Id Masque (ushort) et Id Page (byte)
// ne concerne que les "vraies" fenêtres (i.e. : les fenêtres autres que la toute première, ouverte dans app.xaml.cs)
//Window lastWindow = StackOfWindows.Peek();
//if (!lastWindow.IsVisible) lastWindow.Show();
//lastWindow.IsEnabled = false;
window = new XHtmlWindow(); // { Owner = lastWindow, ShowInTaskbar = false };
buffer.GetString(out window.MaskName);
buffer.Get(out window.PageNum);
window.ReadProperties(buffer);
window.Id = window.MaskName.Replace('.', '_') + "_" + window.PageNum.ToString() + "_" + (StackOfWindows.Count + 1).ToString();
StackOfWindows.Push(window);
ListeParametresComplementaires lc = new ListeParametresComplementaires();
lc.Ajouter("ty", window.minContentHeight.ToString());
lc.Ajouter("tx", window.minContentWidth.ToString());
lc.Ajouter("idFen", window.Id);
lc.Ajouter("libelle", window.MaskName);
lc.Ajouter("numpage", window.PageNum.ToString());
lc.Ajouter("tailleFixe", (window.ModeResize == System.Windows.ResizeMode.NoResize) ? "true" : "false");
lc.Ajouter("couleurFond", XHtmlColor.PrefixeCssFond + window.CouleurFond.ToString());
lc.Ajouter("titre", window.Title);
if (window.icon != null)
lc.Ajouter("icone", window.icon.Css);
string chaineFenetre = HtmlGlobal.ToJsonString(lc, this.Html.JsonParamCompl, false);
{
UnParametreEnvoye p = new UnParametreEnvoye();
p.commande = "ouvrirFenetre";
this.Html.Envois.commandes.Add(p);
p.valeur = chaineFenetre;
}
break;
case ProprietesWpf.FENETRE_TITRE: // Titre de la fenêtre (string)
{
string title;
int codePage;
buffer.Get(out codePage);
buffer.GetStringCP(out title, codePage);
StackOfWindows.Peek().Title = title;
UnParametreEnvoye p = new UnParametreEnvoye();
p.commande = "xmeTitle";
this.Html.Envois.commandes.Add(p);
p.valeur = title;
}
break;
case ProprietesWpf.FENETRE_ICONE: // Titre de la fenêtre (string)
var icon = new XHtmlImageFile();
icon.ReadProperties(buffer);
// StackOfWindows.Peek().SetIcon(icon);
break;
case ProprietesWpf.FENETRE_TAILLE_INITIALE: // Taille de référence pour les calculs d'attachement - Hauteur (ushort) x Largeur (ushort)
window = StackOfWindows.Peek();
buffer.GetString(out window.MaskName);
buffer.Get(out window.PageNum);
window.SetMinContentSize(buffer);
this.Html.Envois.Ajouter("fenetreTailleInitiale",
window.MaskName + "," +
window.PageNum.ToString() + "," +
window.minContentWidth.ToString() + "," +
window.minContentHeight.ToString()
);
break;
case ProprietesWpf.FENETRE_FERMETURE: // Pour fermer la fenêtre en cours
window = StackOfWindows.Pop();
this.Html.Envois.Ajouter("fermerFenetre", window.Id);
//FenetresADepiler.Push(window);
//window.Closing -= window.ClosingHandler;
//StackOfWindows.Peek().IsEnabled = true; // ne pas remplacer par "window": le StackOfWindow.Peek a changé de valeur à cause du pop() !
// window.Close();
break;
#endregion Fenêtre
case ProprietesWpf.PAGE_DEBUT:
buffer.GetString(out idPage); // Id Page (string)
window = StackOfWindows.Peek();
page = window.GetPage(idPage);
if (page == null)
{
window.ListOfPages.Add(page = new XHtmlPage(window,this.Html) { Id = idPage });
this.Html.Envois.Ajouter("nouvellePage", this.Html.CalculerIdPage(page.Id));
page.JeSuisAffichee = true;
}
// une page peut être supprimée (dans la gestion de l'effacement d'une autre page), il faut donc la remettre dans la fenêtre le cas échéant
//if (!window.MainCanvas.Children.Contains(page)) window.MainCanvas.Children.Add(page);
if (page.JeSuisAffichee == false)
{
this.Html.Envois.Ajouter("remettrePage", this.Html.CalculerIdPage(page.Id));
}
// cette ligne était plus bas, mais trop tard
this.Html.Envois.Ajouter("pageCourante", Html.CalculerIdPage(page.Id), page.StopPoint.ToString(), page.NumPage.ToString());
page.JeSuisAffichee = true;
// - lecture de la page et des objets
page.ReadProperties(buffer);
// je la remet aussi ici car avec les panels ca bouge !
this.Html.Envois.Ajouter("pageCourante", Html.CalculerIdPage(page.Id), page.StopPoint.ToString(), page.NumPage.ToString());
page.EnvoyerCouleurPositionAttachement(false);
// on affiche la fenêtre si c'est la toute première page et si la fenêtre n'est pas masquée (application sans fenêtre)
// !!!!!!!!!!if (!page.Window.IsVisible && application.Client.FenetreMereHide == 0)
// !!!!!!!!!! page.Window.Show();
break;
case ProprietesWpf.TABLEAU_DEBUT: // Mise à jour d'une propriété du tableau
dataGrid = GetDataGrid(buffer,out page);
dataGrid.ReadProperties(buffer);
dataGrid.AjouterEnvoisUnObjet(Html.Envois, page, Html.App.StackOfWindows.Count());
break;
case ProprietesWpf.TABLEAU_ASCHOR_A_GAUCHE: // retour au début de la ligne d'un tableau
dataGrid = GetDataGrid(buffer,out page);
// ScrollIntoView sur la colonne dont le DisplayIndex est = FrozenColumnCount pour mettre l'ascenseur à gauche.
// (en tenant compte des colonnes figées)
// attention : le tableau peut être vide, d'où le "if Rows.Count > 0"
var column = dataGrid.Columns.FirstOrDefault(col => col.DisplayIndex == dataGrid.FrozenColumnCount);
//!!!!!!!!!!if (dataGrid.Rows.Count > 0 && column != null)
//!!!!!!!!!! dataGrid.ScrollIntoView(dataGrid.Rows[0], column);
break;
case ProprietesWpf.TABLEAU_REMPLISSAGE_DEBUT: // Remplissage du tableau
dataGrid = GetDataGrid(buffer,out page);
dataGrid.Fill(buffer);
dataGrid.AjouterEnvoisUnObjetRemplissageTableau(Html.Envois, page, Html.App.StackOfWindows.Count());
break;
#region Fonctions Get du tableau
case ProprietesWpf.TABLEAU_ASCHOR_GET_BULLE: // Demande le texte de la bulle de l'ascenseur horizontal
dataGrid = GetDataGrid(buffer,out page);
horizontalScrollbarTooltip = dataGrid.HorizontalScrollBarToolTip;
codepageBulleAscHor = dataGrid.CodepageBulleAscHor;
break;
case ProprietesWpf.TABLEAU_ASCVER_GET_BULLE: // Demande le texte de la bulle de l'ascenseur vertical
dataGrid = GetDataGrid(buffer,out page);
verticalScrollbarTooltip = dataGrid.VerticalScrollBarToolTip;
codepageBulleAscVer = dataGrid.CodepageBulleAscVer;
break;
case ProprietesWpf.TABLEAU_GET_NOMBRE_LIGNES: // Demande du nombre de lignes affichables dans le tableau
{
string id = GetIdentDataGrid(buffer);
// dataGrid = GetDataGrid(buffer);
//!!!!!!!!!! dataGrid.UpdateLayout(); // indispensable, sinon le nombre de lignes envoyé au premier affichage du tableau est potentiellement faux (peut poser pb par la suite)
nbRows = 32; // dataGrid.GetRowCount();
Html.Envois.Ajouter("tabGetNbLig", id);
}
break;
case ProprietesWpf.TABLEAU_GET_COL_SAISIE_PREMIERE: // Demande le numéro de la première colonne en saisie dans la ligne donnée
dataGrid = GetDataGrid(buffer,out page);
index = dataGrid.GetFirstColumnIndex(buffer);
break;
case ProprietesWpf.TABLEAU_GET_COL_SAISIE_DERNIERE: // Demande le numéro de la dernière colonne en saisie dans la ligne donnée
dataGrid = GetDataGrid(buffer,out page);
index = dataGrid.GetLastColumnIndex(buffer);
break;
case ProprietesWpf.TABLEAU_GET_COL_SAISIE_PRECEDENTE: // Demande le numéro de la colonne précédente en saisie dans la ligne donnée
dataGrid = GetDataGrid(buffer,out page);
index = dataGrid.GetPreviousColumnIndex(buffer);
break;
case ProprietesWpf.TABLEAU_GET_COL_SAISIE_SUIVANTE: // Demande le numéro de la colonne suivante en saisie dans la ligne donnée
dataGrid = GetDataGrid(buffer,out page);
index = dataGrid.GetNextColumnIndex(buffer);
break;
#endregion Fonctions Get du tableau
#region Input
case ProprietesWpf.XMEINPUT:
AsynchronousResponse = null; // garde-fou
buffer.GetString(out idPage);
window = StackOfWindows.Peek();
window.CurrentPage = window.GetPage(idPage);
//!!!!!!!!!!!!!!!!!!!!!!! idem pour consult etc....
// this.Html.Envois.Ajouter("pageCourante", Html.CalculerIdPage(window.CurrentPage.Id), window.CurrentPage.StopPoint.ToString(), page.NumPage.ToString());
this.Html.Envois.Ajouter("pageCourante", Html.CalculerIdPage(window.CurrentPage.Id), window.CurrentPage.StopPoint.ToString(), window.CurrentPage.NumPage.ToString());
ReadInput(buffer, window.CurrentPage);
// busyTimer.Stop();
// window.Cursor = null;
AttenteInput = true; // nécessairement à la fin pour que le HeightChanging potentiellement
// envoyé lors du UpdateLayout() contenu dans le readInput soit pris en compte et envoyé en différé
break;
#endregion Input
case ProprietesWpf.XMECONSULT:
buffer.GetString(out idPage);
Consult(idPage, null);
Html.Envois.Ajouter("xmeConsult", idPage);
break;
#region List Consult
case ProprietesWpf.XMELISTCONSULT:
{
uint idDataGrid;
buffer.GetString(out idPage);
buffer.Get(out idDataGrid);
Consult(idPage, null);
Html.Envois.Ajouter("xmeConsult", idPage);
string id = Html.CalculerIdDataGrid(idDataGrid, idPage);
//dataGrid = Consult(idPage, idDataGrid) as XHtmlDataGrid;
//dataGrid.SetIsActive(true); // nécessairement APRES le ManageValidDataGrids() dans le consult car ce dernier RAZ toutes les DataGrids affichées
// traitement des ronds dans l'entête de la colonne arbre le cas échéant
byte treeCount;
buffer.Get(out treeCount);
if (treeCount > 0)
{
byte treeCurrent;
buffer.Get(out treeCurrent);
// XHtmlTreeColumn treeColumn = dataGrid.Columns.FirstOrDefault(col => ((IXHtmlDataGridColumn)col).ColumnType == ColumnType.Arbre) as XHtmlTreeColumn;
// if (treeColumn != null) treeColumn.SetCircles(treeCount, treeCurrent);
}
}
break;
#endregion List Consult
case (ProprietesWpf)161 :
// ClientLegerProprietes.PROPCLIENTLEGER_AFFICHEERREUR:
AfficherErreurTransmise(buffer);
break;
case ProprietesWpf.FENETRE_ATTACHER_TOOLBARS_DEBUT: // Bordel des toolbars
buffer.Get(out property);
while (property != ProprietesWpf.FENETRE_ATTACHER_TOOLBARS_FIN)
{
//switch (property)
{
//case ProprietesWpf.TOOLBAR_DEBUT: // Création de toolbar
// buffer.Get(out idToolBar);
// toolBar = GetXwpfToolBar(idToolBar);
// if (toolBar == null) listOfToolBars.Add(toolBar = new XwpfToolBar { Id = idToolBar });
// toolBar.ReadProperties(buffer);
// break;
//case ProprietesWpf.TOOLBAR_RECONSTRUCTION_DEBUT: // Reconstruction de toolbar
// buffer.Get(out idToolBar);
// toolBar = GetXwpfToolBar(idToolBar);
// if (toolBar == null) listOfToolBars.Add(toolBar = new XwpfToolBar { Id = idToolBar });
// toolBar.ItemsList.Clear();
// toolBar.ReadProperties(buffer);
// foreach (XwpfWindow windowFromStack in StackOfWindows)
// {
// ToolBarTray toolBarTray = (toolBar.Primary) ? windowFromStack.PrimaryToolBarTray : windowFromStack.SecondaryToolBarTray;
// ToolBar toolBarInList = toolBarTray.ToolBars.FirstOrDefault(tb => tb.DataContext == toolBar);
// if (toolBarInList != null) toolBar.Display(windowFromStack, toolBarInList);
// }
// break;
//case ProprietesWpf.FENETRE_ATTACHER_TOOLBAR: // Pour attacher une toolbar (identifiant menu: ushort)
// buffer.Get(out idToolBar);
// GetXwpfToolBar(idToolBar).Display(StackOfWindows.Peek());
// break;
//case ProprietesWpf.FENETRE_DETTACHER_TOOLBAR: // Pour supprimer une toolbar (identifiant menu: ushort)
// buffer.Get(out idToolBar);
// XwpfToolBar.Remove(idToolBar);
// break;
//default:
// throw new XwpfException(XwpfErrorCodes.UnknownProperty, XwpfErrorLocations.Application, property.ToString());
}
buffer.Get(out property);
}
break;
default:
throw new XHtmlException(XHtmlErrorCodes.UnknownProperty, XHtmlErrorLocations.Application, property.ToString());
}
buffer.Get(out property);
}
var response = new DVBuffer();
#region Réponse asynchrone
//if (AsynchronousResponse != null && AttenteInput) // impossible d'avoir un double-clic en input
// AsynchronousResponse = null;
//if (AsynchronousResponse != null && AttenteConsult)
//{
// SetInputBuffer(AsynchronousResponse);
// Send(AsynchronousResponse); // response déjà replie dans le Handler mais pas encore envoyée pour synchronisation
// AsynchronousResponse = null;
// responseAlreadySent = true; // Pour bloquer le Send(response) vide dans Analyse()
// return;
//}
#endregion Réponse asynchrone
#region Réponse asynchrone intertâche
//if (interTaskResponses.Count > 0) // si réveil intertâche en attente
//{
// if (AttenteInput) interTaskResponses.Clear(); // en input : r.à.z. de la liste des dialogues intertâches en attente
// else if (AttenteConsult || AttenteGetb)
// {
// SendInterTaskResponse();
// responseAlreadySent = true; // Pour bloquer le Send(response) vide dans Analyse()
// return;
// }
//}
#endregion Réponse asynchrone intertâche
#region nb lignes tableau
// positionne responseAlreadySend et c'est tout
if (nbRows.HasValue)
{
//response.Put(ProprietesWpf.CLIENTLEGER_DEBUT);
//response.Put(ProprietesWpf.TABLEAU_NOMBRE_LIGNES);
//response.Put(nbRows.Value);
//Send(response);
responseAlreadySent = true; // Pour bloquer le Emettre(response) vide dans Analyser()
return;
}
#endregion nb lignes tableau
#region index colonne tableau
if (index.HasValue)
{
response.Put(ProprietesWpf.CLIENTLEGER_DEBUT);
response.Put(ProprietesWpf.TABLEAU_COLONNE_SAISIE);
response.Put(index.Value);
Send(response);
responseAlreadySent = true; // Pour bloquer le Emettre(response) vide dans Analyser()
return;
}
#endregion index colonne tableau
#region bulle scrollbar horizontale tableau
if (horizontalScrollbarTooltip != null)
{
response.Put(ProprietesWpf.CLIENTLEGER_DEBUT);
response.Put(ProprietesWpf.TABLEAU_ASCHOR_BULLE);
response.PutStringCP(horizontalScrollbarTooltip, codepageBulleAscHor);
Send(response);
responseAlreadySent = true; // Pour bloquer le Emettre(response) vide dans Analyser()
return;
}
#endregion bulle scrollbar horizontale tableau
#region bulle scrollbar verticale tableau
if (verticalScrollbarTooltip != null)
{
response.Put(ProprietesWpf.CLIENTLEGER_DEBUT);
response.Put(ProprietesWpf.TABLEAU_ASCVER_BULLE);
response.PutStringCP(verticalScrollbarTooltip, codepageBulleAscVer);
Send(response);
responseAlreadySent = true; // Pour bloquer le Emettre(response) vide dans Analyser()
return;
}
#endregion bulle scrollbar verticale tableau
#region Retour Fonction YGraph (FA)
//retour normal (ident ou retour par defaut)
//if (yDrawingOperationRet.HasValue)
//{
// response.Put(ProprietesWpf.CLIENTLEGER_DEBUT);
// response.Put(yDrawingIsCreation ? yDrawingOperationRet.Value : (int)yDrawingOperationRet.Value); // pas de propriétéWPF identifiant la valeur de retour (14/09/2011)
// Send(response);
// responseAlreadySent = true; // Pour bloquer le Emettre(response) vide dans Analyser()
// return;
//}
////retour de la taille ecran
//if (yScreenSize.HasValue)
//{
// response.Put(ProprietesWpf.CLIENTLEGER_DEBUT);
// response.Put((int)yScreenSize.Value.Width); // pas de propriétéWPF identifiant la valeur de retour (21/09/2011)
// response.Put((int)yScreenSize.Value.Height);
// Send(response);
// responseAlreadySent = true; // Pour bloquer le Emettre(response) vide dans Analyser()
// return;
//}
#endregion //Retour Fonction YGraph (FA)
#region Paramètres Initiaux Agenda
//if (responseCalendarInit != null)
//{
// Send(responseCalendarInit);
// responseAlreadySent = true; // Pour bloquer le Emettre(response) vide dans Analyser()
//}
#endregion Paramètres Initiaux Agenda
}
/// <summary>
/// ajouter les commandes necessaires pour le client
/// </summary>
/// <param name="envois"></param>
/// <param name="page"></param>
/// <param name="niveau"></param>
public void AjouterEnvoisUnObjet(ListeParametresEnvoyes envois, XHtmlPage page, int niveau)
{
ListeParametresEnvoyes paramsValeurs = new ListeParametresEnvoyes();
paramsValeurs.Ajouter("idObjet", HtmlGlobal.CalculerId(this.Id, page.Id, niveau), this.Page.Html.CalculerIdPage(page.Id));
if (this.textHasValue)
paramsValeurs.Ajouter("texteLabel", this.text);
if (Presentation != null)
this.Presentation.GenererHtml(paramsValeurs,this.Page.Html,this.codePage,false);
UnParametreEnvoye p = new UnParametreEnvoye();
envois.Ajouter("creerObjet", "<P></P>", HtmlGlobal.CalculerId(this.Id, page.Id, niveau));
envois.Ajouter("propsObjet", HtmlGlobal.ToJsonString(paramsValeurs, this.Page.Html.JsonParamsEnvoyes, false));
envois.Ajouter("ajoutObjetCourant","");
///////////////////////////////////////// MORCEAU qui génére tout le code HTML : beaucoup plus rapide a l'exec
//////////////////////////////////////// on devrait faire comme ca pour les objets les plus utilisés (label champ)
/*
ListeParametresEnvoyes paramsValeurs = new ListeParametresEnvoyes();
string css = this.Presentation.GenererHtml(paramsValeurs);
css += "id='" + this.Id.ToString() + "'";
int i = 0;
UnParametreEnvoye p = new UnParametreEnvoye();
envois.commandes.Add(p);
p.commande = "html";
p.valeur = "<P " + css + ">" + this.text + "</P>";
p = new UnParametreEnvoye();
envois.commandes.Add(p);
p.commande = "script";
p.valeur = "AjouterObjet(codeHtml,bodyCourant);";
*/
//////////////////////////////////////////////////////////////
}
public void FaireLaListeDesEnvoisPourStyles()
{
if (Html.App.PolicesCss.Count > 0)
{
UnParametreEnvoye p = new UnParametreEnvoye();
p.commande = "cssAjouts";
Html.Envois.commandes.Insert(0, p);
p.valeur = "<style type='text/css'>\r\n";
foreach (XHtmlFont pol in Html.App.PolicesCss)
{
if (pol.Transmi == false)
{
pol.Transmi = true;
//if (pol.Vide == true)
// Html.App.ListeIdsPolicesVides.l.Add(pol.Id);
p.valeur += pol.Css + "\r\n";
}
}
foreach (XHtmlColor col in Html.App.CouleursCss)
{
if (col.Transmi == false)
{
col.Transmi = true;
//if (col.Vide == true)
// Html.App.ListeIdsCouleursVides.l.Add(col.Id);
//if (col.Transparente == true)
// Html.App.ListeIdsCouleursTransparentes.l.Add(col.Id);
p.valeur += col.Css + "\r\n";
}
}
foreach (XHtmlBorder bord in Html.App.BorduresCss)
{
if (bord.Transmi == false)
{
bord.Transmi = true;
//if (bord.Vide == true)
// Html.App.ListeIdsBorduresVides.l.Add(bord.Id);
p.valeur += bord.Css + "\r\n";
}
}
foreach (XHtmlPadding padd in Html.App.PaddingCss)
{
if (padd.Transmi == false)
{
padd.Transmi = true;
//if (padd.Vide == true)
// Html.App.ListeIdsPaddingsVides.l.Add(padd.Id);
p.valeur += padd.Css + "\r\n";
}
}
// - AJOUTER LES IMAGES POUR LES BOUTONS
foreach (XHtmlImageFile ima in Html.App.ImagesCss)
{
if (ima.Transmi == false)
{
ima.Transmi = true;
//if (padd.Vide == true)
// Html.App.ListeIdsPaddingsVides.l.Add(padd.Id);
p.valeur += ima.Css + "\r\n";
}
}
p.valeur += "</style>";
}
}
/// <summary>
/// ajouter les commandes necessaires pour le client
/// </summary>
/// <param name="envois"></param>
/// <param name="page"></param>
/// <param name="niveau"></param>
public void AjouterEnvoisUnObjet(ListeParametresEnvoyes envois, XHtmlPage page, int niveau)
{
ListeParametresEnvoyes paramsValeurs = new ListeParametresEnvoyes();
paramsValeurs.Ajouter("idObjet", HtmlGlobal.CalculerId(this.Id, page.Id, niveau), this.Page.Html.CalculerIdPage(page.Id));
if (this.LibelleGroupe != null)
paramsValeurs.Ajouter("texteGroupe", this.LibelleGroupe);
if (Presentation != null)
{
this.Presentation.GenererHtml(paramsValeurs, this.Page.Html, this.codePage,true);
UnParametreEnvoye pp = paramsValeurs.commandes.FirstOrDefault(c => c.commande == "css-fond");
if (pp != null)
pp.commande = "couleurTitreGroupe";
pp = paramsValeurs.commandes.FirstOrDefault(c => c.commande == "css-police");
if (pp != null)
pp.commande = "policeTitreGroupe";
pp = paramsValeurs.commandes.FirstOrDefault(c => c.commande == "css-padding");
if (pp != null)
pp.commande = "paddingTitreGroupe";
}
if (this.idFondGroupe.HasValue)
{
string ct = this.Page.Html.App.GenererUneValeurDeCouleur(this.idFondGroupe);
if (ct != null)
{
paramsValeurs.Ajouter("css-fond", ct);
}
}
UnParametreEnvoye p = new UnParametreEnvoye();
// envois.Ajouter("creerObjet", "<P></P>", HtmlGlobal.CalculerId(this.Id, page.Id, niveau));
envois.Ajouter("creerGroupBox", " ", HtmlGlobal.CalculerId(this.Id, page.Id, niveau));
envois.Ajouter("ajoutObjetCourant", "");
envois.Ajouter("propsObjet", HtmlGlobal.ToJsonString(paramsValeurs, this.Page.Html.JsonParamsEnvoyes, false));
}
//#region Ecouteurs
///// <summary>
///// Gestionnaire d'évènement "PreviewKeyDown" pour la fonction XMEInput
///// </summary>
//private static void PreviewKeyDownHandler(object sender, KeyEventArgs e)
//{
// var application = ((App)Application.Current).Appli;
// if (!application.AttenteInput) // cas impossible en théorie: un contrôle ne peut pas avoir le focus sans que l'on soit en Input
// {
// e.Handled = true;
// return;
// }
// if (e.Key == Key.Apps)
// {
// // TODO simuler un clic droit sur touche windows 2
// e.Handled = true;
// }
// string key;
// // Touches de fonction (Fn)
// if (e.Key == Key.System && e.SystemKey == Key.F10) key = "F10";
// else if (XHtmlApplication.FnKeys.Contains(e.Key)) key = e.Key.ToString();
// // Autres touches
// else // pas la peine de faire les tests spécifiques si une touche générique (Fn) a déjà été détetée
// {
// if (ValidKeys.Contains(e.Key) || (
// (Keyboard.Modifiers & ModifierKeys.Control) != 0
// && (Keyboard.Modifiers & ModifierKeys.Alt) == 0
// && ValidModifiedKeys.Contains(e.Key))
// )
// key = e.Key.ToString();
// else return; // les touches restantes ne sont pas bloquées
// }
// e.Handled = true;
// application.SendInputKeyDown(key);
//}
///// <summary>
///// Gestionnaire d'évènement "PreviewMouseDown"
///// </summary>
//private void PreviewMouseDownHandler(object sender, MouseButtonEventArgs e)
//{
// if (IsReadOnly) // si IsReadOnly, on ne notifie pas l'appli
// {
// e.Handled = true;
// return;
// }
// // on laisse passer les clics gauches (simples & doubles) en input (géré par wpf)
// if (Page.Window.ActiveControl == this && e.ChangedButton == MouseButton.Left) return;
// ((App)Application.Current).Appli.SendMouseDown(this, e);
//}
///// <summary>
///// Envoi des infos à l'appli pour ouverture de zoom
///// </summary>
//private void ZoomButtonClickHandler(object sender, RoutedEventArgs e)
//{
// e.Handled = true;
// var application = ((App)Application.Current).Appli;
// var response = new DVBuffer();
// response.Put(ProprietesWpf.CLIENTLEGER_DEBUT); //début de l'acquittement ou de la réponse
// application.SetInputBuffer(response);
// response.Put(ProprietesWpf.EVENEMENT_SOURIS_DEBUT); // Début de l'envoi des évenements souris
// response.Put(ProprietesWpf.SOURIS_TYPE_EVENEMENT); // Type d'évènement souris (byte)
// if (((App)Application.Current).Client.VersionInterneServeur <= 1)
// response.Put((byte)MouseEvent.ZoomCall);
// else
// response.Put((byte)(MouseEvent.ZoomComboCall));
// response.Put(ProprietesWpf.EVENEMENT_SOURIS_FIN); // Fin de l'envoi des évenements souris
// application.Send(response);
//}
//#endregion Ecouteurs
//// D & D non implémenté pour cause d'incompatibilité avec la gestion des mouseUp et MouseDown
//#region Drag & Drop
//public void PreviewMouseLeftButtonDownHandler(object sender, MouseEventArgs e)
//{
// if (e == null) throw new ArgumentNullException("e");
// startPoint = e.GetPosition(null);
//}
//public void PreviewMouseMoveHandler(object sender, MouseEventArgs e)
//{
// if (e == null) throw new ArgumentNullException("e");
// if (isDragging) return;
// if (e.LeftButton != MouseButtonState.Pressed) return;
// // on ne déclenche le drag&drop que si la souris a été suffisament déplacée
// Vector diff = startPoint - e.GetPosition(null);
// if (Math.Abs(diff.X) > SystemParameters.MinimumHorizontalDragDistance ||
// Math.Abs(diff.Y) > SystemParameters.MinimumVerticalDragDistance)
// {
// isDragging = true;
// DataObject data = new DataObject(DataFormats.UnicodeText, Text);
// DragDrop.DoDragDrop(this, data, DragDropEffects.All);
// isDragging = false;
// }
//}
//#endregion Drag & Drop
/// <summary>
/// ajouter les commandes necessaires pour le client
/// </summary>
/// <param name="envois"></param>
/// <param name="page"></param>
/// <param name="niveau"></param>
public void AjouterEnvoisUnObjet(ListeParametresEnvoyes envois, XHtmlPage page, int niveau)
{
ListeParametresEnvoyes paramsValeurs = new ListeParametresEnvoyes();
paramsValeurs.Ajouter("idObjet", HtmlGlobal.CalculerId(this.Id, page.Id, niveau), this.Page.Html.CalculerIdPage(page.Id));
if (IsReadOnly.HasValue)
paramsValeurs.Ajouter("lectureSeule", (bool)IsReadOnly ? "true" : "false");
if (Presentation != null)
this.Presentation.GenererHtml(paramsValeurs, this.Page.Html,this.CodePage,false);
if (this.textHasValue) // pour le caché etc, apres la presentation
paramsValeurs.Ajouter("texteChamp", this.Text);
paramsValeurs.Ajouter("pointSequence", this.SeqPoint.ToString(), page.NumPage.ToString());
// n'est envoyé que pourle champ en cours de saisie
if (this.MaxLengthProperty != 0)
paramsValeurs.Ajouter("tailleSaisie", this.MaxLengthProperty.ToString());
if (this.ListOfValidButtons != null && this.ListOfValidButtons.Count > 0)
{
StringBuilder vb = new StringBuilder();
vb.Append("@");
foreach (string n in ListOfValidButtons)
{
vb.Append(n);
vb.Append("@");
}
paramsValeurs.Ajouter("boutonsValides", vb.ToString());
}
UnParametreEnvoye p = new UnParametreEnvoye();
envois.Ajouter("creerObjet", "<input type='text'/>", HtmlGlobal.CalculerId(this.Id, page.Id, niveau));
envois.Ajouter("propsObjet", HtmlGlobal.ToJsonString(paramsValeurs, this.Page.Html.JsonParamsEnvoyes, false));
envois.Ajouter("ajoutObjetCourant", "");
}
/// <summary>
/// génération des commandes pour le navigateur
/// </summary>
/// <param name="pvs"></param>
/// <param name="html"></param>
/// <returns></returns>
public string GenererHtml(ListeParametresEnvoyes pvs,HtmlGlobal html,int codePage,bool ignorerCorrectifCausePadding)
{
string ret = "";
string classes = "";
int offsetX=0, offsetY=0;
// version ou on crée une commande par propriété
///*
UnParametreEnvoye pv;
XHtmlBorder wbordure= null;
XHtmlPadding wpadding = null;
if (this.idBordure.HasValue)
wbordure = html.App.BorduresCss.FirstOrDefault(e => e.Id == this.idBordure);
if (this.idPadding.HasValue)
wpadding = html.App.PaddingCss.FirstOrDefault(e => e.Id == this.idPadding);
pv = new UnParametreEnvoye();
pv.commande = "css-position";
pv.valeur = "absolute";
pvs.commandes.Add(pv);
// avant tout les positionnements
if (this.AttachementBas || this.AttachementDroite || this.LargeurVariable || this.HauteurVariable)
{
pv = new UnParametreEnvoye();
pv.commande = "attachements";
pv.valeur = (AttachementBas ? "1" : "0") + "," +
(AttachementDroite ? "1" : "0") + "," +
(HauteurVariable ? "1" : "0") + "," +
(LargeurVariable ? "1" : "0");
pvs.commandes.Add(pv);
}
// A FINALISER !!!!!!!!!!!!!!!!
//
// En HTML les bordures et paddings sont à l'extérieur de la boite xwin
// en wpf c'est l'inverse, la boite de xwin contient tout
// HAUTEUR
//------------------------------------
if (this.OriginalHeight.HasValue)
{
double? val = this.OriginalHeight;
pv = new UnParametreEnvoye();
pv.commande = "css-hauteur";
//pv.valeur = this.OriginalHeight.ToString();
pvs.commandes.Add(pv);
//----------------------------------------------------------------
// - traitement padding et border
if (wbordure != null && wbordure.Vide == false && wbordure.Epaisseur != 0)
{
val -= (wbordure.Epaisseur * 2);
offsetX += (int)wbordure.Epaisseur;
offsetY += (int)wbordure.Epaisseur;
}
if (ignorerCorrectifCausePadding == false)
{
if (wpadding != null && wpadding.Vide == false && wpadding.Vertical != 0)
{
val -= (wpadding.Vertical * 2);
offsetY += (int)wpadding.Vertical;
}
}
//----------------------------------------------------------------
pv.valeur = val.ToString();
// modifie également line-heigth coté navigazteur
}
// LARGEUR
//------------------------------------
if (this.OriginalWidth.HasValue)
{
double? val = this.OriginalWidth;
pv = new UnParametreEnvoye();
pv.commande = "css-largeur";
pv.valeur = this.OriginalWidth.ToString();
pvs.commandes.Add(pv);
//--------------------------------------------------------------------------------
if (wbordure != null && wbordure.Vide == false && wbordure.Epaisseur != 0)
val -= (wbordure.Epaisseur * 2);
if (ignorerCorrectifCausePadding == false)
{
if (wpadding != null && wpadding.Vide == false && wpadding.Horizontal != 0)
val -= (wpadding.Horizontal * 2);
}
//--------------------------------------------------------------------------------
pv.valeur = val.ToString();
}
// POSITION XY
//------------------------------------
if (this.Top.HasValue || this.Left.HasValue)
{
UnParametreEnvoyeAvecCompl pvc = new UnParametreEnvoyeAvecCompl();
pvc.commande = "css-xy";
offsetX = 0;
offsetY = 0;
pvc.valeur = (this.Left + offsetX) .ToString();
pvc.compl = (this.Top + offsetY) .ToString();
pvs.commandes.Add(pvc);
}
// ANGLE
//--------------------------------------
if (this.angle.HasValue)
{
UnParametreEnvoye pvc = new UnParametreEnvoye();
pvc.commande = "css-angle";
if (angle == 0)
pvc.valeur = this.angle.ToString() + "deg";
else
{
pvc.valeur = (this.angle * -1).ToString() + "deg";
}
pvs.commandes.Add(pvc);
}
// POLICE
//--------------------------------------
if (idPolice.HasValue)
{
XHtmlFont i;
i = html.App.PolicesCss.Find(e => e.Id == idPolice);
if (i != null)
{
// classes += XHtmlFont.PrefixeCss + idPolice.ToString() + " ";
UnParametreEnvoye pvc = new UnParametreEnvoye();
pvc.commande = "css-police";
if (i.Vide)
pvc.valeur = "xxxx";
else
pvc.valeur = XHtmlFont.PrefixeCss + idPolice.ToString();
pvs.commandes.Add(pvc);
}
}
// FOND
//------------------------------------------
if (idFond.HasValue)
{
UnParametreEnvoye pvc = new UnParametreEnvoye();
pvc.valeur = html.App.GenererUneValeurDeCouleur(idFond);
if (pvc.valeur != null)
{
pvc.commande = "css-fond";
pvs.commandes.Add(pvc);
}
//if (i != null && i.Vide == false && i.Transparente == false)
//{
// classes += XHtmlColor.PrefixeCssFond + idFond.ToString() + " ";
//}
}
// BORDURE
//--------------------------------------------
if (idBordure.HasValue)
{
XHtmlBorder i;
i = html.App.BorduresCss.Find(e => e.Id == idBordure);
if (i != null)
{
UnParametreEnvoye pvc = new UnParametreEnvoye();
pvc.commande = "css-bordure";
if (i.Vide)
pvc.valeur = "xxxx";
else
pvc.valeur = XHtmlBorder.PrefixeCss + idBordure.ToString();
pvs.commandes.Add(pvc);
}
// if (i != null && i.Vide == false)
// classes += XHtmlBorder.PrefixeCss + idBordure.ToString() + " ";
}
// PADDING
//----------------------------------------------
if (idPadding.HasValue)
{
XHtmlPadding i;
i = html.App.PaddingCss.Find(e => e.Id == idPadding);
if (i != null)
{
UnParametreEnvoye pvc = new UnParametreEnvoye();
pvc.commande = "css-padding";
if (i.Vide)
pvc.valeur = "xxxx";
else
pvc.valeur = XHtmlPadding.PrefixeCss + idPadding.ToString() + " ";
pvs.commandes.Add(pvc);
// classes += XHtmlPadding.PrefixeCss + idPadding.ToString() + " ";
}
}
if (codePage != 0)
{
pv = new UnParametreEnvoye();
pv.commande = "code-page";
pv.valeur = codePage.ToString();
pvs.commandes.Add(pv);
}
// INFO BULLE
//--------------------------------------------------
if (this.frameworkElement.ToolTip != null)
{
pv = new UnParametreEnvoye();
pv.commande = "info-bulle";
pv.valeur = this.frameworkElement.ToolTip;
pvs.commandes.Add(pv);
}
// Visibilite
//---------------------------------------------------
if (Visibilite.HasValue)
{
pv = new UnParametreEnvoye();
pv.commande = "visibilite";
pv.valeur = Visibilite.ToString();
pvs.commandes.Add(pv);
}
//*/
///////////////////////////////////////////////////////
//////////////////////////////////////// MORCEAU qui génére tout le code HTML : beaucoup plus rapide a l'exec
/*
ret = "style='";
// ret += "font-size:50pt;";
ret += "position:absolute;";
ret += "top:" + this.Top.ToString() + "px;";
ret += "left:" + this.Left.ToString() + "px;";
ret += "width:" + this.OriginalWidth.ToString() + "px;";
ret += "height:" + this.OriginalHeight.ToString() + "px;";
if (this.angle.HasValue)
{
ret += "transform:rotate(" + angle.ToString() + "deg)";
}
ret += "'";
*/
if (classes.Length > 0)
{
UnParametreEnvoye pvc = new UnParametreEnvoye();
pvc.commande = "css-police-fond-padding";
pvc.valeur = classes;
pvs.commandes.Add(pvc);
}
return ret;
//////////////////////////////////////////////
// return ret;
}
public void Ajouter(string commande, string valeur)
{
UnParametreEnvoye p = new UnParametreEnvoye();
p.valeur = valeur;
p.commande = commande;
this.commandes.Add(p);
}
