Example #1
0
        // Token: 0x06000081 RID: 129 RVA: 0x000046AC File Offset: 0x000028AC
        protected override void FillTab()
        {
            float            num   = 50f;
            Rect             rect  = GenUI.ContractedBy(new Rect(0f, num, this.size.x, this.size.y), 5f);
            List <TabRecord> pages = new List <TabRecord>();
            TabRecord        item  = new TabRecord("Manage", delegate()
            {
                ITab_BellManager.tab = ITab_BellManager.ArenaCardTab.Manager;
            }, ITab_BellManager.tab == ITab_BellManager.ArenaCardTab.Manager);

            pages.Add(item);
            TabRecord item2 = new TabRecord("Leaderboard", delegate()
            {
                ITab_BellManager.tab = ITab_BellManager.ArenaCardTab.Leaderboard;
            }, ITab_BellManager.tab == ITab_BellManager.ArenaCardTab.Leaderboard);

            pages.Add(item2);
            TabDrawer.DrawTabs(rect, pages, 200f);
            Rect rectTabs = new Rect(0f, num, rect.width, rect.height - num);

            bool flag = ITab_BellManager.tab == ITab_BellManager.ArenaCardTab.Manager;

            if (flag)
            {
                this.FillTabManager(rectTabs);
            }
            else
            {
                bool flag2 = ITab_BellManager.tab == ITab_BellManager.ArenaCardTab.Leaderboard;
                if (flag2)
                {
                    this.FillTabLeaderboard(rectTabs);
                }
            }
        }
Example #2
0
        public Page_PrepareCarefully()
        {
            this.closeOnCancel         = false;
            this.closeOnAccept         = false;
            this.closeOnClickedOutside = false;
            this.doCloseButton         = false;
            this.doCloseX = false;

            // Add the tab views to the tab view list.
            tabViews.Add(tabViewPawns);
            tabViews.Add(tabViewRelationships);
            tabViews.Add(tabViewEquipment);

            // Create a tab record UI widget for each tab view.
            foreach (var tab in tabViews)
            {
                ITabView  currentTab = tab;
                TabRecord tabRecord  = new TabRecord(currentTab.Name, delegate {
                    // When a new tab is selected, mark the previously selected TabRecord as unselected and the current one as selected.
                    // Also, update the State to reflected the newly selected ITabView.
                    if (State.CurrentTab != null)
                    {
                        State.CurrentTab.TabRecord.selected = false;
                    }
                    State.CurrentTab = currentTab;
                    currentTab.TabRecord.selected = true;
                }, false);
                currentTab.TabRecord = tabRecord;
                tabRecords.Add(tabRecord);
            }
        }
Example #3
0
        public static void AddItems()
        {
            {
                Project p = new Project();
                p.Name = "Тестовый проект";

                Tab tab = new Tab();
                tab.Name = "Вкладка";

                TabRecord tmp = new TabRecord();
                tmp.Name   = "Лолка";
                tmp.Type   = "Шт";
                tmp.Count  = 1;
                tmp.Real   = 1488;
                tmp.Charge = 10;
                tmp.Usn    = true;

                tab.TabRecords.Add(tmp);

                p.Tabs.Add(tab);

                projectsContext.Projects.Add(p);
                projectsContext.SaveChanges();
            }
        }
Example #4
0
        public override void DoWindowContents(Rect inRect)
        {
            Rect rect = new Rect(inRect);

            rect        = rect.ContractedBy(18f);
            rect.height = 34f;
            Text.Font   = GameFont.Medium;
            Widgets.Label(rect, GetTitle());

            Rect rect2 = new Rect(inRect);

            rect2.yMin  = rect.yMax;
            rect2.yMax -= 38f;

            Rect rect3 = rect2;

            rect3.yMin += 45f;

            List <TabRecord> list = new List <TabRecord>();
            TabRecord        item = new TabRecord("TabStats".Translate(), delegate
            {
                tab = InfoCardTab.Stats;
            }, tab == InfoCardTab.Stats);

            list.Add(item);

            TabDrawer.DrawTabs(rect3, list);
            FillCard(rect3.ContractedBy(18f));
        }
Example #5
0
        /// <inheritdoc />
        public override void Draw(Rect inRect)
        {
            // Do nothing if there's no tabs
            if (tabs.Count == 0)
            {
                return;
            }

            // Ok, so for whatever reason the tabs are drawn /above/ whatever region you give them (why?!)
            // To work around this we just trim the tab height off of the container rect
            inRect = inRect.BottomPartPixels(inRect.height - TabDrawer.TabHeight);

            // We draw the top with tabs
            TabRecord selectedRecord = TabDrawer.DrawTabs(inRect, tabs.Select(e => e.tab).ToList());

            // Change the selected record if it was clicked
            if (selectedRecord != null)
            {
                selectedTab = tabs.IndexOf(tabs.Single(tabEntry => tabEntry.tab.label == selectedRecord.label));
                onTabChange?.Invoke(selectedTab);
            }

            // We draw the selected tab
            Displayable selectedDisplayable = tabs[selectedTab].displayable;

            selectedDisplayable.Draw(inRect);
        }
Example #6
0
 private void SetUpTabs()
 {
     activeTab    = previewsTab = new TabRecord("Reroll2_previews_previewsTab".Translate(), () => OnTabSelected(0), false);
     favoritesTab = new TabRecord(string.Empty, () => OnTabSelected(1), false);
     tabs         = new List <TabRecord> {
         previewsTab, favoritesTab
     };
 }
        public ExporterWindow(Project proj, ExportType type)
        {
            InitializeComponent();

            CurrentProject = proj;

            foreach (var tab in CurrentProject.Tabs)
            {
                int    i   = 1;
                double sum = 0;

                foreach (var item in tab.TabRecords)
                {
                    item.Number = i;
                    sum        += item.Price;
                    i++;
                }

                //Добавить расходные материалы
                if (tab.PartsCharge != 0)
                {
                    TabRecord parts = new TabRecord();
                    parts.Number = i;
                    parts.Name   = "Расходные материалы";
                    parts.Type   = "%";
                    parts.Count  = tab.PartsCharge;
                    parts.Real   = (int)sum / 100;

                    tab.TabRecords.Add(parts);
                    i++;
                }

                //Добавить накладные расходы
                if (tab.WorkCharge != 0)
                {
                    TabRecord works = new TabRecord();
                    works.Number = i;
                    works.Name   = "Накладные расходы";
                    works.Type   = "%";
                    works.Count  = tab.WorkCharge;
                    works.Real   = (int)sum / 100;

                    tab.TabRecords.Add(works);
                    i++;
                }
            }

            if (type == ExportType.Pdf)
            {
                PdfExportCheck.IsChecked = true;
            }
            else
            {
                ExcelExportCheck.IsChecked = true;
            }

            InfoGrid.ItemsSource = InfoList;
        }
Example #8
0
        public void AddTab(string label, Displayable displayable)
        {
            int       index = tabs.Count;
            TabRecord tab   = new TabRecord(label, () => selectedTab = index, selectedTab == index);

            tabs.Add(new TabEntry {
                tab = tab, displayable = displayable
            });
        }
Example #9
0
        // Token: 0x0600007F RID: 127 RVA: 0x000042F0 File Offset: 0x000024F0
        public void AddTab(string label, Displayable displayable)
        {
            var index = tabs.Count;
            var tab   = new TabRecord(label, delegate { selectedTab = index; }, selectedTab == index);

            tabs.Add(new TabEntry
            {
                tab         = tab,
                displayable = displayable
            });
        }
