Example #1
0
        //------------------------------------------------
        public static Image CalculeNewImage(Type tp)
        {
            if (tp != null)
            {
                Image img = DynamicClassAttribute.GetImage(tp);
                if (img != null)
                {
                    Bitmap   bmp = new Bitmap(16, 16);
                    Graphics g   = Graphics.FromImage(bmp);

                    ColorMatrix cm = new ColorMatrix();
                    cm.Matrix33 = 0.75f;
                    ImageAttributes ia = new ImageAttributes();
                    ia.SetColorMatrix(cm);
                    Image imgListe = Resources.view_list;
                    g.DrawImage(Resources.view_list, new Rectangle(0, 0, 16, 16), 0, 0, imgListe.Width, imgListe.Height,
                                GraphicsUnit.Pixel, ia);
                    ia.Dispose();
                    g.DrawImage(img, 4, 4, 12, 12);
                    g.Dispose();
                    return(bmp);
                }
            }
            return(Resources.view_list);
        }
Example #2
0
 /// ////////////////////////////////////////////////////////
 public static Image GetImage(Type tp)
 {
     try
     {
         //Nom d'image : le nom du type suivi de gif
         string[] strNoms     = tp.ToString().Split('.');
         string   strNomImage = strNoms[strNoms.Length - 1] + ".bmp";
         Image    img         = DynamicClassAttribute.GetImage(tp);
         if (img != null)
         {
             return(img);
         }
         try
         {
             img = new Bitmap(tp, strNomImage);
         }
         catch {}
         if (img == null)
         {
             strNomImage = strNomImage[strNomImage.Length] - 1 + ".png";
             img         = new Bitmap(tp, strNomImage);
         }
         return(img);
     }
     catch { }
     return(null);
 }
 //---------------------------------------------------------------
 public CFormPhaseSpecificationsPopup()
     : base()
 {
     InitializeComponent();
     m_picPhase.Image = DynamicClassAttribute.GetImage(typeof(CPhaseSpecifications));
     CWin32Traducteur.Translate(this);
 }
        //------------------------------------------------------------------
        private void SynchronizeTexteEtObjet()
        {
            m_link.Text = Text;
            Image img = null;

            if (SelectedObject != null)
            {
                img = DynamicClassAttribute.GetImage(SelectedObject.GetType());
            }
            UpdateImage();
        }
        //------------------------------------------------------------------
        public CFormChercheIntervenant()
        {
            InitializeComponent();
            m_controlPlanning.BaseAffichee = new CFournisseurEntreesPlanning(CSc2iWin32DataClient.ContexteCourant);
            CWin32Traducteur.Translate(this);
            Image img = DynamicClassAttribute.GetImage(typeof(CActeur));

            if (img != null)
            {
                m_picActeur.Image = img;
            }
        }
Example #6
0
 public virtual Image GetImage()
 {
     if (m_objetEdite != null)
     {
         Image img = DynamicClassAttribute.GetImage(m_objetEdite.GetType());
         if (img != null)
         {
             return(img);
         }
     }
     return(Resources.view_edit);
 }
