示例#1
0
		public void AjouterEnvoisUnObjet(ListeParametresEnvoyes envois, XHtmlPage page, int niveau)
		{
			ListeParametresEnvoyes paramsValeurs = new ListeParametresEnvoyes();
			ListeParametresEnvoyes paramsGrille = new ListeParametresEnvoyes();

			paramsValeurs.Ajouter("idObjet", HtmlGlobal.CalculerId(this.Id, page.Id, niveau), this.Page.Html.CalculerIdPage(page.Id));

			// presentation
			if (Tag != null)
				this.Tag.GenererHtml(paramsValeurs, this.Page.Html, 0, false);

			GridJson gj = new GridJson();
			gj.nbCellules = this.Cellules.Count();
			gj.vertical = this.Orientation == 1;
			gj.modePourcent = true;
			gj.tailleX = (int)this.Tag.OriginalWidth;
			gj.tailleY = (int)this.Tag.OriginalHeight;

			foreach (XHtmlCelluleGrille cell in this.Cellules)
			{
				CellJson gc = new CellJson();
				gj.cellules.Add(gc);
				gc.avecResize = cell.AvecResize;
//				if (cell.Presentation.idFond.HasValue)
//					gc.fond = page.Html.App.GenererUneValeurDeCouleur(cell.Presentation.idFond);
				gc.posX = (int)cell.Presentation.Left;
				gc.posY = (int)cell.Presentation.Top;
				gc.tailleX = (int)cell.Presentation.OriginalWidth;
				gc.tailleY = (int)cell.Presentation.OriginalHeight;
			}

			paramsGrille.Ajouter("paramsGrille", HtmlGlobal.ToJsonString(gj, this.Page.Html.JsonGrille, false));

			envois.Ajouter("creerGrille", HtmlGlobal.ToJsonString(paramsGrille, this.Page.Html.JsonParamsEnvoyes, false), HtmlGlobal.CalculerId(this.Id, page.Id, niveau));
			envois.Ajouter("propsObjet", HtmlGlobal.ToJsonString(paramsValeurs, this.Page.Html.JsonParamsEnvoyes, false));

			string p;
			if (this.Tag.GridId != 0)
			{
				p = "{" +
							"\"idGrille\":\"" + HtmlGlobal.CalculerId(this.Tag.GridId, this.Page.Id, niveau) + "\"," +
							"\"iCellule\":" + this.Tag.CellIndex +
							"}";
			}
			else
			{
				p = "{" +
							"\"idGrille\":\"" + "0" + "\"," +
							"\"iCellule\":" + 0 +
							"}";
			}
			
			envois.Ajouter("ajouterGrille", p); 
		}
 public void AjouterEnvoisUnObjet(ListeParametresEnvoyes envois, XHtmlPage page, int niveau)
 {
 }
示例#3
0
 public HtmlGlobal()
 {
     Envois = new ListeParametresEnvoyes();
 }
        public void AjouterEnvoisUnObjet(ListeParametresEnvoyes envois, XHtmlPage page, int niveau)
        {
            ListeParametresEnvoyes paramsValeurs = new ListeParametresEnvoyes();
            ListeParametresEnvoyes paramsCreation = new ListeParametresEnvoyes();

            OngletVersJson cc = new OngletVersJson();

            paramsValeurs.Ajouter("idObjet", HtmlGlobal.CalculerId(this.Id, page.Id, niveau), this.Page.Html.CalculerIdPage(page.Id));

            if (this.idPolice.HasValue)
                cc.police = XHtmlFont.PrefixeCss + idPolice.ToString();

            if (this.idPadding.HasValue)
                cc.padding = XHtmlPadding.PrefixeCss + idPadding.ToString();

            if (this.ImageHeight.HasValue)
                cc.hauteurImage = this.ImageHeight;

            if (this.ImageWidth.HasValue)
                cc.largeurImage = this.ImageWidth;

            cc.multiLigne = this.IsMultiLine;

            cc.pointArret = this.stopPoint;
            cc.pageCourante = this.currentTabPageNum;

            if (Presentation != null)
                this.Presentation.GenererHtml(paramsValeurs, this.Page.Html, 0, false);

            foreach (XHtmlTabItem item in this.Items)
            {
                cc.items.Add(item.AjouterEnvoisUnItem(envois,page,niveau));
            }

            string parametresJson = HtmlGlobal.ToJsonString(cc, this.Page.Html.JsonParametresOnglet, false);
            paramsCreation.Ajouter("paramsCreation", parametresJson);

            //UnParametreEnvoye p = new UnParametreEnvoye();

            envois.Ajouter("creerOnglet", HtmlGlobal.ToJsonString(paramsCreation, this.Page.Html.JsonParamsEnvoyes, false), HtmlGlobal.CalculerId(this.Id, page.Id, niveau));
            envois.Ajouter("propsObjet", HtmlGlobal.ToJsonString(paramsValeurs, this.Page.Html.JsonParamsEnvoyes, false));
        }