Example #10
0
        /// <summary>
        /// Adds a tab to the container.
        /// </summary>
        /// <param name="label">Label shown on the tab itself</param>
        /// <param name="displayable">Contents of the tab</param>
        public void AddTab(string label, Displayable displayable)
        {
            // Set the current index to where this new tab will be
            int index = tabs.Count;

            // Create a tab record
            TabRecord tab = new TabRecord(label, () =>
            {
                selectedTab = index;
                onTabChange(index);
            }, selectedTab == index);

            // Add the tab to the tab list
            tabs.Add(new TabEntry {
                tab = tab, displayable = displayable
            });
        }
Example #11
0
        public static void DrawNewColonistTab(this TabRecord tab, Rect rect)
        {
            if (rect.Contains(Event.current.mousePosition))
            {
                GUI.color = new Color(1, 1, 1, 0.7f);
            }
            else
            {
                GUI.color = new Color(1, 1, 1, 0.2f);
            }
            Rect drawRect = new Rect(rect);

            drawRect.width = 30;
            Rect drawRect2 = new Rect(rect);

            drawRect2.width = 30;
            drawRect2.x     = rect.x + rect.width - 30;
            Rect texRect   = new Rect(0.53125f, 0, 0.46875f, 1);
            Rect drawRect3 = new Rect(rect);

            drawRect3.x     += drawRect.width;
            drawRect3.width -= 60;
            Rect texRect2 = new Rect(30, 0, 4, (float)Textures.TextureTabAtlas.height).ToUVRect(new Vector2((float)Textures.TextureTabAtlas.width, (float)Textures.TextureTabAtlas.height));

            Widgets.DrawTexturePart(drawRect, new Rect(0, 0, 0.46875f, 1), Textures.TextureTabAtlas);
            Widgets.DrawTexturePart(drawRect3, texRect2, Textures.TextureTabAtlas);
            Widgets.DrawTexturePart(drawRect2, texRect, Textures.TextureTabAtlas);
            Rect rect2 = rect;

            GUI.color = new Color(0.7f, 0.7f, 0.7f);
            if (rect.Contains(Event.current.mousePosition))
            {
                Rect drawRect4 = new Rect(rect);
                drawRect4.y     += rect.height;
                drawRect4.y     -= 1;
                drawRect4.height = 1;
                Rect texRect3 = new Rect(0.5f, 0.01f, 0.01f, 0.01f);
                Widgets.DrawTexturePart(drawRect4, texRect3, Textures.TextureTabAtlas);

                GUI.color = Color.yellow;
            }
            Widgets.Label(rect2, tab.label);
            GUI.color = Color.white;
        }
        //TODO метод, обновляющий цену позиции из бд по содержимому названия. Запускается при старте и сбивает цену
        private void TableComboBoxCheck(object sender, RoutedEventArgs e)
        {
            TabRecord obj = ((FrameworkElement)sender).DataContext as TabRecord;
            ComboBox  box = (FrameworkElement)sender as ComboBox;

            if (obj == null)
            {
                return;
            }

            var overlap = App.PC.Items.Where(i => i.Name == box.Text);

            if (overlap.Count() == 1)
            {
                //obj.Count = 1; TODO
                obj.Real = Int32.Parse((overlap.First().Value == null) ? "0" : overlap.First().Value);
                obj.Type = (overlap.First().Type == null) ? " " : overlap.First().Type;
            }
        }
        public override void DoWindowContents(Rect inRect)
        {
            Rect rect = new Rect(inRect);

            rect        = rect.ContractedBy(18f);
            rect.height = 34f;
            Text.Font   = GameFont.Medium;
            Widgets.Label(rect, this.thing.LabelCapNoCount);
            Rect rect2 = new Rect(inRect);

            rect2.yMin  = rect.yMax;
            rect2.yMax -= 38f;
            Rect rect3 = rect2;

            rect3.yMin += 45f;
            List <TabRecord> list = new List <TabRecord>();
            TabRecord        item = new TabRecord("TabStats".Translate(), delegate()
            {
                this.tab = InfoCardTab.Stats;
            }, this.tab == InfoCardTab.Stats);

            list.Add(item);

            TabRecord item2 = new TabRecord("TabHealth".Translate(), delegate()
            {
                this.tab = InfoCardTab.Health;
            }, this.tab == InfoCardTab.Health);

            list.Add(item2);

            TabRecord item3 = new TabRecord("TabRecords".Translate(), delegate()
            {
                this.tab = InfoCardTab.Records;
            }, this.tab == InfoCardTab.Records);

            list.Add(item3);

            TabDrawer.DrawTabs(rect3, list, 200f);
            this.FillCard(rect3.ContractedBy(18f));
        }
        public static void DrawTab(TabRecord record, Rect rect, Texture2D atlas)
        {
            Rect drawRect = new Rect(rect);

            drawRect.width = 30f;
            Rect drawRect2 = new Rect(rect);

            drawRect2.width = 30f;
            drawRect2.x     = rect.x + rect.width - 30f;
            Rect texRect   = new Rect(0.53125f, 0f, 0.46875f, 1f);
            Rect drawRect3 = new Rect(rect);

            drawRect3.x     += drawRect.width;
            drawRect3.width -= 60f;
            Rect texRect2 = new Rect(30f, 0f, 4f, (float)atlas.height).ToUVRect(new Vector2((float)atlas.width, (float)atlas.height));

            Widgets.DrawTexturePart(drawRect, new Rect(0f, 0f, 0.46875f, 1f), atlas);
            Widgets.DrawTexturePart(drawRect3, texRect2, atlas);
            Widgets.DrawTexturePart(drawRect2, texRect, atlas);
            Rect rect2 = rect;

            if (rect.Contains(Event.current.mousePosition))
            {
                GUI.color = Color.yellow;
                rect2.x  += 2f;
                rect2.y  -= 2f;
            }
            Widgets.Label(rect2, record.label);
            GUI.color = Color.white;
            if (!record.selected)
            {
                Rect drawRect4 = new Rect(rect);
                drawRect4.y     += rect.height;
                drawRect4.y     -= 1f;
                drawRect4.height = 1f;
                Rect texRect3 = new Rect(0.5f, 0.01f, 0.01f, 0.01f);
                Widgets.DrawTexturePart(drawRect4, texRect3, atlas);
            }
        }
        private void DrawTabs(Rect rect)
        {
            Rect tabRect = new Rect(rect);

            //Need to give it a minY or they get drawn one pixel tall
            tabRect.yMin += 120f;

            List <TabRecord> tabs = new List <TabRecord>();

            //Creating all the tabs, we have to reCreate all these at runtime because they don't update
            TabRecord tabRec_All = new TabRecord("TabAll".Translate(), delegate()                     { TabClick(Tabs.All); }, _currentTab == Tabs.All);

            TabRecord tabRec_Foods        = new TabRecord("TabFoods".Translate(), delegate()                 { TabClick(Tabs.Foods); }, _currentTab == Tabs.Foods);
            TabRecord tabRec_Manufactured = new TabRecord("TabManufactured".Translate(), delegate()    { TabClick(Tabs.Manufactured); }, _currentTab == Tabs.Manufactured);
            TabRecord tabRec_RawResources = new TabRecord("TabRawResources".Translate(), delegate()  { TabClick(Tabs.RawResources); }, _currentTab == Tabs.RawResources);
            TabRecord tabRec_Items        = new TabRecord("TabItems".Translate(), delegate()                 { TabClick(Tabs.Items); }, _currentTab == Tabs.Items);

            TabRecord tabRec_Weapon    = new TabRecord("TabWeapons".Translate(), delegate()              { TabClick(Tabs.Weapons); }, _currentTab == Tabs.Weapons);
            TabRecord tabRec_Apperal   = new TabRecord("TabApparel".Translate(), delegate()             { TabClick(Tabs.Apperal); }, _currentTab == Tabs.Apperal);
            TabRecord tabRec_Buildings = new TabRecord("TabBuildings".Translate(), delegate()         { TabClick(Tabs.Building); }, _currentTab == Tabs.Building);
            TabRecord tabRec_Chunks    = new TabRecord("TabChunks".Translate(), delegate()               { TabClick(Tabs.Chunks); }, _currentTab == Tabs.Chunks);
            TabRecord tabRec_Corpses   = new TabRecord("TabCorpses".Translate(), delegate()             { TabClick(Tabs.Corpses); }, _currentTab == Tabs.Corpses);

            //Add them to the list
            tabs.Add(tabRec_All);
            tabs.Add(tabRec_Foods);
            tabs.Add(tabRec_Manufactured);
            tabs.Add(tabRec_RawResources);
            tabs.Add(tabRec_Items);

            tabs.Add(tabRec_Weapon);
            tabs.Add(tabRec_Apperal);
            tabs.Add(tabRec_Buildings);
            tabs.Add(tabRec_Chunks);
            tabs.Add(tabRec_Corpses);

            //Draw the tabs, the last argument is how many rows you want
            TabDrawer.DrawTabs(tabRect, tabs, 2);
        }