Example #7
0
        private ToolStripItem CreateItemSatisfaction(IElementACout utilisateur, IElementACout source)
        {
            CImputationsCouts imputation = source.GetImputationsAFaireSurUtilisateursDeCout();

            if (imputation != null)
            {
                CImputationCout i = imputation.GetImputation(utilisateur);
                if (i != null && i.Poids != 0)
                {
                    double            fVal             = imputation.GetCoutImputéeA(utilisateur, m_bMenuForCoutReel);
                    ToolStripMenuItem itemElementACout = new ToolStripMenuItem();
                    itemElementACout.Text = fVal.ToString("0.####") + "   ";
                    if (source is ISatisfactionBesoin)
                    {
                        itemElementACout.Text += ((ISatisfactionBesoin)source).LibelleSatisfactionComplet;
                    }
                    else
                    {
                        itemElementACout.Text += source.Libelle;
                    }
                    if (source is ISatisfactionBesoin && utilisateur is CBesoin)
                    {
                        double fPct = CUtilSatisfaction.GetPourcentageFor((CBesoin)utilisateur, (ISatisfactionBesoin)source);
                        itemElementACout.Text += " (" + fPct.ToString("0.##") + "%)";
                    }
                    else
                    {
                        itemElementACout.Text += "  (100%)";
                    }


                    itemElementACout.Tag   = source;
                    itemElementACout.Image = DynamicClassAttribute.GetImage(source.GetType());
                    if (fVal == 0)
                    {
                        itemElementACout.BackColor = Color.LightPink;
                    }
                    if (source.GetSourcesDeCout(m_bMenuForCoutReel).Length > 0)
                    {
                        ToolStripMenuItem dummy = new ToolStripMenuItem();
                        itemElementACout.DropDownItems.Add(dummy);
                        itemElementACout.DropDownOpening += new EventHandler(itemElementACout_DropDownOpening);
                    }
                    itemElementACout.MouseUp += new MouseEventHandler(itemElementACout_MouseUp);
                    return(itemElementACout);
                }
            }
            return(null);
        }
Example #8
0
        //------------------------------------------------------------------
        public void SelectObject()
        {
            string strText = m_textBox.Text;
            HashSet <CReferenceEntiteMemoryDb> lstRefs = null;

            if (m_dicIntellisense != null && m_dicIntellisense.TryGetValue(strText.ToUpper(), out lstRefs))
            {
                if (lstRefs.Count == 1)
                {
                    if (m_currentMemoryDb != null)
                    {
                        SelectedObject = lstRefs.ElementAt(0).GetEntity(m_currentMemoryDb);
                    }
                    return;
                }
            }
            if (m_configDefaut == null && m_listeConfigs.Count == 1)
            {
                m_configDefaut = m_listeConfigs[0];
            }
            if (m_configDefaut == null)
            {
                foreach (IDisposable dis in new ArrayList(m_menuChooseType.Items))
                {
                    dis.Dispose();
                }
                m_menuChooseType.Items.Clear();
                foreach (CConfigTextBoxSelectMemoryDb config in m_listeConfigs)
                {
                    ToolStripMenuItem itemSelectType = new ToolStripMenuItem(config.LibelleConfig);
                    itemSelectType.Tag = config;
                    Image img = DynamicClassAttribute.GetImage(config.TypeObjets);
                    if (img != null)
                    {
                        itemSelectType.Image = img;
                    }
                    m_menuChooseType.Items.Add(itemSelectType);
                    itemSelectType.Click += new EventHandler(itemSelectType_Click);
                }
                if (m_menuChooseType.Items.Count > 0)
                {
                    m_menuChooseType.Show(m_btn, new Point(0, m_btn.Height));
                }
            }
            else
            {
                SelectObject(m_configDefaut);
            }
        }
Example #9
0
        //-----------------------------------------------------------------------------------
        private void FillNodeType(TreeNode node, Type tp)
        {
            node.ImageIndex = 0;
            node.Tag        = tp;
            node.Text       = DynamicClassAttribute.GetNomConvivial(tp);
            Image img = DynamicClassAttribute.GetImage(tp);

            if (img != null)
            {
                m_treeImages.Images.Add(img);
                node.ImageIndex = m_treeImages.Images.Count - 1;
            }
            node.SelectedImageIndex = node.ImageIndex;
            node.Checked            = false;
        }