示例#5
0
        /// <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);";
            */
            //////////////////////////////////////////////////////////////
        }
示例#6
0
        public ItemOngletVersJson AjouterEnvoisUnItem(ListeParametresEnvoyes envois, XHtmlPage page, int niveau)
        {
            ItemOngletVersJson io = new ItemOngletVersJson();

            io.texte = this.Header;
            io.bulle = this.ToolTip;

            if (imageFile != null && string.IsNullOrEmpty(imageFile.FileName) == false)
            {
                io.bitmap = imageFile.FileName.Replace('.', '_');
            }

            //if (this.Presentation != null && this.Presentation.idFond.HasValue)
            //{
            //	io.fond = this.Page.Html.App.GenererUneValeurDeCouleur(this.Presentation.idFond);
            //}
            if (this.IdFond.HasValue)
            {
                io.fond = this.Page.Html.App.GenererUneValeurDeCouleur((ushort)this.IdFond);
            }

            io.numeroPage = this.PageNumber;
            io.visibilite = (byte)this.Visibilite;

            return io;
        }
示例#7
0
        /// <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));
        }
示例#8
0
        //#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;
        //   }
        //   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) && ValidModifiedKeys.Contains(e.Key)))
        //         key = e.Key.ToString();
        //      else if (e.Key != Key.Left && e.Key != Key.Right) return; // les touches restantes ne sont pas bloquées, excepté flèches droite et gauche
        //   }
        //   e.Handled = true;
        //   application.SendInputKeyDown(key);
        //}
        /// <summary>
        /// Gestionnaire d'évènement "PreviewMouseDown"
        /// </summary>
        //private void PreviewMouseDownHandler(object sender, MouseButtonEventArgs e)
        //{
        //   if (IsReadOnly) // refusé si IsReadOnly
        //   {
        //      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>
        /// Gestionnaire d'évènement "Checked ou Unchecked" pour la notification
        /// </summary>
        //private void ValueChangedHandler(object sender, RoutedEventArgs e)
        //{
        //   var application = ((App)Application.Current).Appli;
        //   // on ne notifie pas si la case n'est pas le contrôle actif en input
        //   if (!(application.AttenteInput && Page.Window.ActiveControl == this)) return;
        //   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 (byte)
        //   response.Put(Page.NumPage);
        //   response.Put(ProprietesWpf.IDENT_UNIQUE);					// Id de la donnée cliquée (uint)
        //   response.Put(Id);
        //   response.Put(ProprietesWpf.PARAM_SAISIE_SEQUENCE);		// Numéro du point de séquence de la donnée cliquée (ushort)
        //   response.Put(SeqPoint);
        //   response.Put(ProprietesWpf.EVENEMENT_SOURIS_FIN);		// Fin de l'envoi des évenements souris
        //   response.Put(ProprietesWpf.CASE_A_COCHER_ETAT);			// Nouvelle valeur (ushort)
        //   response.Put((IsChecked.HasValue && IsChecked.Value) ? (ushort)1 : (ushort)0);
        //   application.Send(response);
        //}
        //#endregion Ecouteurs
        /// 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();
            ListeParametresEnvoyes paramsCreation = new ListeParametresEnvoyes();

            CaseACocherVersJson cc = new CaseACocherVersJson();

            paramsValeurs.Ajouter("idObjet", HtmlGlobal.CalculerId(this.Id, page.Id, niveau), this.Page.Html.CalculerIdPage(page.Id));

            if (this.IsChecked.HasValue)
                paramsValeurs.Ajouter("caseChecked", (bool)this.IsChecked ? "true" : "false");

            if (this.TexteAGauche.HasValue)
                cc.texteAGauche = (bool)this.TexteAGauche;

            if (string.IsNullOrEmpty(this.Libelle) == false)
                paramsValeurs.Ajouter("caseLibelle", this.Libelle);

            if (NotificationSiModif)
                cc.notification = true;

            if (IsReadOnly.HasValue)
                paramsValeurs.Ajouter("lectureSeule", (bool)IsReadOnly ? "true" : "false");

            if (Presentation != null)
                this.Presentation.GenererHtml(paramsValeurs, this.Page.Html,0,false);

            paramsValeurs.Ajouter("pointSequence", this.SeqPoint.ToString(), page.NumPage.ToString());

            string parametresJson = HtmlGlobal.ToJsonString(cc, this.Page.Html.JsonParametresCaseACocher, false);
            paramsCreation.Ajouter("paramsCreation", parametresJson);

            //UnParametreEnvoye p = new UnParametreEnvoye();

            envois.Ajouter("creerCaseACocher", HtmlGlobal.ToJsonString(paramsCreation, this.Page.Html.JsonParamsEnvoyes, false), HtmlGlobal.CalculerId(this.Id, page.Id, niveau));
            //			envois.Ajouter("ajoutObjetCourant", "");
            envois.Ajouter("propsObjet", HtmlGlobal.ToJsonString(paramsValeurs, this.Page.Html.JsonParamsEnvoyes, false));
        }