Example #16
0
        public override void DoWindowContents(Rect inRect)
        {
            List <TabRecord> tabs = new List <TabRecord>();
            TabRecord        item = new TabRecord("Religion_Main".Translate(), delegate()
            {
                this.tab = Dialog_InfoCard.InfoCardTab.Stats;
            }, this.tab == Dialog_InfoCard.InfoCardTab.Stats);
            TabRecord item2 = new TabRecord("Religion_SocialSettings".Translate(), delegate()
            {
                this.tab = Dialog_InfoCard.InfoCardTab.Records;
            }, this.tab == Dialog_InfoCard.InfoCardTab.Records);

            tabs.Add(item);
            tabs.Add(item2);


            Rect tabRect = inRect.ContractedBy(18f);

            tabRect.yMin += 45f;
            TabDrawer.DrawTabs(tabRect, tabs, 200f);

            Fill(tabRect.ContractedBy(18));
        }
        private void DoLeftRow(Rect rect)
        {
            // background (minus top line so we can draw tabs.)
            Widgets.DrawMenuSection(rect, false);

            // tabs
            var tabs = new List <TabRecord>();
            var availableTabRecord = new TabRecord("FMP.Available".Translate(), delegate
            {
                _onCurrentTab = false;
                Refresh();
            }, !_onCurrentTab);

            tabs.Add(availableTabRecord);
            var currentTabRecord = new TabRecord("FMP.Current".Translate(), delegate
            {
                _onCurrentTab = true;
                Refresh();
            }, _onCurrentTab);

            tabs.Add(currentTabRecord);

            TabDrawer.DrawTabs(rect, tabs);

            // start the actual content.
            Rect outRect  = rect;
            Rect viewRect = outRect.AtZero();

            if (_onCurrentTab)
            {
                DrawCurrentJobList(outRect, viewRect);
            }
            else
            {
                DrawAvailableJobList(outRect, viewRect);
            }
        }
        public override void DrawHairPicker(Rect rect)
        {
            List <TabRecord> list     = new List <TabRecord>();
            List <string>    hairTags = this.alienRace.HairTags;

            if (this.CompFace.Pawn.def.race.hasGenders)
            {
                TabRecord item = new TabRecord("Female".Translate(), delegate
                {
                    HairDefs = DefDatabase <HairDef> .AllDefsListForReading.FindAll(
                        x =>
                        x.hairTags
                        .SharesElementWith(hairTags)
                        &&
                        (x.hairGender ==
                         HairGender
                         .Female ||
                         x.hairGender ==
                         HairGender
                         .FemaleUsually && !x.IsBeardNotHair()
                        ));
                    HairDefs       = HairDefs.OrderBy(i => i.LabelCap).ToList();
                    this.genderTab = GenderTab.Female;
                }, this.genderTab == GenderTab.Female);
                list.Add(item);

                TabRecord item2 = new TabRecord("Male".Translate(), delegate
                {
                    HairDefs = DefDatabase <HairDef> .AllDefsListForReading.FindAll(
                        x =>
                        x.hairTags
                        .SharesElementWith(hairTags)
                        &&
                        (x.hairGender ==
                         HairGender
                         .Male ||
                         x.hairGender ==
                         HairGender
                         .MaleUsually && !x.IsBeardNotHair()
                        ));
                    HairDefs       = HairDefs.OrderBy(i => i.LabelCap).ToList();
                    this.genderTab = GenderTab.Male;
                }, this.genderTab == GenderTab.Male);
                list.Add(item2);

                TabRecord item3 = new TabRecord("FacialStuffEditor.Any".Translate(), delegate
                {
                    HairDefs = DefDatabase <HairDef> .AllDefsListForReading.FindAll(
                        x =>
                        x.hairTags
                        .SharesElementWith(hairTags) &&
                        x.hairGender ==
                        HairGender
                        .Any && !x.IsBeardNotHair());
                    HairDefs       = HairDefs.OrderBy(i => i.LabelCap).ToList();
                    this.genderTab = GenderTab.Any;
                }, this.genderTab == GenderTab.Any);
                list.Add(item3);
            }

            TabRecord item4 = new TabRecord("FacialStuffEditor.All".Translate(), delegate
            {
                HairDefs = DefDatabase <HairDef> .AllDefsListForReading.FindAll(
                    x => x
                    .hairTags
                    .SharesElementWith(hairTags) && !x.IsBeardNotHair());
                HairDefs       = HairDefs.OrderBy(i => i.LabelCap).ToList();
                this.genderTab = GenderTab.All;
            }, this.genderTab == GenderTab.All);

            list.Add(item4);

            TabDrawer.DrawTabs(rect, list);

            Rect rect2a = new Rect(rect);

            rect2a.yMin += 32f;

            Rect rect2 = rect2a.ContractedBy(1f);
            Rect rect3 = rect2;

            // 12 columns as base
            int   divider       = 3;
            int   iconSides     = 2;
            int   thisColumns   = Columns / divider / iconSides;
            float thisEntrySize = EntrySize * divider;

            int rowsCount = Mathf.CeilToInt(FilteredHairDefs.Count / (float)thisColumns);

            rect3.height = rowsCount * thisEntrySize;

            Vector2 vector = new Vector2(thisEntrySize * iconSides, thisEntrySize);

            if (rect3.height > rect2.height)
            {
                vector.x    -= 16f / thisColumns;
                vector.y    -= 16f / thisColumns;
                rect3.width -= 16f;
                rect3.height = vector.y * rowsCount;
            }

            switch (this.genderTab)
            {
            case GenderTab.Male:
                Widgets.BeginScrollView(rect2, ref this.ScrollPositionHairMale, rect3);
                break;

            case GenderTab.Female:
                Widgets.BeginScrollView(rect2, ref this.ScrollPositionHairFemale, rect3);
                break;

            case GenderTab.Any:
                Widgets.BeginScrollView(rect2, ref this.ScrollPositionHairAny, rect3);
                break;

            case GenderTab.All:
                Widgets.BeginScrollView(rect2, ref this.ScrollPositionHairAll, rect3);
                break;
            }

            GUI.BeginGroup(rect3);

            for (int i = 0; i < FilteredHairDefs.Count; i++)
            {
                int  yPos  = i / thisColumns;
                int  xPos  = i % thisColumns;
                Rect rect4 = new Rect(xPos * vector.x, yPos * vector.y, vector.x, vector.y);
                this.DrawHairPickerCell(FilteredHairDefs[i], rect4.ContractedBy(3f));
            }

            GUI.EndGroup();
            Widgets.EndScrollView();
        }
