Esempio n. 1
0
		/// <summary>
		/// Initializes a new instance of the XwpfPage class.
		/// </summary>
		public XHtmlPage(XHtmlWindow window,HtmlGlobal html)
		{
		// !!!!!!!	InitializeComponent();
			Init();
			Window = window;
			Html = html;
			Page = this;

			// écouteurs sur le "MainCanvas" de la fenêtre pour largeur / hauteur variable et attachements
			// !!!!!!!!!!!! Window.MainCanvas.SizeChanged += MainCanvasSizeChangedHandler;

			// on empêche tout clic (IsHitTestVisible = false inutilisable car hérité par tous les enfants)
			// !!!!!!!!!!!!!!!! MouseDown += (sender, e) => { e.Handled = true; };
		}
Esempio n. 2
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;
        }
        /// <summary>
        /// Création d'un Padding
        /// </summary>
        internal static void Create(DVBuffer buffer,HtmlGlobal html)
        {
            XHtmlPadding padd = new XHtmlPadding();
            html.App.PaddingCss.Add(padd);

            buffer.Get(out padd.Id);

            ProprietesWpf property;
            buffer.Get(out property);
            while (property != ProprietesWpf.PADDING_CREATION_FIN)
            {
                switch (property)
                {
                    case ProprietesWpf.PADDING_VERTICAL:		// Epaisseur de la bordure (byte)
                        byte verticalPadding;
                        buffer.Get(out verticalPadding);
                        padd.Vertical = verticalPadding;
                        padd.Vide = false;
                        //XHtmlApplication.Resources.Add("VerticalPadding-" + id, (double?)verticalPadding);
                        break;

                    case ProprietesWpf.PADDING_HORIZONTAL:		// Epaisseur de la bordure (byte)
                        byte horizontalPadding;
                        buffer.Get(out horizontalPadding);
                        padd.Horizontal = horizontalPadding;
                        padd.Vide = false;
                        //XHtmlApplication.Resources.Add("HorizontalPadding-" + id, (double?)horizontalPadding);
                        break;

                    default:
                        throw new XHtmlException(XHtmlErrorCodes.UnknownProperty, XHtmlErrorLocations.Padding, property.ToString());
                }
                buffer.Get(out property);
            }
            padd.Css = padd.GenererCss();
        }
        internal static void Create(DVBuffer buffer, HtmlGlobal html)
        {
            XHtmlFont font = new XHtmlFont();

            buffer.Get(out font.Id);
            font.ReadProperties(buffer);
            font.Css = font.GenererCss();

            html.App.PolicesCss.Add(font);

            //if (font.R.HasValue)
            //{
            //   XHtmlColor color = new XHtmlColor();
            //   color.R = font.R;
            //   color.G = font.G;
            //   color.B = font.B;
            //   color.Id = font.Id;
            //   color.Prefixe = XHtmlFont.PrefixeCss;			// meme prfixe que la fonte

            //   HtmlGlobal.App.CouleursCss.Add(color);

            //}

            //!!!!!!!!!!!!			Application.Resources.Add("Font-" + id, font);
        }
        /// <summary>
        /// Création d'une XHtmlCouleur
        /// </summary>
        internal static void Create(DVBuffer buffer,HtmlGlobal html)
        {
            XHtmlColor color = new XHtmlColor();

            html.App.CouleursCss.Add(color);

            buffer.Get(out color.Id);

            ProprietesWpf property;
            buffer.Get(out property);
            while (property != ProprietesWpf.COULEUR_CREATION_FIN)
            {
                switch (property)
                {
                    case ProprietesWpf.COULEUR_RVB:		// Couleur : Rouge (byte); Vert (byte); Bleu (byte)
                        byte a, r, g, b;
                        color.Vide = false;
                        buffer.Get(out a);
                        buffer.Get(out r);
                        buffer.Get(out g);
                        buffer.Get(out b);
                        color.A = a;
                        color.R = r;
                        color.G = g;
                        color.B = b;
                        color.Transparente = (a == 0);

                        break;

                    default:
                        throw new XHtmlException(XHtmlErrorCodes.UnknownProperty, XHtmlErrorLocations.Color, property.ToString());
                }
                buffer.Get(out property);
            }
            color.Css = color.GenererCss();
        }
        /// <summary>
        /// Création d'une Bordure
        /// </summary>
        /// 
        internal static void Create(DVBuffer buffer,HtmlGlobal html)
        {
            XHtmlBorder bordure = new XHtmlBorder();
            html.App.BorduresCss.Add(bordure);

            buffer.Get(out bordure.Id);

            ProprietesWpf property;
            buffer.Get(out property);
            while (property != ProprietesWpf.BORDURE_CREATION_FIN)
            {
                switch (property)
                {
                    case ProprietesWpf.BORDURE_COULEUR:			// Couleur de la bordure : Rouge (byte); Vert (byte); Bleu (byte)
                        byte r, g, b;
                        buffer.Get(out r);
                        buffer.Get(out g);
                        buffer.Get(out b);
                        bordure.B = b;
                        bordure.G = g;
                        bordure.R = r;
                        bordure.Vide = false;
                        //!!!!!!!!!!!!!!!!!!!!!!!!
                        //var brush = new SolidColorBrush(Color.FromArgb(255, r, g, b));
                        //brush.Freeze();
                        //Application.Current.Resources.Add("BorderBrush-" + id, brush);
                        break;

                    case ProprietesWpf.BORDURE_EPAISSEUR:		// Epaisseur de la bordure (byte)
                        byte thickness;
                        buffer.Get(out thickness);
                        bordure.Epaisseur = thickness;
                        bordure.Vide = false;
            //!!!!!!!!!!						Application.Current.Resources.Add("BorderThickness-" + id, (double?)thickness);
                        break;

                    default:
                        throw new XHtmlException(XHtmlErrorCodes.UnknownProperty, XHtmlErrorLocations.Border, property.ToString());
                }
                buffer.Get(out property);
            }
            bordure.Css = bordure.GenererCss();
        }