示例#9
0
        //#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", "");
        }
示例#10
0
 public void AjouterEnvoisUnObjet(ListeParametresEnvoyes envois,XHtmlPage page,int niveau)
 {
     throw new NotImplementedException();
 }
示例#11
0
        /*
        #region Ecouteurs
        /// <summary>
        /// Gestionnaire d'évènement "PreviewKeyDown" pour la fonction XMEInput
        /// </summary>
        ///
        private 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;
            }

            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 ((e.Key == Key.Return && !IsDropDownOpen) ||			// ne pas traiter quand combobox ouverte : géré par wpf
                        (e.Key == Key.Enter && !IsDropDownOpen) ||		// ne pas traiter quand combobox ouverte : géré par wpf
                        (e.Key == Key.Escape && !IsDropDownOpen) ||		// ne pas traiter quand combobox ouverte : géré par wpf
                        (e.Key == Key.Back && !IsDropDownOpen) ||			// ne pas traiter quand combobox ouverte : géré par wpf
                        (e.Key == Key.Tab && !IsDropDownOpen) ||			// ne pas traiter quand combobox ouverte : géré par wpf
                    //e.Key == Key.Space ||		// ne pas traiter : géré par wpf

                        e.Key == Key.Insert ||

                    //e.Key == Key.Next ||		// ne pas traiter : géré par wpf
                    //e.Key == Key.Prior ||		// ne pas traiter : géré par wpf
                    //e.Key == Key.PageDown ||	// ne pas traiter : géré par wpf
                    //e.Key == Key.PageUp ||	// ne pas traiter : géré par wpf
                    //e.Key == Key.Down ||		// ne pas traiter : géré par wpf
                    //e.Key == Key.Up ||			// ne pas traiter : géré par wpf

                        (((Keyboard.Modifiers & ModifierKeys.Control) != 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) // refusé si IsReadOnly
            {
                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>
        /// Gestionnaire d'évènement "SelectionChanged" pour la notification
        /// </summary>
        private void SelectionChangedHandler(object sender, SelectionChangedEventArgs e)
        {
            var application = ((App)Application.Current).Appli;

            // on ne notifie pas si le multichoix n'est pas le contrôle actif en input ou si le changement de valeur est fait par programme
            if (ignoreValueChanged || !(application.AttenteInput && Page.Window.ActiveControl == this)) return;

            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 (byte)
            response.Put(Page.NumPage);
            response.Put(ProprietesWpf.IDENT_UNIQUE);					// Id de la donnée cliquée (uint)
            response.Put(Id);
            response.Put(ProprietesWpf.PARAM_SAISIE_SEQUENCE);		// Numéro du point de séquence de la donnée cliquée (ushort)
            response.Put(SeqPoint);

            response.Put(ProprietesWpf.EVENEMENT_SOURIS_FIN);		// Fin de l'envoi des évenements souris

            response.Put(ProprietesWpf.MULTICHOIX_VALEUR);			// Nouvelle valeur (ushort)
            response.Put((ushort)(SelectedIndex + 1));

            application.Send(response);
        }

        /// <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
        */
        /// <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)
        {
            ComboBoxVersJson cb = new ComboBoxVersJson();

            if (this.imageComboBox)
            {
                cb.formatSelection = "imageMultiChoix";
                cb.formatResult = "imageMultiChoix";
            }
            else
            {
                cb.formatSelection = "texteMultiChoix";
                cb.formatResult = "texteMultiChoix";
            }

            ListeParametresEnvoyes paramsValeurs = new ListeParametresEnvoyes();
            ListeParametresEnvoyes paramsCreation = new ListeParametresEnvoyes();

            // surtout pas, car ca casse le s2id			paramsValeurs.Ajouter("idObjet", HtmlGlobal.CalculerId(this.Id, page.Id, niveau));

            if (Presentation != null)
                this.Presentation.GenererHtml(paramsValeurs, this.Page.Html, 0,false);

            paramsValeurs.Ajouter("pointSequence", this.SeqPoint.ToString(), page.NumPage.ToString());

            if (IsReadOnly.HasValue)
                paramsValeurs.Ajouter("lectureSeule", (bool)IsReadOnly ? "true" : "false");

            int cpt = 0;
            foreach (UnItemMultiChoix item in Items)
            {
                UnItemJson j = new UnItemJson();
                j.id = cpt.ToString();
                cpt++;
                j.text = item.Libelle;
                cb.data.results.Add(j);
            }

            cb.autoOpen = autoOpen;

            if (this.PositionRecue.HasValue)
                cb.position = this.PositionRecue.Value.ToString();

            //			string datasJson = HtmlGlobal.ToJsonString(datas, this.Page.Html.JsonDataComboBox, false);
            string parametresJson = HtmlGlobal.ToJsonString(cb, this.Page.Html.JsonParametresComboBox, false);

            //		paramsCreation.Ajouter("liste", datasJson);
            paramsCreation.Ajouter("paramsCreation", parametresJson);

            envois.Ajouter("creerMultiChoix", HtmlGlobal.ToJsonString(paramsCreation, this.Page.Html.JsonParamsEnvoyes, false), HtmlGlobal.CalculerId(this.Id, page.Id, niveau));

            // je met les coordonnées + couleurs etc sur l'objet hidden, comme ca si on recrée l'objet (liste de choix modifiée), on reprend
            // les bonnes caractéristiques
            paramsValeurs.Ajouter("idPage", this.Page.Html.CalculerIdPage(page.Id));
            envois.Ajouter("propsObjet", HtmlGlobal.ToJsonString(paramsValeurs, this.Page.Html.JsonParamsEnvoyes, false));

            // j'envoie la meme chose pour le conteneur du combo
            envois.Ajouter("setObjetCourant", "s2id_" + HtmlGlobal.CalculerId(this.Id, page.Id, niveau));
            paramsValeurs.Ajouter("idPage", this.Page.Html.CalculerIdPage(page.Id));
            envois.Ajouter("propsObjet", HtmlGlobal.ToJsonString(paramsValeurs, this.Page.Html.JsonParamsEnvoyes, false));
        }