Example #19
0
 private void OnTabSelected(int tabIndex)
 {
     activeTab = tabs[tabIndex];
 }
Example #20
0
        public static void DrawSacrificeCard(Rect inRect, Building_SacrificialAltar altar)
        {
            GUI.BeginGroup(inRect);

            if (CultTracker.Get.PlayerCult != null)
            {
                float cultLabelWidth = Text.CalcSize(CultTracker.Get.PlayerCult.name).x;

                Rect rect = new Rect(inRect);
                rect        = rect.ContractedBy(14f);
                rect.height = 30f;

                Text.Font = GameFont.Medium;
                Widgets.Label(rect, altar.RoomName);
                Text.Font = GameFont.Small;

                DrawRename(altar);

                Rect rect2 = new Rect(inRect);
                rect2.yMin   = rect.yMax + 10;
                rect2.height = 22f;
                rect2.xMin  += 15f;
                rect2.width  = cultLabelWidth + 5;
                //rect2.yMax -= 38f;
                Widgets.Label(rect2, CultTracker.Get.PlayerCult.name);
                if (Mouse.IsOver(rect2))
                {
                    Widgets.DrawHighlight(rect2);
                }
                if (Mouse.IsOver(rect2) && Event.current.type == EventType.MouseDown)
                {
                    Find.WindowStack.Add(new Dialog_RenameCult(altar.Map));
                }

                Rect rect3 = new Rect(inRect);
                //rect3.height -= 45f;
                //rect3.yMin += 45f;
                rect3.yMin   = rect2.yMax + 45f;
                rect3.height = 550f;
                List <TabRecord> list = new List <TabRecord>();
                TabRecord        item = new TabRecord("Offering".Translate(), delegate
                {
                    tab = SacrificeCardTab.Offering;
                }, tab == SacrificeCardTab.Offering);
                list.Add(item);
                if (altar.currentFunction >= Building_SacrificialAltar.Function.Level2)
                {
                    TabRecord item2 = new TabRecord("Animal".Translate(), delegate
                    {
                        tab = SacrificeCardTab.Animal;
                    }, tab == SacrificeCardTab.Animal);
                    list.Add(item2);
                }
                if (altar.currentFunction >= Building_SacrificialAltar.Function.Level3)
                {
                    TabRecord item3 = new TabRecord("Human".Translate(), delegate
                    {
                        tab = SacrificeCardTab.Human;
                    }, tab == SacrificeCardTab.Human);
                    list.Add(item3);
                }
                TabDrawer.DrawTabs(rect3, list);
                FillCard(rect3.ContractedBy(10f), altar);
            }
            else
            {
                Rect rect = new Rect(inRect);
                rect        = rect.ContractedBy(14f);
                rect.height = 30f;

                Text.Font = GameFont.Medium;
                Widgets.Label(rect, "Cults_NoPlayerCultAvailable".Translate());
                Text.Font = GameFont.Small;
            }


            GUI.EndGroup();
        }
        public void DoLeftRow(Rect canvas)
        {
            Widgets.DrawMenuSection(canvas, false);

            // filter
            Rect filterRect = new Rect(10f, canvas.yMin + 5f, canvas.width - 50f, 30f);

            GUI.SetNextControlName("filterTextfield");
            SourceFilter = Widgets.TextField(filterRect, SourceFilter);

            if (!_postOpenFocus)
            {
                GUI.FocusControl("filterTextfield");
                _postOpenFocus = true;
            }

            if (SourceFilter != "")
            {
                Rect clearFilter = new Rect(filterRect.width + 10f, filterRect.yMin, 30f, 30f);
                if (Widgets.ImageButton(clearFilter, Widgets.CheckboxOffTex))
                {
                    SourceFilter = "";
                }
                TooltipHandler.TipRegion(clearFilter, "FMP.ClearFilterDesc".Translate());
            }
            TooltipHandler.TipRegion(filterRect, "FMP.FilterDesc".Translate());

            // tabs
            List<TabRecord> list = new List<TabRecord>();
            TabRecord item = new TabRecord("FMP.All".Translate(), delegate
            {
                Source = SourceOptions.All;
                RefreshSourceList();
            }, Source == SourceOptions.All);
            list.Add(item);
            TabRecord item2 = new TabRecord("FMP.Available".Translate(), delegate
            {
                Source = SourceOptions.Available;
                RefreshSourceList();
            }, Source == SourceOptions.Available);
            list.Add(item2);
            TabRecord item3 = new TabRecord("FMP.Current".Translate(), delegate
            {
                Source = SourceOptions.Current;
                RefreshSourceList();
            }, Source == SourceOptions.Current);
            list.Add(item3);
            TabDrawer.DrawTabs(canvas, list);

            // content
            Rect scrollCanvas = canvas.ContractedBy(10f);
            scrollCanvas.yMin = scrollCanvas.yMin + 40f;
            float height = SourceListHeight + 20f;
            Rect scrollView = new Rect(0f, 0f, scrollCanvas.width - 16f, height);
            Widgets.BeginScrollView(scrollCanvas, ref LeftRowScrollPosition, scrollView);
            Rect scrollContent = scrollView.ContractedBy(10f);

            GUI.BeginGroup(scrollContent);
            float y = 0;

            foreach (ManagerJobProduction current in from job in SourceList
                                             where job.Bill.recipe.label.ToUpper().Contains(SourceFilter.ToUpper()) || job.MainProduct.Label.ToUpper().Contains(SourceFilter.ToUpper())
                                             orderby job.Bill.recipe.LabelCap
                                             select job)
            {
                Rect recipeRow = new Rect(0f, y, scrollContent.width, 25f);

                string text = current.Bill.recipe.LabelCap + " (";
                try
                {
                    text += String.Join(", ", current.BillGivers.GetBillGiverDefs.Select(ru => ru.LabelCap).ToArray());
                }
                catch
                {
                    text += "error";
                }
                text += ")";

                // resize the row if label grow too big.
                Rect recipeRowResized = new Rect(recipeRow);
                recipeRowResized.x += 6f;
                recipeRowResized.width -= 6f;
                float calculatedHeight = Text.CalcHeight(text, recipeRowResized.width);
                if (recipeRowResized.height < calculatedHeight)
                {
                    recipeRowResized.height = calculatedHeight + 3f;
                }

                if (Widgets.TextButton(recipeRowResized, text, false, true))
                {
                    SoundDefOf.Click.PlayOneShotOnCamera();
                    Job = current;
                }

                if (Job != null && Job == current)
                {
                    GUI.DrawTexture(recipeRowResized, TexUI.HighlightTex);
                }

                y += recipeRowResized.height;
            }
            SourceListHeight = y;
            GUI.EndGroup();
            Widgets.EndScrollView();
        }
        public void DoLeftRow( Rect canvas )
        {
            Widgets.DrawMenuSection( canvas, false );

            // filter
            Rect filterRect = new Rect( 10f, canvas.yMin + 5f, canvas.width - _leftRowEntryHeight, _entryHeight );

            GUI.SetNextControlName( "filterTextfield" );
            SourceFilter = Widgets.TextField( filterRect, SourceFilter );

            if ( !_postOpenFocus )
            {
                GUI.FocusControl( "filterTextfield" );
                _postOpenFocus = true;
            }

            if ( SourceFilter != "" )
            {
                Rect clearFilter = new Rect( filterRect.width + 10f, filterRect.yMin, _entryHeight, _entryHeight );
                if ( Widgets.ImageButton( clearFilter, Widgets.CheckboxOffTex ) )
                {
                    SourceFilter = "";
                }
                TooltipHandler.TipRegion( clearFilter, "FMP.ClearFilterDesc".Translate() );
            }
            TooltipHandler.TipRegion( filterRect, "FMP.FilterDesc".Translate() );

            // tabs
            List<TabRecord> list = new List<TabRecord>();
            TabRecord availableTabRecord = new TabRecord( "FMP.Available".Translate(), delegate
            {
                Source = SourceOptions.Available;
                Refresh();
            }, Source == SourceOptions.Available );
            list.Add( availableTabRecord );
            TabRecord currentTabRecord = new TabRecord( "FMP.Current".Translate(), delegate
            {
                Source = SourceOptions.Current;
                Refresh();
            }, Source == SourceOptions.Current );
            list.Add( currentTabRecord );
            TabDrawer.DrawTabs( canvas, list );

            // content
            Rect scrollCanvas = canvas;
            scrollCanvas.yMin = scrollCanvas.yMin + _entryHeight + _margin;
            float height = SourceListHeight;
            Rect scrollView = new Rect( 0f, 0f, scrollCanvas.width, height );
            if ( height > scrollCanvas.height )
            {
                scrollView.width -= 16f;
            }

            Widgets.BeginScrollView( scrollCanvas, ref LeftRowScrollPosition, scrollView );
            Rect scrollContent = scrollView;

            GUI.BeginGroup( scrollContent );
            float y = 0;
            int i = 0;

            foreach ( ManagerJob_Production current in from job in SourceList
                                                       where
                                                           job.Bill.recipe.label.ToUpper()
                                                              .Contains( SourceFilter.ToUpper() ) ||
                                                           job.MainProduct.Label.ToUpper()
                                                              .Contains( SourceFilter.ToUpper() )
                                                       select job )
            {
                Rect row = new Rect( 0f, y, scrollContent.width, Utilities.LargeListEntryHeight );
                Widgets.DrawHighlightIfMouseover( row );
                if ( _selected == current )
                {
                    Widgets.DrawHighlightSelected( row );
                }

                if ( i++ % 2 == 1 )
                {
                    Widgets.DrawAltRect( row );
                }

                Rect jobRect = row;

                if ( Source == SourceOptions.Current )
                {
                    if ( ManagerTab_Overview.DrawOrderButtons(
                        new Rect( row.xMax - _leftRowEntryHeight, row.yMin, _leftRowEntryHeight, _leftRowEntryHeight ),
                        current ) )
                    {
                        Refresh();
                    }
                    jobRect.width -= _leftRowEntryHeight;
                }

                current.DrawListEntry( jobRect, false, Source == SourceOptions.Current );
                if ( Widgets.InvisibleButton( jobRect ) )
                {
                    _selected = current;
                }

                y += Utilities.LargeListEntryHeight;
            }
            SourceListHeight = y;
            GUI.EndGroup();
            Widgets.EndScrollView();
        }