Example #10
0
        //-------------------------------------------------------------------------
        private void UpdateImage()
        {
            Image img = null;

            if (m_imageSpecifique != null)
            {
                m_picType.Image = m_imageSpecifique;
            }
            else
            {
                if (m_listeConfigs.Count == 1)
                {
                    img = DynamicClassAttribute.GetImage(m_listeConfigs[0].TypeObjets);
                }
                else
                {
                    if (SelectedObject != null)
                    {
                        img = DynamicClassAttribute.GetImage(SelectedObject.GetType());
                    }
                    else
                    {
                        img = null;
                    }
                }
            }
            m_picType.Image = img;
            switch (m_modeIcone)
            {
            case EModeAffichageImageTextBoxRapide.Never:
                m_picType.Visible = false;
                break;

            case EModeAffichageImageTextBoxRapide.Always:
                m_picType.Visible = img != null;
                break;

            case EModeAffichageImageTextBoxRapide.OnSelection:
                m_picType.Visible = img != null && SelectedObject != null;
                break;

            default:
                break;
            }
        }
Example #11
0
        //--------------------------------------------------------
        private static Image GetImageComplement(ETypeDonneeBesoin type)
        {
            switch (type)
            {
            case ETypeDonneeBesoin.QuantiteCU:
                return(Resource.donneeBesoinQuantite);

                break;

            case ETypeDonneeBesoin.TypeEquipement:
                return(DynamicClassAttribute.GetImage(typeof(CEquipement)));

                break;

            /*case ETypeDonneeBesoin.Pourcentage:
             *  return Resource.donneeBesoinPourcentage;
             *  break;*/
            case ETypeDonneeBesoin.BesoinParent:
                return(Resource.donneeBesoinParent);

                break;

            case ETypeDonneeBesoin.TypeConsommable:
                return(DynamicClassAttribute.GetImage(typeof(timos.data.equipement.consommables.CTypeConsommable)));

                break;

            case ETypeDonneeBesoin.Temps:
                return(Resource.donneeBesoinTemps);

                break;

            case ETypeDonneeBesoin.Operation:
                return(DynamicClassAttribute.GetImage(typeof(COperation)));

                break;

            case ETypeDonneeBesoin.Projet:
                return(DynamicClassAttribute.GetImage(typeof(CProjet)));

            default:
                break;
            }
            return(null);
        }
Example #12
0
        //--------------------------------------------------------
        public static Image GetImage(ETypeDonneeBesoin type)
        {
            Image img = null;

            if (m_dicImages.TryGetValue(type, out img))
            {
                return(img);
            }
            Image imgBesoin = DynamicClassAttribute.GetImage(typeof(CBesoin));

            Image complement = GetImageComplement(type);

            if (complement == null)
            {
                m_dicImages[type] = imgBesoin;
                return(imgBesoin);
            }

            img = new Bitmap(imgBesoin.Width, imgBesoin.Height);
            Graphics g = Graphics.FromImage(img);


            //Dessin l'image besoin en fond transparent
            ColorMatrix cm = new ColorMatrix();

            cm.Matrix33 = 0.25f;
            ImageAttributes ia = new ImageAttributes();

            ia.SetColorMatrix(cm);
            g.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
            g.InterpolationMode  = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
            g.SmoothingMode      = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
            g.DrawImage(imgBesoin, new Rectangle(0, 0, imgBesoin.Width, imgBesoin.Height), 0, 0, imgBesoin.Width, imgBesoin.Height,
                        GraphicsUnit.Pixel, ia);
            ia.Dispose();

            Size  szComp = new Size((int)(imgBesoin.Width * 0.7), (int)(imgBesoin.Height * 0.7));
            Point pt     = new Point(imgBesoin.Width - szComp.Width, imgBesoin.Height - szComp.Height);

            g.DrawImage(complement, new Rectangle(pt, szComp), new Rectangle(0, 0, complement.Width, complement.Height), GraphicsUnit.Pixel);
            m_dicImages[type] = img;
            g.Dispose();
            return(img);
        }
        //------------------------------------------------------------------------
        public void Init(CDroitEditionType droit)
        {
            List <CCustomizableListItem> items     = new List <CCustomizableListItem>();
            CParametreDroitEditionType   parametre = droit.ParametreDroits;

            if (droit.TypeElements != null)
            {
                m_picType.Image = DynamicClassAttribute.GetImage(droit.TypeElements);
                m_lblType.Text  = DynamicClassAttribute.GetNomConvivial(droit.TypeElements);
                ((CEditeurDroitTypeEdition)ItemControl).TypeObjets = droit.TypeElements;
                foreach (CParametreDroitEditionType.CCoupleFormuleToGroupeRestrictions couple in parametre.CouplesFormuleGroupe)
                {
                    CCustomizableListItem item = new CCustomizableListItem();
                    item.Tag = CCloner2iSerializable.Clone(couple) as CParametreDroitEditionType.CCoupleFormuleToGroupeRestrictions;
                    items.Add(item);
                }
            }
            Items = items.ToArray();
            Refill();
        }
        /// ////////////////////////////////////////////
        private void CFormSelectUneEntiteMemoryDb_Load(object sender, System.EventArgs e)
        {
            // Lance la traduction du formulaire
            sc2i.win32.common.CWin32Traducteur.Translate(this);

            if (m_listeObjets != null)
            {
                m_imageType.Image = DynamicClassAttribute.GetImage(m_listeObjets.TypeElements);
            }
            m_lblInstructions.Text = m_strInstructions;


            Text = sc2i.common.DynamicClassAttribute.GetNomConvivial(m_typeObjets);
            //if ( m_filtreRechercheRapide == null && m_typeObjets != null)
            //	m_filtreRechercheRapide = CFournisseurFiltreRapide.GetFiltreRapideForType ( m_typeObjets );
            if (m_filtreRechercheRapide == null || !m_filtreRechercheRapide.HasFiltre)
            {
                m_panelRecherche.Visible = false;
            }
            RefreshListe();
        }