示例#12
0
        /// <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;
        }
示例#13
0
        //#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)
        //   {
        //      e.Handled = true;
        //      return;
        //   }
        //   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 && ValidModifiedKeys.Contains(e.Key)))
        //         key = e.Key.ToString();
        //      else if (e.Key != Key.Left && e.Key != Key.Right) return; // les touches restantes ne sont pas bloquées, excepté flèches droite et gauche
        //   }
        //   e.Handled = true;
        //   application.SendInputKeyDown(key);
        //}
        ///// <summary>
        ///// Gestionnaire d'évènement "Click" du bouton
        ///// </summary>
        //private void ClickHandler(object sender, RoutedEventArgs e)
        //{
        //   e.Handled = true;
        //   var application = ((App)Application.Current).Appli;
        //   var client = ((App)Application.Current).Client;
        //   if (application.AttenteInput || application.AttenteConsult || (application.AttenteGetb && action == 3))	// input ou consult ou get bloquant (traité AVANT le GetBegin car on peut être en GetBegin et faire un input/consult/get bloquant)
        //   {
        //      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)
        //      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(pointTraitement); break;				// Type = 1 : point de traitement
        //         case 2: response.Put(pointArret); break;						// Type = 2 : point d'arrêt
        //         case 3: response.PutString(generatedString); break;		// Type = 3 : chaîne à générer
        //      }
        //      response.Put(ProprietesWpf.EVENEMENT_SOURIS_FIN);			// Fin de l'envoi des évenements souris
        //      application.Send(response);
        //      return;
        //   }
        //   if (client != null && client.GetBegin > 0 && action == 3)	// get non bloquant sur bouton "chaîne" (les autres types sont ignorés)
        //      client.Transport.EnvoyerUnGet("##" + OutilsString.ToHexa(generatedString));
        //}
        ///// <summary>
        ///// Gestionnaire d'effets du clic bouton (pour sons, curseurs et images)
        ///// </summary>
        //private void PreviewMouseDownEffectsHandler(object sender, RoutedEventArgs e)
        //{
        //   if (soundClick == null || !IsEnabled) return;
        //   player.Open(soundClick);
        //   player.Play();
        //}
        ///// <summary>
        ///// Gestionnaire d'effets du mouseOver bouton (pour sons, curseurs et images)
        ///// </summary>
        //private void MouseOverEffectsHandler(object sender, RoutedEventArgs e)
        //{
        //   if (IsMouseOver && IsEnabled)
        //   {
        //      if (imageMouseOver != null) Content = imageMouseOver;
        //      if (cursorMouseOver != null) Mouse.OverrideCursor = cursorMouseOver;
        //      if (soundMouseOver != null)
        //      {
        //         player.Open(soundMouseOver);
        //         player.Play();
        //      }
        //   }
        //   else if (!IsMouseOver)
        //   {
        //      if (text != null) Content = text;
        //      else if (image != null) Content = image;
        //      Mouse.OverrideCursor = null;
        //   }
        //}
        ///// <summary>
        ///// 
        ///// </summary>
        //private void LostFocusEventHandler(object sender, RoutedEventArgs e)
        //{
        //   Focusable = false; // garde-fou. Le Focusable est repassé à true lors du passage en input (pour éviter qu'un bouton ne prenne le focus sans qu'on ne l'y autorise)
        //}
        //#endregion Ecouteurs
        public void AjouterEnvoisUnObjet(ListeParametresEnvoyes envois, XHtmlPage page, int niveau)
        {
            ListeParametresEnvoyes paramsValeurs = new ListeParametresEnvoyes();

            if (Presentation != null)
                this.Presentation.GenererHtml(paramsValeurs,this.Page.Html,this.codePage,false);

            paramsValeurs.Ajouter("idObjet", HtmlGlobal.CalculerId(this.Id, page.Id, niveau), this.Page.Html.CalculerIdPage(page.Id)); //   this.Id.ToString());

            if (string.IsNullOrEmpty(this.text) == false)
                paramsValeurs.Ajouter("textBouton", this.text);
            //else
            //	paramsValeurs.Ajouter("textBouton", "pas de texte");

            if (imageDuBouton != null && string.IsNullOrEmpty(imageDuBouton.FileName) == false)
            {
                paramsValeurs.Ajouter("imagebouton", imageDuBouton.FileName.Replace('.','_'));
            }

            if (this.IsLocal)
                paramsValeurs.Ajouter("boutonLocal", "true");

            if (string.IsNullOrEmpty(this.Selection) == false)
                paramsValeurs.Ajouter("boutonNomSelection", Selection);

            UnParametreComplementaire compl;
            ListeParametresComplementaires compls = new ListeParametresComplementaires();
            compls.Ajouter("action:",action.ToString());
            compl = compls.Ajouter("param", "0");
            switch (action)
            {
                case 1: compl.v = pointTraitement.ToString(); break;				// Type = 1 : point de traitement
                case 2: compl.v = pointArret.ToString(); break;					// Type = 2 : point d'arrêt
                case 3: compl.v = generatedString; break;							// Type = 3 : chaîne à générer
            }

            string chaineAction = HtmlGlobal.ToJsonString(compls, this.Page.Html.JsonParamCompl,false);

            paramsValeurs.Ajouter("actionBouton", chaineAction.Replace("'", @"#quote"));

            envois.Ajouter("creerBouton", "<button></button>", HtmlGlobal.CalculerId(this.Id, page.Id, niveau));
            envois.Ajouter("propsObjet", HtmlGlobal.ToJsonString(paramsValeurs, this.Page.Html.JsonParamsEnvoyes, false));
            envois.Ajouter("ajoutObjetCourant", "");

            //			chaineAction = "data-harmony=" + "'" + chaineAction.Replace("'",@"#quote") + "'";
            //string id = "id=" + this.Id.ToString();
            //UnParametreEnvoye p = new UnParametreEnvoye();
            //envois.commandes.Add(p);
            //p.commande = "bouton";
            //p.valeur = "<button " + id + " " + css + " " + chaineAction +">" + this.text + "</button>";
        }