Example #23
0
        public override void DoSettingsWindowContents(Rect inRect)
        {
            Listing_Standard listingStandard = new Listing_Standard();

            listingStandard.Begin(inRect);

            Rect rect3 = new Rect(inRect);

            List <TabRecord> list = new List <TabRecord>();

            TabRecord generalTab = new TabRecord("ZMD_generalTab".Translate(), delegate
            {
                this.tab = MapDesignerMod.InfoCardTab.General;
            }, this.tab == MapDesignerMod.InfoCardTab.General);

            list.Add(generalTab);

            TabRecord mountainTab = new TabRecord("ZMD_mountainTab".Translate(), delegate
            {
                this.tab = MapDesignerMod.InfoCardTab.Mountains;
            }, this.tab == MapDesignerMod.InfoCardTab.Mountains);

            list.Add(mountainTab);

            TabRecord terrainTab = new TabRecord("ZMD_terrainTab".Translate(), delegate
            {
                this.tab = MapDesignerMod.InfoCardTab.Terrain;
            }, this.tab == MapDesignerMod.InfoCardTab.Terrain);

            list.Add(terrainTab);

            TabRecord ThingsTab = new TabRecord("ZMD_thingsTab".Translate(), delegate
            {
                this.tab = MapDesignerMod.InfoCardTab.Things;
            }, this.tab == MapDesignerMod.InfoCardTab.Things);

            list.Add(ThingsTab);

            TabRecord riverTab = new TabRecord("ZMD_riverTab".Translate(), delegate
            {
                this.tab = MapDesignerMod.InfoCardTab.Rivers;
            }, this.tab == MapDesignerMod.InfoCardTab.Rivers);

            list.Add(riverTab);

            TabRecord featureTab = new TabRecord("ZMD_featureTab".Translate(), delegate
            {
                this.tab = MapDesignerMod.InfoCardTab.Feature;
            }, this.tab == MapDesignerMod.InfoCardTab.Feature);

            list.Add(featureTab);

            //if(Prefs.DevMode)
            //{
            //    TabRecord betaTab = new TabRecord("ZMD_betaTab".Translate(), delegate
            //    {
            //        this.tab = MapDesigner_Mod.InfoCardTab.Beta;
            //    }, this.tab == MapDesigner_Mod.InfoCardTab.Beta);
            //    list.Add(betaTab);
            //}

            TabDrawer.DrawTabs(rect3, list, 150f);
            this.FillCard(rect3.ContractedBy(18f));

            listingStandard.End();
        }
        private void DoLeftRow( Rect rect )
        {
            // background (minus top line so we can draw tabs.)
            Widgets.DrawMenuSection( rect, false );

            // tabs
            var tabs = new List<TabRecord>();
            var availableTabRecord = new TabRecord( "FMP.Available".Translate(), delegate
                                                                                     {
                                                                                         _onCurrentTab = false;
                                                                                         Refresh();
                                                                                     }, !_onCurrentTab );
            tabs.Add( availableTabRecord );
            var currentTabRecord = new TabRecord( "FMP.Current".Translate(), delegate
                                                                                 {
                                                                                     _onCurrentTab = true;
                                                                                     Refresh();
                                                                                 }, _onCurrentTab );
            tabs.Add( currentTabRecord );

            TabDrawer.DrawTabs( rect, tabs );

            // start the actual content.
            Rect outRect = rect;
            Rect viewRect = outRect.AtZero();

            if ( _onCurrentTab )
            {
                DrawCurrentJobList( outRect, viewRect );
            }
            else
            {
                DrawAvailableJobList( outRect, viewRect );
            }
        }
        public void DoLeftRow(Rect canvas)
        {
            Widgets.DrawMenuSection(canvas, false);

            // filter
            var filterRect = new Rect(10f, canvas.yMin + 5f, canvas.width - _leftRowEntryHeight, _entryHeight);

            GUI.SetNextControlName("filterTextfield");
            SourceFilter = Widgets.TextField(filterRect, SourceFilter);

            if (!_postOpenFocus)
            {
                GUI.FocusControl("filterTextfield");
                _postOpenFocus = true;
            }

            if (SourceFilter != "")
            {
                var clearFilter = new Rect(filterRect.width + 10f, filterRect.yMin, _entryHeight, _entryHeight);
                if (Widgets.ButtonImage(clearFilter, Widgets.CheckboxOffTex))
                {
                    SourceFilter = "";
                }
                TooltipHandler.TipRegion(clearFilter, "FMP.ClearFilterDesc".Translate());
            }
            TooltipHandler.TipRegion(filterRect, "FMP.FilterDesc".Translate());

            // tabs
            var list = new List <TabRecord>();
            var availableTabRecord = new TabRecord("FMP.Available".Translate(), delegate
            {
                Source =
                    SourceOptions.Available;
                Refresh();
            },
                                                   Source == SourceOptions.Available);

            list.Add(availableTabRecord);
            var currentTabRecord = new TabRecord("FMP.Current".Translate(), delegate
            {
                Source = SourceOptions.Current;
                Refresh();
            }, Source == SourceOptions.Current);

            list.Add(currentTabRecord);
            TabDrawer.DrawTabs(canvas, list);

            // content
            Rect scrollCanvas = canvas;

            scrollCanvas.yMin = scrollCanvas.yMin + _entryHeight + _margin;
            float height     = SourceListHeight;
            var   scrollView = new Rect(0f, 0f, scrollCanvas.width, height);

            if (height > scrollCanvas.height)
            {
                scrollView.width -= 16f;
            }

            Widgets.BeginScrollView(scrollCanvas, ref LeftRowScrollPosition, scrollView);
            Rect scrollContent = scrollView;

            GUI.BeginGroup(scrollContent);
            float y = 0;
            var   i = 0;

            foreach (ManagerJob_Production current in from job in SourceList
                     where
                     job.Bill.recipe.label.ToUpper()
                     .Contains(SourceFilter.ToUpper()) ||
                     job.MainProduct.Label.ToUpper()
                     .Contains(SourceFilter.ToUpper())
                     select job)
            {
                var row = new Rect(0f, y, scrollContent.width, Utilities.LargeListEntryHeight);
                Widgets.DrawHighlightIfMouseover(row);
                if (_selected == current)
                {
                    Widgets.DrawHighlightSelected(row);
                }

                if (i++ % 2 == 1)
                {
                    Widgets.DrawAltRect(row);
                }

                Rect jobRect = row;

                if (Source == SourceOptions.Current)
                {
                    if (ManagerTab_Overview.DrawOrderButtons(
                            new Rect(row.xMax - _leftRowEntryHeight, row.yMin,
                                     _leftRowEntryHeight, _leftRowEntryHeight),
                            manager,
                            current))
                    {
                        Refresh();
                    }
                    jobRect.width -= _leftRowEntryHeight;
                }

                current.DrawListEntry(jobRect, false, Source == SourceOptions.Current);
                if (Widgets.ButtonInvisible(jobRect))
                {
                    _selected = current;
                }

                y += Utilities.LargeListEntryHeight;
            }

            SourceListHeight = y;
            GUI.EndGroup();
            Widgets.EndScrollView();
        }
        public static TabRecord DrawTabs(Rect baseRect, IEnumerable <TabRecord> tabsEnum, Texture2D atlas)
        {
            TabDrawer.tabList.Clear();
            foreach (TabRecord current in tabsEnum)
            {
                TabDrawer.tabList.Add(current);
            }
            TabRecord tabRecord  = null;
            TabRecord tabRecord2 = (from t in TabDrawer.tabList
                                    where t.selected
                                    select t).FirstOrDefault <TabRecord>();

            if (tabRecord2 == null)
            {
                Debug.LogWarning("Drew tabs without any being selected.");
                return(TabDrawer.tabList[0]);
            }
            float num      = baseRect.width + (float)(TabDrawer.tabList.Count - 1) * 10f;
            float tabWidth = num / (float)TabDrawer.tabList.Count;

            if (tabWidth > 200f)
            {
                tabWidth = 200f;
            }
            Rect position = new Rect(baseRect);

            position.y     -= 32f;
            position.height = 9999f;
            GUI.BeginGroup(position);
            Text.Anchor = TextAnchor.MiddleCenter;
            Text.Font   = GameFont.Small;
            Func <TabRecord, Rect> func = delegate(TabRecord tab)
            {
                int   num2 = TabDrawer.tabList.IndexOf(tab);
                float left = (float)num2 * (tabWidth - 10f);
                return(new Rect(left, 1f, tabWidth, 32f));
            };
            List <TabRecord> list = TabDrawer.tabList.ListFullCopy <TabRecord>();

            list.Remove(tabRecord2);
            list.Add(tabRecord2);
            TabRecord        tabRecord3 = null;
            List <TabRecord> list2      = list.ListFullCopy <TabRecord>();

            list2.Reverse();
            for (int i = 0; i < list2.Count; i++)
            {
                TabRecord tabRecord4 = list2[i];
                Rect      rect       = func(tabRecord4);
                if (tabRecord3 == null && rect.Contains(Event.current.mousePosition))
                {
                    tabRecord3 = tabRecord4;
                }
                MouseoverSounds.DoRegion(rect);
                if (Widgets.InvisibleButton(rect))
                {
                    tabRecord = tabRecord4;
                }
            }
            foreach (TabRecord current2 in list)
            {
                Rect rect2 = func(current2);
                TabDrawer.DrawTab(current2, rect2, atlas);
            }
            Text.Anchor = TextAnchor.UpperLeft;
            GUI.EndGroup();
            if (tabRecord != null)
            {
                SoundDefOf.SelectDesignator.PlayOneShotOnCamera();
                if (tabRecord.clickedAction != null)
                {
                    tabRecord.clickedAction();
                }
            }
            return(tabRecord);
        }
