internal void Analyse(DVBuffer buffer)
{
try { GetProperties(buffer); }
catch (XHtmlException e) {
SendError(e.ErrorCode, e.ErrorLocation, e.ErrorParameter); }
//!!!!!!!!!!!!!!!!!!!! revoir tous ce cas
if (AttenteInput) return ; // input : attente opérateur (sauf notif immédiate)
if (AttenteConsult) return ; // consult : attente opérateur
if (AttentePopupMenu) return; // popup menu : attente opérateur
if (AttenteGetb) return; // get bloquant : attente opérateur
if (responseAlreadySent) return; // double clic / nb lignes tableau / index colonne / bulle scrollbar tableau envoyé
//autres cas (display, ...)
var response = new DVBuffer();
response.Put(ProprietesWpf.CLIENTLEGER_DEBUT);
Send(response); // acquittement (réponse "vide")
return;
}
// bh1
/// <summary>
/// Ajout dans les données de retour des fichiers joints
/// </summary> bhficjoint
/// <param name="reponse">dvbuffer à completer</param>
/// <param name="fichiers">fichiers</param>
void AjouterFichiersJoints(DVBuffer reponse, HttpFileCollection fichiers)
{
string nomreel, nomtemp;
HttpPostedFile fichierposté;
string id;
for (int i = 0; i < fichiers.Count; i++)
{
id = fichiers.AllKeys[i];
fichierposté = fichiers[i];
nomreel = fichierposté.FileName;
if (nomreel != "")
{
nomtemp = Path.GetTempFileName();
fichierposté.SaveAs(nomtemp);
reponse.Put(Proprietes.VALEUR_SAISIE);
reponse.Put(id);
string val = "__YWEBFICJOINT1__" + nomtemp +
"__YWEBFICJOINT2__" + nomreel;
reponse.Put(val);
}
}
}
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>
/// Fills the DVBuffer with the value of the given control
/// </summary>
/// <param name="response">Buffer containing the prepared response to the Diva program</param>
/// <param name="typeNode"> DANS default.aspx, voir la fonction envoyerClic</param>
internal void SetInputBuffer(DVBuffer response,string typeNode,string typeObjet,string valeurObjet,int cp)
{
FrameworkElement activeControl = StackOfWindows.Peek().ActiveControl; //
int codePage = 0;
if (response == null) throw new ArgumentNullException("response");
//if (activeControl == null) return; // on ne fait rien si pas de controle actif
ProprietesWpf property = new ProprietesWpf();
string valueString = null;
ushort? valueUshort = null;
//if (!AttenteInput) return; // garde-fou : on ne fait rien si l'on n'est pas en attenteInput (ne devrait pas arriver)
if (typeNode == "BUTTON") //!!!!!!!!!!!!!!!!tester!!!!!!!!!
return; // on n'envoie rien pour le bouton
//// type d'objet + codepage + valeur
//if (activeControl is TextBox) !!!!!!!!!!!!!!!!!!!!
//{
// property = ProprietesWpf.CHAMP_VALEUR;
// valueString = ((XHtmlTextBox)activeControl).Text;
// codePage = ((XHtmlTextBox)activeControl).CodePage; // !!!!!!!!!!!!!! stocker le codePage dans l'html
//}
if (typeNode == "INPUT" && typeObjet == "TEXT")
{
property = ProprietesWpf.CHAMP_VALEUR;
valueString = valeurObjet;
codePage = cp;
}
else if (typeNode == "INPUT" && typeObjet == "SELECT") // (activeControl is ComboBox)
{
property = ProprietesWpf.MULTICHOIX_VALEUR;
valueUshort = (ushort)Convert.ToInt16(valeurObjet);
}
else if (typeNode == "DIV" && typeObjet == "CHECKBOX")
{
property = ProprietesWpf.CASE_A_COCHER_ETAT;
valueUshort = (ushort)Convert.ToInt16(valeurObjet);
//(((XHtmlCheckBox)activeControl).IsChecked == true) ? (ushort)1 : (ushort)0;
}
// DANS default.aspx, voir la fonction envoyerClic
//else if (activeControl is PasswordBox)
//{
// property = ProprietesWpf.CHAMP_VALEUR;
// valueString = ((PasswordBox)activeControl).Password;
// codePage = ((XHtmlPasswordBox)(activeControl.DataContext)).CodePage;
//}
//else if (activeControl is DatePicker)
//{
// property = ProprietesWpf.CHAMP_VALEUR;
// valueString = ((XHtmlDatePicker)activeControl).DisplayText;
// codePage = ((XHtmlDatePicker)activeControl).CodePage;
//}
//else if (activeControl is ListBox)
//{
// property = ProprietesWpf.MULTICHOIX_VALEUR;
// valueUshort = (ushort)(((XHtmlListBox)activeControl).SelectedIndex + 1);
//}
//else if (activeControl is GroupBox)
//{
// property = ProprietesWpf.GROUPE_RADIO_BOUTON_ACTIF;
// valueUshort = (ushort)(((XHtmlRadioGroup)activeControl).CurrentIndex + 1);
//}
//else if (activeControl is RichTextBox)
//{
// property = ProprietesWpf.RICHTEXT_TEXTE;
// valueString = ((XHtmlRichTextBox)activeControl).GetValue();
//}
//else if (activeControl is DataGrid)
//{
// XHtmlDataGrid dataGrid = (XHtmlDataGrid)activeControl;
// int currentRowIndex = dataGrid.Rows.IndexOf((XHtmlRow)dataGrid.CurrentItem);
// int currentColIndex = dataGrid.Columns.IndexOf(dataGrid.CurrentCellInfo.Column);
// dataGrid.PrepareInputCallBack(dataGrid.GetDataGridCell(currentRowIndex, currentColIndex), out property, out valueString, out valueUshort);
//}
response.Put(property);
if (valueString != null) response.PutStringCP(valueString, codePage);
else response.Put(valueUshort.Value);
}
internal void SendError(XHtmlErrorCodes errorCode, XHtmlErrorLocations errorLocation, string errorParameter)
{
var errorBuffer = new DVBuffer();
errorBuffer.Put(ProprietesWpf.CLIENTLEGER_DEBUT);
errorBuffer.Put(ProprietesWpf.ERREUR_XWPF);
errorBuffer.Put((ushort)errorCode);
errorBuffer.Put((ushort)errorLocation);
errorBuffer.PutString(errorParameter);
errorBuffer.PutString("ApplicationVersion"); //!!!!!!!!!!!!!!!!!!!!!!!!!
// Send(errorBuffer); Il faut d'abord rendre la main au navigateur qui va immédiatement revenir pour emettre ce dvbuffer
responseAlreadySent = true;
// je garde le DVBuffer, j'en fait une copie en profondeur
DVBufferATransmettreImmediatement = new DVBuffer(errorBuffer.LeBuffer, 0, errorBuffer.GetTaille());
}
// private readonly FlashModeHelper flashModeHelper = FlashModeHelper.GetInstance();
internal void Send(DVBuffer response)
{
return; //!!!!!!!!!!!!!!!
/*
App appp = (App)Application.Current;
var app = (App)Application.Current;
// TODO mettre dans les logs harmony ? Ce message est intéressant car il signale une anomalie qui va mettre le bazar
if (app.AttenteReponseEnCours)
{
// !!!!!!!!!! MessageBox.Show("Attention : Désynchronisation entre Xwpf et Xrtdiva");
return;
}
app.AttenteReponseEnCours = true;
AttenteConsult = false;
AttenteInput = false;
AttentePopupMenu = false;
AttenteGetb = false;
*/
//!!!!!!!!!!! if (consultTimer != null) consultTimer.Stop(); // arrêt du timer le cas échéant
//!!!!!!!!!!! if (!busyTimer.IsEnabled) busyTimer.Start(); // lancement du timer pour le curseur d'attente le cas échéant.
//!!!!!!!!!!! XwpfWindow window = StackOfWindows.Peek(); //abandonner le focus si input en cours
//!!!!!!!!!!! Keyboard.Focus(window.MainCanvas);
//!!!!!!!!!! window.ActiveControl = null; // garde-fou: on r.à.z le contrôle actif lorsque l'appli à la main (et donc hors input).
/* !!!!!!!!!!!!!!!!
if (SendWindowhandler)
{
IntPtr hwnd = app.GetTopWindow();
if (hwnd != (IntPtr)0)
{
SendWindowhandler = false;
response.Put((ushort)ClientLegerProprietes.PROPCLIENTLEGER_HFENETRE);
response.Put((int)hwnd);
app.Client.FenetreMere = hwnd;
app.Client.Tunnel.EcrireHandlerFenetreClient(app.Client.SessionProgrammeCourant, hwnd, app.Client.IdentifiantServeur);
}
}
*/
//si le menu pour l'impression d'écran a été (dé)coché, on envoie la nouvelle valeur:
if (IsPrintPreviewUpdated)
{
IsPrintPreviewUpdated = false;
response.Put(ProprietesWpf.MENU_SYSTEME_APERCU_ETAT);
response.Put((byte)(IsPrintPreviewEnabled ? 1 : 0)); // Flag "aperçu avant impression actif ?" (byte)
response.Put((byte)(IsPrintPreviewSaved ? 2 : 0)); // Flag "sauver aperçu avant impression ?" (byte)
}
response.Put(ProprietesWpf.CLIENTLEGER_FIN);
//!!!!!!!!!!!!!! app.Client.Transport.BufferEmission = response;
//!!!!!!!!!!!!!! app.Client.Transport.EnvoyerEtDemanderReveil();
}
//***********************************************************************************************
//***********************************************************************************************
// C'EST ICI QUE CA SE PASSE
//***********************************************************************************************
//***********************************************************************************************
protected unsafe void Page_Load(object sender, EventArgs e)
{
string chaineJson = "";
// récupération des parametres envoyés en ajax
//-----------------------------------------------------------------
foreach (string id in Request.Form)
{
string[] valeurs = Request.Form.GetValues(id);
if (valeurs.Length == 1)
{
string val = Request.Form[id];
if (id == "divaltoParametresAjax")
chaineJson = val;
}
else
{
//§!!!!!!!!!!!!!!!!!!!!!!!!
for (int cpt = 0; cpt < valeurs.Length; cpt++)
{
string val = valeurs[cpt];
}
}
}
// je n'ai aucune variable statique CAR (OH SURPRISE) elle serait globale a toutes les sessions
//----------------------------------------------------------------------------------------------
XHtmlApplication app = new XHtmlApplication();
app.Html = new HtmlGlobal();
app.Html.App = app;
// je recupere ce que j'ai stocké dans les variables de session
// Les polices,bordures,couleurs,paddings,pile des fenetres
//----------------------------------------------------------------------------------------------
byte[] toutEnJson = (byte[])this.Session["application"];
if (toutEnJson != null)
{
// je passe par une donnée de travail CAR LES CONSTRUCTEURS NE SONT PAS APPELES par les fonctions JSON
XHtmlApplication wapp = (XHtmlApplication)app.Html.JsonApplication.ReadObject(new MemoryStream(toutEnJson));
app.BorduresCss = wapp.BorduresCss;
app.PaddingCss = wapp.PaddingCss;
app.PolicesCss = wapp.PolicesCss;
app.CouleursCss = wapp.CouleursCss;
app.StackOfWindows = wapp.StackOfWindows;
// pour chaque page, remet le pointeur vers la fenetre parent
foreach (XHtmlWindow w in app.StackOfWindows)
{
foreach (XHtmlPage p in w.ListOfPages)
{
p.Html = app.Html;
p.Window = w;
}
}
}
// - au moins une fenetre sur le stack
if (app.StackOfWindows.Count == 0)
app.StackOfWindows.Push(new XHtmlWindow());
// - création d'une liste de commandes a partir des données recues
byte[] tablo = app.Html.UniEncoding.GetBytes(chaineJson);
ListeParametresRecus recus = (ListeParametresRecus)app.Html.JsonParamsRecus.ReadObject(new MemoryStream(tablo));
// - Balayage des données transmises par le client
//---------------------------------------------------------------------------------
foreach (UnParametreRecu recu in recus.commandes)
{
switch (recu.commande)
{
case "premierappel":
{
byte[] tablop = app.Html.UniEncoding.GetBytes(recu.compl);
XHtmlParametresLancement lancement = (XHtmlParametresLancement)app.Html.JsonParametresLancement.ReadObject(new MemoryStream(tablop));
app.LancementDuProgramme(true, lancement, this, sender, e);
}
break;
case "cmdSuite": // il n'y avait rien a faire coté client, juste a réveiller le serveur
{
var response = new DVBuffer();
response.Put(ProprietesWpf.CLIENTLEGER_DEBUT); //début de l'acquittement ou de la réponse
EnvoyerEtAttendre(response,app);
}
break;
case "transmettreBufferGarde": // transmission du buffer précédemment gardé
{
DVBuffer b;
byte[] t = (byte[])this.Session["DVBufferATransmettreImmediatement"];
b = new DVBuffer(t);
EnvoyerEtAttendre(b, app);
}
break;
case "tabGetNbLig": // transmettre le nombre de lignes d'un tableau
{
ushort us;
DVBuffer b = new DVBuffer();
b.Put(ProprietesWpf.CLIENTLEGER_DEBUT);
b.Put(ProprietesWpf.TABLEAU_NOMBRE_LIGNES);
us = Convert.ToUInt16(recu.valeur);
b.Put(us);
EnvoyerEtAttendre(b, app);
}
break;
case "identsTables": // reception de la liste des idents des objets tableaux,
// comme ca je peux tester si un tableau existe ou non
{
string[] idents = recu.valeur.Split(',');
app.Html.ListeIdentsTablesExistantesCoteClient = idents;
}
break;
case "toucheFonction":
{
// - création d'une liste de commandes a partir des données recues
string [] p;
string key = "";
string shift = "false";
string ctrl = "false";
string alt = "false";
string typeNode = "";
string typeInput = "";
string valeurObjet = "";
int codePage=0;
byte[] stablo = app.Html.UniEncoding.GetBytes(recu.compl);
ListeParametresRecus srecus = (ListeParametresRecus)app.Html.JsonParamsRecus.ReadObject(new MemoryStream(stablo));
foreach (UnParametreRecu sp in srecus.commandes)
{
switch (sp.commande)
{
case "typeTouche" :
p = sp.valeur.Split(',');
key = p[0];
shift = p[1];
ctrl = p[2];
alt = p[3];
break;
case "typeObjet" :
typeNode = sp.valeur;
typeInput = sp.compl.ToUpper();
break;
case "valeurObjet" :
valeurObjet = sp.valeur;
codePage = Convert.ToInt32(sp.compl);
break;
}
}
var response = new DVBuffer();
response.Put(ProprietesWpf.CLIENTLEGER_DEBUT); //début de l'acquittement ou de la réponse
app.SetInputBuffer(response,typeNode,typeInput,valeurObjet,codePage);
if (ctrl == "true")
response.Put(ProprietesWpf.TOUCHE_CTRL);
if (shift == "true")
response.Put(ProprietesWpf.TOUCHE_SHIFT);
if (alt == "true")
response.Put(ProprietesWpf.TOUCHE_ALT);
response.Put(ProprietesWpf.TOUCHE_CLAVIER); // touche tapée (APRES les modificateurs)
response.PutString(key);
EnvoyerEtAttendre(response, app);
}
break;
case "clicSouris":
{
string[] p;
int nombreClic = 1;
int boutonSouris = 1;
ushort arretDemandeSaisie = 0;
ushort numeroPage = 0;
string shift = "false";
string ctrl = "false";
string alt = "false";
string typeNode = "";
string typeInput = "";
string valeurObjet = "";
int sequence = 0;
int codePage = 0;
ClicOnglet onglet=null;
byte[] stablo = app.Html.UniEncoding.GetBytes(recu.compl);
ListeParametresRecus srecus = (ListeParametresRecus)app.Html.JsonParamsRecus.ReadObject(new MemoryStream(stablo));
foreach (UnParametreRecu sp in srecus.commandes)
{
switch (sp.commande)
{
case "typeClic" :
p = sp.valeur.Split(',');
nombreClic = Convert.ToInt32(p[0]);
boutonSouris = Convert.ToInt32(p[1]);
shift = p[2];
ctrl = p[3];
alt = p[4];
break;
case "typeObjet" :
typeNode = sp.valeur;
typeInput = sp.compl.ToUpper();
break;
case "infosPage" :
p = sp.valeur.Split(',');
sequence = Convert.ToInt32(p[0]);
numeroPage = (ushort)Convert.ToInt16(p[1]);
arretDemandeSaisie = (ushort)Convert.ToInt16(p[2]);
break;
case "valeurObjet" :
valeurObjet = sp.valeur;
codePage = Convert.ToInt32(sp.compl);
break;
case "clicOnglet":
{
byte[] stablong = app.Html.UniEncoding.GetBytes(sp.valeur);
onglet = (ClicOnglet)app.Html.JsonClicOnglet.ReadObject(new MemoryStream(stablong));
}
break;
}
}
var response = new DVBuffer();
response.Put(ProprietesWpf.CLIENTLEGER_DEBUT); //début de l'acquittement ou de la réponse
app.SetInputBuffer(response, typeNode, typeInput, valeurObjet, codePage);
response.Put(ProprietesWpf.EVENEMENT_SOURIS_DEBUT); // Début de l'envoi des évenements souris
if (onglet == null)
{
response.Put(ProprietesWpf.SOURIS_TYPE_EVENEMENT); // Type d'évènement souris (byte)
response.Put((byte)MouseEvent.ClickControl);
response.Put(ProprietesWpf.PAGE_NUMERO); // Numéro de la page contenant la donnée cliquée
response.Put((byte)numeroPage);
response.Put(ProprietesWpf.PAGE_ARRET_SAISIE); // Numéro du point d'arrêt "Demande de saisie" de la page contenant la donnée cliquée
response.Put(arretDemandeSaisie);
p = recu.valeur.Split('_');
response.Put(ProprietesWpf.IDENT_UNIQUE); // Id de la donnée cliquée (uint)
response.Put(Convert.ToInt32(p[0]));
response.Put(ProprietesWpf.PARAM_SAISIE_SEQUENCE); // Numéro du point de séquence de la donnée cliquée
response.Put((ushort)sequence);
// Informations sur le clic lui-même, à savoir (pour le moment) :
response.Put(ProprietesWpf.SOURIS_CLIC); // 1 = simple clic; 2 = double clic (byte)
response.Put((byte)nombreClic);
response.Put(ProprietesWpf.SOURIS_BOUTON); // 1 = gauche; 2 = milieu; 3 = droite (byte)
response.Put((byte)boutonSouris);
response.Put(ProprietesWpf.SOURIS_TOUCHE); // touche(s) du clavier enfoncée(s) simultanément (byte)
response.Put(XHtmlApplication.GetPressedKey(shift, ctrl, alt));
// if (e.ClickCount < 2) Send(response); // envoi de la réponse et attente de la suite
// else if (!AttenteInput) AsynchronousResponse = response;
}
else
{
response.Put(ProprietesWpf.SOURIS_TYPE_EVENEMENT); // Type d'évènement souris (byte)
response.Put((byte)MouseEvent.ClickTab);
response.Put(ProprietesWpf.SOURIS_CLIC); // 1 = simple clic; 2 = double clic (byte)
response.Put((byte)1);
response.Put(ProprietesWpf.SOURIS_BOUTON); // 1 = gauche; 2 = milieu; 3 = droite (byte)
response.Put((byte)1);
response.Put(ProprietesWpf.SOURIS_TOUCHE); // touche(s) du clavier enfoncée(s) simultanément (byte)
response.Put((byte)0);
// Informations sur le changement d'onglet :
response.Put(ProprietesWpf.ONGLET_ARRET); // Numéro du point d'arrêt (ushort)
response.Put(onglet.arretOnglet);
response.Put(ProprietesWpf.ONGLET_NOUVELLE_PAGE); // numéro de page de l'onglet à afficher (byte)
response.Put((byte)onglet.pageOngletClick);
response.Put(ProprietesWpf.ONGLET_ANCIENNE_PAGE); // numéro de page de l'onglet précédemment affiché (byte)
response.Put((byte)onglet.anciennePage);
}
response.Put(ProprietesWpf.EVENEMENT_SOURIS_FIN); // Fin de l'envoi des évenements souris
EnvoyerEtAttendre(response, app);
}
break;
case "notificationCaseACocher":
{
string[] p;
ushort arretDemandeSaisie = 0;
ushort numeroPage = 0;
string valeurObjet = "";
int sequence = 0;
byte[] stablo = app.Html.UniEncoding.GetBytes(recu.compl);
ListeParametresRecus srecus = (ListeParametresRecus)app.Html.JsonParamsRecus.ReadObject(new MemoryStream(stablo));
foreach (UnParametreRecu sp in srecus.commandes)
{
switch (sp.commande)
{
case "infosPage":
p = sp.valeur.Split(',');
sequence = Convert.ToInt32(p[0]);
numeroPage = (ushort)Convert.ToInt16(p[1]);
arretDemandeSaisie = (ushort)Convert.ToInt16(p[2]);
break;
case "valeurCase":
valeurObjet = sp.valeur;
break;
}
}
var response = new DVBuffer();
response.Put(ProprietesWpf.CLIENTLEGER_DEBUT); //début de l'acquittement ou de la réponse
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)
response.Put((byte)MouseEvent.Notification);
response.Put(ProprietesWpf.PAGE_NUMERO); // Numéro de la page contenant la donnée cliquée
response.Put((byte)numeroPage);
p = recu.valeur.Split('_');
response.Put(ProprietesWpf.IDENT_UNIQUE); // Id de la donnée cliquée (uint)
response.Put(Convert.ToInt32(p[0]));
response.Put(ProprietesWpf.PARAM_SAISIE_SEQUENCE); // Numéro du point de séquence de la donnée cliquée
response.Put((ushort)sequence);
response.Put(ProprietesWpf.EVENEMENT_SOURIS_FIN); // Fin de l'envoi des évenements souris
response.Put(ProprietesWpf.CASE_A_COCHER_ETAT);
response.Put((ushort)Convert.ToInt16(valeurObjet));
EnvoyerEtAttendre(response, app);
}
break;
case "clicbouton": // transfert des infos du clic a JS
{
byte[] tablop = app.Html.UniEncoding.GetBytes(recu.compl);
ListeParametresComplementaires recusp = (ListeParametresComplementaires)app.Html.JsonParamCompl.ReadObject(new MemoryStream(tablop));
UnParametreComplementaire p1, p2;
string idBouton = recu.valeur;
p1 = recusp.p.First();
byte action = Convert.ToByte(p1.v);
p2 = recusp.p[1];
var response = new DVBuffer();
response.Put(ProprietesWpf.CLIENTLEGER_DEBUT); //début de l'acquittement ou de la réponse
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)
response.Put((byte)MouseEvent.ClickButton);
response.Put(ProprietesWpf.BOUTON_ACTION); // Type d'action (byte = 1, 2 ou 3)
response.Put(action);
switch (action)
{
case 1: response.Put(Convert.ToInt16(p2.v)); break; // Type = 1 : point de traitement
case 2: response.Put(Convert.ToInt16(p2.v)); break; // Type = 2 : point d'arrêt
case 3: response.PutString(p2.v); break; // Type = 3 : chaîne à générer
}
response.Put(ProprietesWpf.EVENEMENT_SOURIS_FIN); // Fin de l'envoi des évenements souris
EnvoyerEtAttendre(response,app);
}
break;
case "clicmultichoix":
//envoi = new UnParametreEnvoye();
//envoi.commande = "status";
//envoi.valeur = "true";
//envois.commandes.Add(envoi);
//envoi = new UnParametreEnvoye();
//envoi.commande = "script";
//envoi.valeur = "laisserPasserClickMultiChoix=true;";
//envoi.valeur += "$(\"#dropdownlist\").data(\"kendoDropDownList\").open();";
//envois.commandes.Add(envoi);
break;
}
}
//*****************************************************************************************
// Analyse des données provenant de JS
//*****************************************************************************************
app.CodeEcran = new DVBuffer(app.DonneesRecuesDeYwpf, Marshal.SizeOf(typeof(EnteteTrame)), app.DonneesRecuesDeYwpf.Length);
app.Analyse(app.CodeEcran);
//*****************************************************************************************
// Préparation des envois vers le client
//*****************************************************************************************
app.FaireLaListeDesEnvoisPourStyles();
// - utilisé pour les erreurs détectées dans la couche IIS
if (app.DVBufferATransmettreImmediatement != null)
{
DVBuffer b = app.DVBufferATransmettreImmediatement;
byte[] t = new byte[b.GetTaille()];
Array.Copy(b.LeBuffer, t, b.GetTaille());
this.Session["DVBufferATransmettreImmediatement"] = t;
app.Html.Envois.Ajouter("transmettreBufferGarde", "session");
}
else
this.Session["DVBufferATransmettreImmediatement"] = null;
chaineAEnvoyer = HtmlGlobal.ToJsonString(app.Html.Envois, app.Html.JsonParamsEnvoyes, false);
// - je garde tout ce qui m'intéresse dans une donnée de session
//--------------------------------------------------------------------------------
this.Session["application"] = HtmlGlobal.ToJson(app, app.Html.JsonApplication);
byte[] wtout = (byte [])this.Session["application"];
}
//*************************************************************************************
// Envoyer les données vers JS et attendre sa réponse
//*************************************************************************************
private void EnvoyerEtAttendre(DVBuffer response, XHtmlApplication app)
{
int sessionWeb = (int)this.Session["SessionDivaltoWeb"];
response.Put(ProprietesWpf.CLIENTLEGER_FIN);
// emballe le DVBuffer comme si c'était une trame client léger
byte[] tout = XHtmlOutils.AjouterEnteteAuDVBuffer(response);
// envoi + attente
DialogueX2Y.WebSendDataAndWaitResponse(sessionWeb, tout, out app.DonneesRecuesDeYwpf);
// dans tous les cas on crée un DVBuffer avec le code de la page
if (app.DonneesRecuesDeYwpf == null)
{
string message = "codeecran null dans XWebPageLoad";
throw new NullReferenceException(message);
}
}