Example #15
0
        public void ShowMenuDetailCalcul(
            IElementACout utilisateur,
            CItemBesoin itemBesoin,
            ContextMenuStrip menu,
            bool bCoutReel,
            Control ctrlRepere)
        {
            m_bMenuForCoutReel = bCoutReel;
            foreach (ToolStripItem item in new ArrayList(menu.Items))
            {
                menu.Items.Remove(item);
                item.Dispose();
            }
            if (utilisateur != null)
            {
                foreach (IElementACout elt in utilisateur.GetSourcesDeCout(bCoutReel))
                {
                    ToolStripItem item = CreateItemSatisfaction(utilisateur, elt);
                    if (item != null)
                    {
                        menu.Items.Add(item);
                    }
                }
                if (menu.Items.Count > 0)
                {
                    menu.Items.Add(new ToolStripSeparator());
                }

                ToolStripMenuItem itemSatisfaction = new ToolStripMenuItem();
                double            fCout            = bCoutReel ? utilisateur.CoutReel : utilisateur.CoutPrevisionnel;
                itemSatisfaction.Text  = (menu.Items.Count > 0 ? "--->" : "") + fCout.ToString("0.####");
                itemSatisfaction.Image = Resources.PuzzleMal20;
                menu.Items.Add(itemSatisfaction);

                bool bShouldAddSeparateur = true;

                if (itemBesoin != null)
                {
                    foreach (CItemBesoin childItem in itemBesoin.ChildItems)
                    {
                        if (childItem.Besoin.GetImputationsAFaireSurUtilisateursDeCout().GetCoutImputéeA(utilisateur, bCoutReel) == 0)
                        {
                            if (bShouldAddSeparateur)
                            {
                                menu.Items.Add(new ToolStripSeparator());
                            }
                            bShouldAddSeparateur = false;
                            ToolStripMenuItem item = new ToolStripMenuItem();
                            double            fVal = bCoutReel ? childItem.CoutReel : childItem.CoutPrevisionnel;
                            item.Text  = fVal.ToString("0.####") + "   " + childItem.Besoin.Libelle;
                            item.Image = DynamicClassAttribute.GetImage(childItem.Besoin.GetType());
                            menu.Items.Add(item);
                        }
                    }
                }
            }
            if (menu.Items.Count > 0)
            {
                menu.Show(ctrlRepere, new Point(0, ctrlRepere.Height));
            }
        }