Example #27
0
        //draws the window's contents
        public override void DoWindowContents(Rect inRect)
        {
            //Title
            Rect titleRect = new Rect(inRect);

            titleRect        = titleRect.ContractedBy(17f);
            titleRect.height = 34f;
            titleRect.x     += 34f;
            Text.Font        = GameFont.Medium;
            Widgets.Label(titleRect, this.thing.LabelCapNoCount);
            Rect titleIconRect = new Rect(inRect.x + 9f, titleRect.y, 34f, 34f);

            if (this.thing != null)
            {
                Widgets.ThingIcon(titleIconRect, this.thing, 1f);
            }
            //Inner Rectangle
            Rect innerRect = new Rect(inRect);

            innerRect.yMin  = titleRect.yMax;
            innerRect.yMax -= 34f;
            Widgets.DrawLineVertical(innerRect.x + innerRect.width / 2, innerRect.y, innerRect.height);
            Text.Font = GameFont.Small;
            //Harddrive Info
            Rect harddriveInfo = new Rect(innerRect.x, innerRect.y, innerRect.width / 2 - 17f, innerRect.height);
            Rect cardRect      = new Rect(harddriveInfo);

            cardRect.y   += 34f;
            cardRect.yMax = innerRect.yMax;
            if (selectedHarddrive != null)
            {
                Rect             harddriveInfoTabs = harddriveInfo;
                List <TabRecord> tabs  = new List <TabRecord>();
                TabRecord        stats = new TabRecord("TabStats".Translate(), delegate() {
                    this.tab = Neurolink_Dialog_Mainframe.InfoCardTab.Stats;
                }, this.tab == Neurolink_Dialog_Mainframe.InfoCardTab.Stats);
                tabs.Add(stats);
                if (selectedHarddrive.pawn.RaceProps.Humanlike)
                {
                    TabRecord character = new TabRecord("TabCharacter".Translate(), delegate() {
                        this.tab = Neurolink_Dialog_Mainframe.InfoCardTab.Character;
                    }, this.tab == Neurolink_Dialog_Mainframe.InfoCardTab.Character);
                    tabs.Add(character);
                }
                TabRecord social = new TabRecord("TabSocial".Translate(), delegate() {
                    this.tab = Neurolink_Dialog_Mainframe.InfoCardTab.Social;
                }, this.tab == Neurolink_Dialog_Mainframe.InfoCardTab.Social);
                tabs.Add(social);
                TabRecord needs = new TabRecord("TabNeeds".Translate(), delegate() {
                    this.tab = Neurolink_Dialog_Mainframe.InfoCardTab.Needs;
                }, this.tab == Neurolink_Dialog_Mainframe.InfoCardTab.Needs);
                tabs.Add(needs);
                if (tabs.Count > 1)
                {
                    harddriveInfoTabs.yMin += 45f;
                    TabDrawer.DrawTabs(harddriveInfoTabs, tabs, cardRect.width);
                }
                this.FillInfoTabs(cardRect.ContractedBy(17f));
            }
            //Harddrives
            Rect harddrivesList = new Rect(innerRect.width / 2 + 17f, innerRect.y, innerRect.width / 2 - 17f, innerRect.height);

            Widgets.DrawBoxSolid(harddrivesList, Color.black);
            if (!thing.GetDirectlyHeldThings().NullOrEmpty())
            {
                Thing[] contents = ThingOwnerUtility.GetAllThingsRecursively(thing).ToArray();
                Rect[]  hdRect   = new Rect[contents.Length];
                Color   buttonBgColor;
                string  buttonText = null;
                Widgets.BeginScrollView(harddrivesList, ref this.scrollPosition, harddrivesList, true);                 //%TODO%
                for (int i = 0; i < contents.Length; i++)
                {
                    Pawn pawn = ((Neurolink_Harddrive)contents[i]).pawn;
                    hdRect[i]     = new Rect(harddrivesList.x, harddrivesList.y + 100f * i, harddrivesList.width, 100f);
                    buttonBgColor = Mouse.IsOver(hdRect[i]) ? Color.green : Color.gray;
                    buttonText    = pawn.GetHashCode() + " | " + pawn.Name.ToStringFull + " | " + pawn.story.TitleCap
                                    + " | " + pawn.ageTracker.AgeChronologicalYears;
                    if (Widgets.CustomButtonText(ref hdRect[i], buttonText, buttonBgColor, Color.white, Color.black))
                    {
                        this.selectedHarddrive = (Neurolink_Harddrive)contents.GetValue(i);
                    }
                }
                Widgets.EndScrollView();
            }
            //Simulation %TODO%
        }
        public override void DoWindowContents(Rect inRect)
        {
            base.DoWindowContents(inRect);
            if (!_noBenchWarned)
            {
                if (!Find.ListerBuildings.ColonistsHaveBuilding(ThingDefOf.ResearchBench))
                {
                    Find.WindowStack.Add(new Dialog_Message("ResearchMenuWithoutBench".Translate()));
                }
                _noBenchWarned = true;
            }
            Text.Font = GameFont.Medium;
            Text.Anchor = TextAnchor.UpperCenter;
            Widgets.Label(new Rect(0f, 0f, inRect.width, 300f), "Research".Translate());
            Text.Anchor = TextAnchor.UpperLeft;
            Text.Font = GameFont.Small;
            Rect sidebar = new Rect(0f, 75f, 330f, inRect.height - 75f);
            Rect content = new Rect(sidebar.xMax + 10f, 45f, inRect.width - sidebar.width - 10f, inRect.height - 45f);
            Widgets.DrawMenuSection(sidebar, false);
            Widgets.DrawMenuSection(content);

            // plop in extra row for input + sort buttons
            Rect sortFilterRow = sidebar.ContractedBy(10f);
            sortFilterRow.height = 30f;

            Rect filterRect = new Rect(sortFilterRow);
            filterRect.width = sortFilterRow.width - 110f;
            Rect deleteFilter = new Rect(filterRect.xMax + 6f, filterRect.yMin + 3f, 24f, 24f);
            Rect sortByName = new Rect(deleteFilter.xMax + 6f, filterRect.yMin + 3f, 24f, 24f);
            Rect sortByCost = new Rect(sortByName.xMax + 6f, filterRect.yMin + 3f, 24f, 24f);
            TooltipHandler.TipRegion(filterRect, "RI.filterTooltip".Translate());
            if (_filter != "") TooltipHandler.TipRegion(deleteFilter, "RI.deleteFilterTooltip".Translate());
            TooltipHandler.TipRegion(sortByName, "RI.sortByNameTooltip".Translate());
            TooltipHandler.TipRegion(sortByCost, "RI.sortByCostTooltip".Translate());

            // filter options
            _filter = Widgets.TextField(filterRect, _filter);
            if (_oldFilter != _filter)
            {
                _oldFilter = _filter;
                RefreshSource();
            }
            if (_filter != "")
            {
                if (Widgets.ImageButton(deleteFilter, Widgets.CheckboxOffTex))
                {
                    _filter = "";
                    RefreshSource();
                }
            }

            // sort options
            if (Widgets.ImageButton(sortByName, _sortByNameTex))
            {
                if (_sortBy != SortOptions.Name)
                {
                    _sortBy = SortOptions.Name;
                    _asc = false;
                    RefreshSource();
                }
                else
                {
                    _asc = !_asc;
                    RefreshSource();
                }
            }
            if (Widgets.ImageButton(sortByCost, _sortByCostTex))
            {
                if (_sortBy != SortOptions.Cost)
                {
                    _sortBy = SortOptions.Cost;
                    _asc = true;
                    RefreshSource();
                }
                else
                {
                    _asc = !_asc;
                    RefreshSource();
                }
            }

            // contract sidebar area
            Rect sidebarInner = sidebar.ContractedBy(10f);
            sidebarInner.yMin += 30f;
            sidebarInner.height -= 30f;
            float height = 25 * _source.Count() + 100;
            Rect sidebarContent = new Rect(0f, 0f, sidebarInner.width - 16f, height);
            Widgets.BeginScrollView(sidebarInner, ref _projectListScrollPosition, sidebarContent);
            Rect position = sidebarContent.ContractedBy(10f);
            GUI.BeginGroup(position);
            int num = 0;

            foreach (ResearchProjectDef current in from rp in _source
                                                   select rp)
            {
                Rect sidebarRow = new Rect(0f, num, position.width, 25f);
                if (SelectedProject == current)
                {
                    GUI.DrawTexture(sidebarRow, TexUI.HighlightTex);
                }

                string text = current.LabelCap + " (" + current.totalCost.ToString("F0") + ")";
                Rect sidebarRowInner = new Rect(sidebarRow);
                sidebarRowInner.x += 6f;
                sidebarRowInner.width -= 6f;
                float num2 = Text.CalcHeight(text, sidebarRowInner.width);
                if (sidebarRowInner.height < num2)
                {
                    sidebarRowInner.height = num2 + 3f;
                }
                // give the label a colour if we're in the all tab.
                Color textColor;
                if (_showResearchedProjects == ShowResearch.All)
                {
                    if (current.IsFinished)
                    {
                        textColor = new Color(1f, 1f, 1f);
                    }
                    else if (!current.PrereqsFulfilled)
                    {
                        textColor = new Color(.6f, .6f, .6f);
                    }
                    else
                    {
                        textColor = new Color(.8f, .85f, 1f);
                    }
                }
                else
                {
                    textColor = new Color(.8f, .85f, 1f);
                }
                if (Widgets.TextButton(sidebarRowInner, text, false, true, textColor))
                {
                    SoundDefOf.Click.PlayOneShotOnCamera();
                    SelectedProject = current;
                }
                num += 25;
            }
            GUI.EndGroup();
            Widgets.EndScrollView();
            List<TabRecord> list = new List<TabRecord>();
            TabRecord item = new TabRecord("RI.All".Translate(), delegate
            {
                this._showResearchedProjects = ShowResearch.All;
                RefreshSource();
            }, _showResearchedProjects == ShowResearch.All);
            list.Add(item);
            TabRecord item2 = new TabRecord("Researched".Translate(), delegate
            {
                this._showResearchedProjects = ShowResearch.Completed;
                RefreshSource();
            }, _showResearchedProjects == ShowResearch.Completed);
            list.Add(item2);
            TabRecord item3 = new TabRecord("RI.Available".Translate(), delegate
            {
                this._showResearchedProjects = ShowResearch.Available;
                RefreshSource();
            }, _showResearchedProjects == ShowResearch.Available);
            list.Add(item3);
            TabDrawer.DrawTabs(sidebar, list);
            Rect position2 = content.ContractedBy(20f);
            GUI.BeginGroup(position2);
            if (SelectedProject != null)
            {
                Text.Font = GameFont.Medium;
                GenUI.SetLabelAlign(TextAnchor.MiddleLeft);
                Rect rect6 = new Rect(20f, 0f, position2.width - 20f, 50f);
                Widgets.Label(rect6, SelectedProject.LabelCap);
                GenUI.ResetLabelAlign();
                Text.Font = GameFont.Small;
                Rect rect7 = new Rect(0f, 50f, position2.width, position2.height - 50f);
                string desc = SelectedProject.description;

                // select prerequisites
                desc += ".\n\n";
                string[] prereqs = SelectedProject.prerequisites.Select(def => def.LabelCap).ToArray();
                desc += "RI.Prerequisites".Translate() + ": ";
                if (prereqs.Length == 0)
                {
                    desc += "RI.none".Translate();
                }
                else
                {
                    desc += String.Join(", ", prereqs);
                }
                desc += ".\n\n";

                // select follow-ups
                string[] follow = DefDatabase<ResearchProjectDef>.AllDefsListForReading.Where(rpd => rpd.prerequisites.Contains(SelectedProject)).Select(rpd => rpd.LabelCap).ToArray();
                desc += "RI.LeadsTo".Translate() + ": ";
                if (!follow.Any())
                {
                    desc += "RI.none".Translate();
                }
                else
                {
                    desc += String.Join(", ", follow);
                }
                desc += ".\n\n";

                //// find all unlocks
                //desc += "Unlocks: ";
                //string[] unlocks = getUnlocks(selectedProject);
                //if (unlocks == null || unlocks.Count() == 0)
                //{
                //    desc += "none";
                //}
                //else
                //{
                //    desc += String.Join(", ", unlocks);
                //}
                //desc += ".\n\n";

                Widgets.Label(rect7, desc);
                Rect rect8 = new Rect(position2.width / 2f - 50f, 300f, 100f, 50f);
                if (SelectedProject.IsFinished)
                {
                    Widgets.DrawMenuSection(rect8);
                    Text.Anchor = TextAnchor.MiddleCenter;
                    Widgets.Label(rect8, "Finished".Translate());
                    Text.Anchor = TextAnchor.UpperLeft;
                }
                else if (SelectedProject == Find.ResearchManager.currentProj)
                {
                    Widgets.DrawMenuSection(rect8);
                    Text.Anchor = TextAnchor.MiddleCenter;
                    Widgets.Label(rect8, "InProgress".Translate());
                    Text.Anchor = TextAnchor.UpperLeft;
                }
                else if (!SelectedProject.PrereqsFulfilled)
                {
                    Widgets.DrawMenuSection(rect8);
                    Text.Anchor = TextAnchor.MiddleCenter;
                    Widgets.Label(rect8, "RI.PreReqLocked".Translate());
                    Text.Anchor = TextAnchor.UpperLeft;
                }
                else
                {
                    if (Widgets.TextButton(rect8, "Research".Translate()))
                    {
                        SoundDef.Named("ResearchStart").PlayOneShotOnCamera();
                        Find.ResearchManager.currentProj = SelectedProject;
                    }
                    if (Prefs.DevMode)
                    {
                        Rect rect9 = rect8;
                        rect9.x += rect9.width + 4f;
                        if (Widgets.TextButton(rect9, "Debug Insta-finish"))
                        {
                            Find.ResearchManager.currentProj = SelectedProject;
                            Find.ResearchManager.InstantFinish(SelectedProject);
                        }
                    }
                }
                Rect rect10 = new Rect(15f, 450f, position2.width - 30f, 35f);
                Widgets.FillableBar(rect10, SelectedProject.PercentComplete, BarFillTex, BarBgTex, true);
                Text.Anchor = TextAnchor.MiddleCenter;
                Widgets.Label(rect10, SelectedProject.ProgressNumbersString);
                Text.Anchor = TextAnchor.UpperLeft;
            }
            GUI.EndGroup();
        }
        public override void DoWindowContents(Rect inRect)
        {
            Rect rect = new Rect(MarginFS, 0f, inRect.width, TitleHeight);

            Text.Font   = GameFont.Medium;
            Text.Anchor = TextAnchor.MiddleLeft;
            Widgets.Label(rect, Title);
            Text.Anchor = TextAnchor.UpperLeft;
            Text.Font   = GameFont.Small;

            // re-render pawn
            try
            {
                if (this.RerenderPawn)
                {
                    Pawn.Drawer.renderer.graphics.ResolveAllGraphics();
                    PortraitsCache.SetDirty(Pawn);
                    this.RerenderPawn = false;
                }

                if (!this.Initialized)
                {
                    this.DresserDto = new DresserDTO(Pawn);
                    this.DresserDto.SetUpdatePawnListeners(this.UpdatePawn);
                }
            }
            catch (Exception ex)
            {
            }

            List <TabRecord> list = new List <TabRecord>();

            TabRecord item = new TabRecord(
                "FacialStuffEditor.Hair".Translate(),
                this.SetTabFaceStyle(FaceStyleTab.Hair),
                this.Tab == FaceStyleTab.Hair);

            list.Add(item);

            if (this.CompFace.Props.hasBeard)
            {
                if (Pawn.gender == Gender.Male)
                {
                    TabRecord item2 = new TabRecord(
                        "FacialStuffEditor.Beard".Translate(),
                        this.SetTabFaceStyle(FaceStyleTab.Beard),
                        this.Tab == FaceStyleTab.Beard);
                    list.Add(item2);
                }
            }

            if (this.CompFace.Props.hasEyes)
            {
                TabRecord item3 = new TabRecord(
                    "FacialStuffEditor.Eye".Translate(),
                    this.SetTabFaceStyle(FaceStyleTab.Eye),
                    this.Tab == FaceStyleTab.Eye);
                list.Add(item3);

                TabRecord item4 = new TabRecord(
                    "FacialStuffEditor.Brow".Translate(),
                    this.SetTabFaceStyle(FaceStyleTab.Brow),
                    this.Tab == FaceStyleTab.Brow);
                list.Add(item4);
            }

            if (Controller.settings.ShowBodyChange && Current.ProgramState == ProgramState.Playing)
            {
                TabRecord item5 = new TabRecord(
                    "FacialStuffEditor.TypeSelector".Translate(),
                    this.SetTabFaceStyle(FaceStyleTab.TypeSelector),
                    this.Tab == FaceStyleTab.TypeSelector);
                list.Add(item5);
            }

            Rect contentRect = new Rect(
                0f,
                TitleHeight + TabDrawer.TabHeight + MarginFS / 2,
                inRect.width,
                inRect.height - TitleHeight - MarginFS * 2 - TabDrawer.TabHeight);

            TabDrawer.DrawTabs(contentRect, list);

            this.DrawUI(contentRect);

            Action backAct = delegate
            {
                this.RemoveColorPicker();

                // SoundDef.Named("InteractShotgun").PlayOneShotOnCamera();
                if (this.OriginalGender != Gender.Male && this.Tab == FaceStyleTab.Beard)
                {
                    this.Tab = FaceStyleTab.Hair;
                }

                this.ResetPawnFace();
            };

            DialogUtility.DoNextBackButtons(
                inRect,
                "Randomize".Translate(),
                "FacialStuffEditor.Accept".Translate(),
                backAct,
                this.FaceRandomizer,
                this.SaveAndClose);
        }