Example #1
0
        private void UpdateUndoRedoMessages()
        {
            CommandManager commandManager = Base.CommandManager;

            /* Update undo messages */
            ToolButton undoButton = Base.GetWidget(WidgetNames.UndoButton) as ToolButton;

            if (commandManager.CanUndo)
            {
                string undoDescription = commandManager.UndoDescription;
                SetTooltip(undoButton, undoDescription);
                MenuItem undoMenuItem = Base.GetWidget(WidgetNames.EditUndo) as MenuItem;
                (undoMenuItem.Child as Label).Text = undoDescription;
            }
            else
            {
                ClearTooltip(undoButton);
            }

            /* Update redo messages */
            ToolButton redoButton = Base.GetWidget(WidgetNames.RedoButton) as ToolButton;

            if (commandManager.CanRedo)
            {
                string redoDescription = commandManager.RedoDescription;
                SetTooltip(redoButton, redoDescription);
                MenuItem redoMenuItem = Base.GetWidget(WidgetNames.EditRedo) as MenuItem;
                (redoMenuItem.Child as Label).Text = redoDescription;
            }
            else
            {
                ClearTooltip(redoButton);
            }
        }
Example #2
0
 private void LoadToolbarIcons(bool defaultUseIdmIcons)
 {
     if (defaultUseIdmIcons)
     {
         foreach (var c in MainToolbar.Children)
         {
             ToolButton item = (ToolButton)c;
             if (item != null)
             {
                 //if (item.IconWidget is Image iconWidget)
                 //{
                 item.IconWidget = new Gtk.Image(GtkUtils.GetIdmToolbarIcon((string)item.Data["iconKey"]));
                 //iconWidget.Pixbuf = GtkUtils.GetIdmToolbarIcon((string)item.Data["iconKey"]);
                 //}
             }
         }
     }
     else
     {
         foreach (var c in MainToolbar.Children)
         {
             ToolButton item = (ToolButton)c;
             if (item != null)
             {
                 //if (item.IconWidget is Image iconWidget)
                 //{
                 item.IconWidget = new Gtk.Image(GtkUtils.GetGtkToolbarIcon(this, (string)item.Data["iconKey"]));
                 //}
             }
         }
     }
     MainToolbar.ShowAll();
 }
Example #3
0
    public MainWindow()
        : base(Gtk.WindowType.Toplevel)
    {
        Application.Init ();

            this.Resize(640,480);
            //menu bar very top
            MenuBar mb = new MenuBar ();
            Menu fileMenu = new Menu ();
            MenuItem menuItem = new MenuItem ("_File");
            menuItem.Submenu = fileMenu;
            mb.Append(menuItem);
            MenuItem menuFileQuit = new MenuItem("Quit");
            fileMenu.Append(menuFileQuit);
            vboxMain.PackStart(mb,false,false,0);

            //toolbar
            Toolbar tbTop = new Toolbar ();
            //toolbutton Staff
            ToolButton tbStaff = new ToolButton (Gtk.Stock.OrientationPortrait);
            tbStaff.Label="Staff";
            tbStaff.IsImportant=true;
            tbStaff.Clicked += HandleTbStaffClicked;
            tbTop.Insert(tbStaff,0);
            //toolbutton Clients
            ToolButton tbClients = new ToolButton (Gtk.Stock.About);
            tbClients.Label="Clients";
            tbClients.IsImportant=true;
            tbClients.Clicked+= HandleTbClientsClicked;
            tbTop.Insert(tbClients,1);
            //media bar
            Label lbMediaTemp = new Label ();
            lbMediaTemp.Text="Media holder";
            lbMediaTemp.Show();
            //pack the toolbar and media bar in the top hbox//
            hbTop.PackStart(tbTop);
            hbTop.PackStart(lbMediaTemp);
            //pack the top hbox in the main vbox
            vboxMain.PackStart(hbTop,false,false,1);
            // horizontal pane
            verticalPane.Position=200;
            verticalPane.Pack1(scrollWindowLeft,false,false);
            verticalPane.Pack2(scrollWindowRight,false,false);
            vboxMain.PackStart(verticalPane);
            scrollWindowLeft.Add(viewPortLeft);

            scrollWindowRight.Add(viewPortRight);
            Label lbMain = new Label ();
            lbMain.Text= "main";
            viewPortRight.Add(lbMain);
            verticalPane.ShowAll();
            //status bar very bottom
            Statusbar sb = new Statusbar ();
            vboxMain.PackStart(sb,false,false,1);

            this.Add(vboxMain);
            //hb1.Add(tbTop);
            this.ShowAll ();
        Build ();
    }
Example #4
0
        /// <summary>
        ///     Creates tool buttons to the bottom right of the screen.
        /// </summary>
        private void CreateToolButtons()
        {
            const int targetY       = -5;
            const int animationTime = 1100;

            PowerButton = new ToolButton(FontAwesome.Get(FontAwesomeIcon.fa_power_button_off), (o, e) => DialogManager.Show(new QuitDialog()))
            {
                Alignment = Alignment.BotRight,
            };

            PowerButton.Y = PowerButton.Height;

            // Add Animation to move it up.
            PowerButton.Animations.Add(new Animation(AnimationProperty.Y, Easing.OutQuint,
                                                     PowerButton.Y, targetY, animationTime));

            MiddleContainer.AddContainedDrawable(PowerButton);

            // Create settings button
            SettingsButton = new ToolButton(FontAwesome.Get(FontAwesomeIcon.fa_settings), (o, e) => DialogManager.Show(new SettingsDialog()))
            {
                Parent     = MiddleContainer,
                Alignment  = Alignment.BotRight,
                Y          = PowerButton.Y,
                X          = PowerButton.X - PowerButton.Width - 5,
                Animations =
                {
                    new Animation(AnimationProperty.Y, Easing.OutQuint, PowerButton.Y, targetY, animationTime)
                }
            };

            MiddleContainer.AddContainedDrawable(SettingsButton);
        }
Example #5
0
        private void build()
        {
            this.vbox1 = new VBox();

            this.toolbar1              = new Toolbar();
            this.aboutbtn1             = new ToolButton(Stock.About);
            this.aboutbtn1.Label       = "About";
            this.aboutbtn1.IsImportant = true;
            this.toolbar1.ToolbarStyle = ToolbarStyle.BothHoriz;
            this.toolbar1.Add(this.aboutbtn1);
            this.vbox1.PackStart(this.toolbar1, false, true, 0);

            this.treestore1 = this.populateTreeStoreFromSession();
            this.scrollw1   = new ScrolledWindow();
            this.hpaned1    = new HPaned();
            this.treeview1  = new TreeView(this.treestore1);
            this.treeview1.HeadersVisible = true;
            this.treeview1.AppendColumn("Session", new CellRendererText(), "text", 0);
            this.treeview1.AppendColumn("Name", new CellRendererText(), "text", 1);
            this.treeview1.ExpandAll();
            this.scrollw1.Add(this.treeview1);
            this.iconview1 = new IconView();
            this.hpaned1.Add1(this.scrollw1);
            this.hpaned1.Add2(this.iconview1);
            this.hpaned1.Position = 254;
            this.vbox1.PackStart(this.hpaned1, true, true, 0);

            this.statusbar1 = new Statusbar();
            this.vbox1.PackEnd(this.statusbar1, false, true, 0);

            this.Add(this.vbox1);
            this.SetSizeRequest(800, 600);

            this.DeleteEvent += HandleDeleteEvent;
        }
        //private SharpAccessory.GenericBusinessClient.VisualComponents
        public Plugin1()
        {
            base.Text = "Demo Plugin 1";

              pnlLeft = new Panel();
              pnlLeft.BackColor = Color.Green;
              pnlLeft.Dock = DockStyle.Left;
              pnlLeft.Visible = false;
              pnlLeft.Width = 150;

              pnlTop = new Panel();
              pnlTop.BackColor = Color.Blue;
              pnlTop.Dock = DockStyle.Top;
              pnlTop.Visible = false;
              pnlTop.Height = 50;

              tbDock = new ToolButton();
              tbDock.Image = TangoIconSet.LoadIcon(TangoIcon.Window_New);
              tbDock.Text = "Show dock";
              tbDock.Click += delegate { ToggleDock(); };

              tbMicroscope = new ToolButton();
              tbMicroscope.Image = TangoIconSet.LoadIcon(TangoIcon.Network_Transmit);
              tbMicroscope.Text = "Mikroskop";
              tbMicroscope.Click += delegate { ShowPlugin("Microscope"); };

              TextBox tb = new TextBox();
              tb.BackColor = Color.Yellow;
              tb.Dock = DockStyle.Fill;
              tb.Multiline = true;
              tb.Parent = Control;
        }
Example #7
0
    void SetToolButtonPosition(ToolButton btn, int index)
    {
        RectTransform btnTrans = (RectTransform)btn.transform;
        Vector2       tmp      = btnTrans.anchorMin;

        if (ButtonOffsetX > 0)
        {
            tmp.x = index * ButtonOffsetX;
        }
        if (ButtonOffsetY > 0)
        {
            tmp.y = 1 - ((index + 1) * ButtonOffsetY);
        }
        btnTrans.anchorMin = tmp;

        tmp = btnTrans.anchorMax;
        if (ButtonOffsetX > 0)
        {
            tmp.x = (index + 1) * ButtonOffsetX;
        }
        if (ButtonOffsetY > 0)
        {
            tmp.y = 1 - (index * ButtonOffsetY);
        }
        btnTrans.anchorMax = tmp;

        btnTrans.offsetMax  = btnTrans.offsetMin = Vector2.zero;
        btnTrans.localScale = IDENTITY_V3;
    }
Example #8
0
    private void ButtonAtGroup(ToolButton button, int groupIndex, int buttonIndex)
    {
        Tool tool = toolGroups[groupIndex].Tools[buttonIndex];

        button.gameObject.name = tool.Name;
        button.SetIcon(tool.Icon);

        ToolGroupType type = toolGroups[groupIndex].Type;

        button.OnClick = () =>
        {
            if (OnClickTool != null)
            {
                OnClickTool(type, tool);
            }
        };

        button.OnEnter = () =>
        {
            float buttonPosX = buttonGroups[groupIndex].GetPosX() + button.GetPosX();
            SetTip(tool.Description, buttonPosX);
            toolTip.SetActive(true);
        };

        button.OnExit = () =>
        {
            toolTip.SetActive(false);
        };
    }
Example #9
0
    public static void Main(string[] args)
    {
        Application app = new Application(null, null);
        app.setMargin(new Margin(10));
        app.setLayout(new VBoxLayout());

        Dialog dialog1 = new Dialog("Dialog 1", Dialog.ButtonOption.NoButtonOption);
        ToolButton button1 = new ToolButton("Show dialog 1");
        button1.connectClick(new DelegateNotify(dialog1.execute));
        app.addWidget(button1);

        Dialog dialog2 = new Dialog("Dialog 2", Dialog.ButtonOption.CancelButtonOption);
        ToolButton button2 = new ToolButton("Show dialog 2");
        button2.connectClick(new DelegateNotify(dialog2.execute));
        app.addWidget(button2);

        Dialog dialog3 = new Dialog("Dialog 3", Dialog.ButtonOption.OKCancelButtonOption);
        ToolButton button3 = new ToolButton("Show dialog 3");
        button3.connectClick(new DelegateNotify(dialog3.execute));
        app.addWidget(button3);

        Dialog dialog4 = new Dialog("Dialog 4", Dialog.ButtonOption.YesNoCancelButtonOption);
        ToolButton button4 = new ToolButton("Show dialog 4");
        button4.connectClick(new DelegateNotify(dialog4.execute));
        app.addWidget(button4);

        app.exec();
    }
Example #10
0
            public MasterDetailMasterTitleContainer()
            {
                _defaultBackgroundColor = Style.Backgrounds[(int)StateType.Normal];

                _root           = new HBox();
                _hamburguerIcon = new Gtk.Image();

                try
                {
                    _hamburguerIcon = new Gtk.Image(HamburgerPixBuf);
                }
                catch (Exception ex)
                {
                    Internals.Log.Warning("MasterDetailPage HamburguerIcon", "Could not load hamburguer icon: {0}", ex);
                }

                _hamburguerButton = new ToolButton(_hamburguerIcon, string.Empty);
                _hamburguerButton.HeightRequest = GtkToolbarConstants.ToolbarItemHeight;
                _hamburguerButton.WidthRequest  = GtkToolbarConstants.ToolbarItemWidth;
                _hamburguerButton.Clicked      += OnHamburguerButtonClicked;

                _titleLabel       = new Gtk.Label();
                _defaultTextColor = _titleLabel.Style.Foregrounds[(int)StateType.Normal];

                _root.PackStart(_hamburguerButton, false, false, GtkToolbarConstants.ToolbarItemSpacing);
                _root.PackStart(_titleLabel, false, false, 25);

                Add(_root);
            }
Example #11
0
        /// <summary>Creates a button according to given parameters.</summary>
        /// <param name="text">Text for button</param>
        /// <param name="image">Image for button</param>
        /// <param name="handler">Handler to call when user clicks on button</param>
        /// <param name="withDropDown">Should the button have a drop-down arrow for a sub-menu?</param>
        private ToolButton CreateButton(string text, Image image, EventHandler handler, bool withDropDown)
        {
            ToolButton button = withDropDown ? new CustomMenuToolButton(image, null) : new ToolButton(image, null);

            button.Homogeneous = false;
            Label btnLabel = new Label(text);

            // Unsure why, but sometimes the label's font is incorrect
            // (inconsistent with default font).
            Pango.FontDescription font = Utility.Configuration.Settings.Font;
            if (font != null && font != btnLabel.Style.FontDescription)
            {
                btnLabel.ModifyFont(Utility.Configuration.Settings.Font);
            }
            btnLabel.LineWrap     = true;
            btnLabel.LineWrapMode = Pango.WrapMode.Word;
            btnLabel.Justify      = Justification.Center;
            btnLabel.Realized    += BtnLabel_Realized;
            button.LabelWidget    = btnLabel;
            if (handler != null)
            {
                button.Clicked += handler;
            }
            return(button);
        }
Example #12
0
    private void CreateToolbar()
    {
        Toolbar toolbar = new Toolbar();

        toolbar.ToolbarStyle = ToolbarStyle.Text;

        System.Action <string, EventHandler> addButton = (text, action) =>
        {
            ToolButton button = new ToolButton(Stock.New);
            button.Label    = text;
            button.Clicked += action;
            toolbar.Insert(button, -1);
        };

        addButton("Moon", (obj, args) => controller.StartMoonAnimation());
        addButton("Sun", (obj, args) => controller.StartSunAnimation());
        addButton("Earth", (obj, args) => controller.StartSunMoonAnimation());
        toolbar.Insert(new SeparatorToolItem(), -1);
        addButton("Pause", (obj, args) => controller.TogglePause());
        addButton("Slow", (obj, args) => controller.Slow());
        addButton("Fast", (obj, args) => controller.Fast());
        toolbar.Insert(new SeparatorToolItem(), -1);
        addButton("Reset", (obj, args) => controller.Reset());

        VBox vbox = new VBox(false, 2);

        vbox.PackStart(toolbar, false, false, 0);
        Add(vbox);
    }
Example #13
0
        /// <summary>Populate the main menu tool strip.</summary>
        /// <param name="menuDescriptions">Descriptions for each item.</param>
        public void Populate(List <MenuDescriptionArgs> menuDescriptions)
        {
            accelerators = new AccelGroup();
            foreach (Widget child in toolStrip.Children)
            {
                toolStrip.Remove(child);
                child.Dispose();
            }
            foreach (MenuDescriptionArgs description in menuDescriptions)
            {
                Gtk.Image            image  = null;
                Gdk.Pixbuf           pixbuf = null;
                ManifestResourceInfo info   = Assembly.GetExecutingAssembly().GetManifestResourceInfo(description.ResourceNameForImage);

                if (info != null)
                {
                    pixbuf = new Gdk.Pixbuf(null, description.ResourceNameForImage, 20, 20);
                    image  = new Gtk.Image(pixbuf);
                }
                ToolItem item = new ToolItem();
                item.Expand = true;

                if (description.OnClick == null)
                {
                    Label toolbarlabel = new Label();
                    if (description.RightAligned)
                    {
                        toolbarlabel.Xalign = 1.0F;
                    }
                    toolbarlabel.Xpad        = 10;
                    toolbarlabel.Text        = description.Name;
                    toolbarlabel.TooltipText = description.ToolTip;
                    toolbarlabel.Visible     = !String.IsNullOrEmpty(toolbarlabel.Text);
                    item.Add(toolbarlabel);
                    toolStrip.Add(item);
                    toolStrip.ShowAll();
                }
                else
                {
                    ToolButton button = new ToolButton(image, description.Name);
                    button.Homogeneous = false;
                    button.LabelWidget = new Label(description.Name);
                    button.Clicked    += description.OnClick;
                    if (!string.IsNullOrWhiteSpace(description.ShortcutKey))
                    {
                        Gtk.Accelerator.Parse(description.ShortcutKey, out uint key, out Gdk.ModifierType modifier);
                        button.AddAccelerator("clicked", accelerators, key, modifier, AccelFlags.Visible);
                    }
                    item = button;
                }
                toolStrip.Add(item);
            }
            Window mainWindow = GetMainWindow();

            if (mainWindow != null)
            {
                mainWindow.AddAccelGroup(accelerators);
            }
            toolStrip.ShowAll();
        }
Example #14
0
        private MainToolBar() : base()
        {
            var listAdapter = ListFrameAdapter.GetInstance();

            // Setup toolbar (icon) buttons
            Toolbar toolbar = new Toolbar();

            toolbar.ToolbarStyle = ToolbarStyle.Icons;

            ToolButton addDay    = new ToolButton(Stock.New);
            ToolButton addParent = new ToolButton(Stock.Add);
            ToolButton addChild  = new ToolButton(Stock.Convert);

            addDay.Clicked    += delegate { listAdapter.AddTab(); };
            addParent.Clicked += delegate { listAdapter.AddParentEntry(); };
            addChild.Clicked  += delegate { listAdapter.AddChildEntry(); };

            toolbar.Insert(addDay, 0);
            toolbar.Insert(addParent, 1);
            toolbar.Insert(addChild, 2);
            toolbar.Insert(new SeparatorToolItem(), 3);

            programmItem = new ProgrammChooserTBItem();

            this.PackStart(toolbar, false, true, 2);
            this.PackStart(programmItem, false, false, 10);
        }
Example #15
0
        private void ToolButton_Click(object sender, RoutedEventArgs e)
        {
            ToolButton btn = sender as ToolButton;

            currentIdx = btn.Index;
            ButtonSelecte(btn);
        }
Example #16
0
        private void Build()
        {
            var vb         = new VBox();
            var toolbar    = new Toolbar();
            var tbiRefresh = new ToolButton(Stock.Refresh);

            toolbar.Insert(tbiRefresh, -1);
            vb.PackStart(toolbar, false, false, 0);

            var hpaned = new HPaned();

            this.nbDataType = new Notebook();
            this.tvDataType = new TreeView();
            this.nbDataType.Add(this.tvDataType);
            this.nbDataType.SetTabLabelText(this.tvDataType, "Data Type");
            hpaned.Add1(this.nbDataType);

            this.nbTypeDetail = new Notebook();
            this.tvTypeDetail = new TreeView();
            this.nbTypeDetail.Add(this.tvTypeDetail);
            this.nbTypeDetail.SetTabLabelText(this.tvTypeDetail, "Data Type Details");
            hpaned.Add2(nbTypeDetail);

            vb.PackStart(hpaned);
            AddWithViewport(vb);
            ShowAll();
        }
Example #17
0
    public static void Main(string[] args)
    {
        Application app = new Application(null, null);

        app.setMargin(new Margin(10));
        app.setLayout(new VBoxLayout());

        Dialog     dialog1 = new Dialog("Dialog 1", Dialog.ButtonOption.NoButtonOption);
        ToolButton button1 = new ToolButton("Show dialog 1");

        button1.connectClick(new DelegateNotify(dialog1.execute));
        app.addWidget(button1);

        Dialog     dialog2 = new Dialog("Dialog 2", Dialog.ButtonOption.CancelButtonOption);
        ToolButton button2 = new ToolButton("Show dialog 2");

        button2.connectClick(new DelegateNotify(dialog2.execute));
        app.addWidget(button2);

        Dialog     dialog3 = new Dialog("Dialog 3", Dialog.ButtonOption.OKCancelButtonOption);
        ToolButton button3 = new ToolButton("Show dialog 3");

        button3.connectClick(new DelegateNotify(dialog3.execute));
        app.addWidget(button3);

        Dialog     dialog4 = new Dialog("Dialog 4", Dialog.ButtonOption.YesNoCancelButtonOption);
        ToolButton button4 = new ToolButton("Show dialog 4");

        button4.connectClick(new DelegateNotify(dialog4.execute));
        app.addWidget(button4);

        app.exec();
    }
Example #18
0
        /// <summary>
        /// Populate the main menu tool strip.
        /// We rebuild the contents from scratch
        /// </summary>
        /// <param name="menuDescriptions">Menu descriptions for each menu item.</param>
        public void PopulateMainToolStrip(List <MenuDescriptionArgs> menuDescriptions)
        {
            foreach (Widget child in toolStrip.Children)
            {
                toolStrip.Remove(child);
            }
            foreach (MenuDescriptionArgs description in menuDescriptions)
            {
                Gdk.Pixbuf pixbuf = new Gdk.Pixbuf(null, description.ResourceNameForImage, 20, 20);
                ToolButton button = new ToolButton(new Gtk.Image(pixbuf), description.Name);
                button.Homogeneous = false;
                button.LabelWidget = new Label(description.Name);
                Pango.FontDescription font = new Pango.FontDescription();
                font.Size = (int)(8 * Pango.Scale.PangoScale);
                button.LabelWidget.ModifyFont(font);
                if (description.OnClick != null)
                {
                    button.Clicked += description.OnClick;
                }
                toolStrip.Add(button);
            }
            ToolItem item = new ToolItem();

            item.Expand         = true;
            toolbarlabel        = new Label();
            toolbarlabel.Xalign = 1.0F;
            toolbarlabel.Xpad   = 10;
            toolbarlabel.ModifyFg(StateType.Normal, new Gdk.Color(0x99, 0x99, 0x99));
            item.Add(toolbarlabel);
            toolbarlabel.Visible = false;
            toolStrip.Add(item);
            toolStrip.ShowAll();
        }
Example #19
0
    private void Start()
    {
        sys  = FindObjectOfType <WindowSystem>();
        pref = FindObjectOfType <PrefabManager>();

        LocalDataManager.instance.OnCorporationChange += OnCorpChange;

        ToolButton corp = Instantiate(buttonPrefab, buttonGrid);

        corp.SetTitle("Corp");
        corp.GetComponent <Button>().onClick.AddListener(() => OnShowCorpClic());

        ToolButton ships = Instantiate(buttonPrefab, buttonGrid);

        ships.SetTitle("Ships");
        ships.GetComponent <Button>().onClick.AddListener(() => OnMyShipClic());
        _buttonNeedingCorp.Add(ships);

        ToolButton stations = Instantiate(buttonPrefab, buttonGrid);

        stations.SetTitle("Stations");
        stations.GetComponent <Button>().onClick.AddListener(() => OnStationsClic());
        _buttonNeedingCorp.Add(stations);

        ToolButton market = Instantiate(buttonPrefab, buttonGrid);

        market.SetTitle("Market");
        market.GetComponent <Button>().onClick.AddListener(() => OnMarketClic());
        _buttonNeedingCorp.Add(market);

        ToolButton bookmarks = Instantiate(buttonPrefab, buttonGrid);

        bookmarks.SetTitle("Places");
        bookmarks.GetComponent <Button>().onClick.AddListener(() => OnBookmarkClic());
        _buttonNeedingCorp.Add(bookmarks);

        ToolButton plans = Instantiate(buttonPrefab, buttonGrid);

        plans.SetTitle("Plans");
        plans.GetComponent <Button>().onClick.AddListener(() => OnPlanClick());
        _buttonNeedingCorp.Add(plans);

        mailButton = Instantiate(buttonPrefab, buttonGrid);
        mailButton.SetTitle("Mails");
        mailButton.GetComponent <Button>().onClick.AddListener(() => OnMailsClic());
        LocalDataManager.instance.OnMailboxChange += (m) => { mailButton.SetBlinking(true); };
        _buttonNeedingCorp.Add(mailButton);

        ToolButton options = Instantiate(buttonPrefab, buttonGrid);

        options.SetTitle("Menu");
        options.GetComponent <Button>().onClick.AddListener(() => OnMenuClic());

        ToolButton console = Instantiate(buttonPrefab, buttonGrid);

        console.SetTitle("Console");
        console.GetComponent <Button>().onClick.AddListener(() => OnConsoleClic());

        OnCorpChange(null);
    }
Example #20
0
 static void AddToolbarItems(Toolbar toolbar, params String[] names)
 {
     foreach (var s in names)
     {
         var item = new ToolButton(s);
         toolbar.Insert(item, -1);
     }
 }
Example #21
0
        public ToolButton CreateButton(int image, string text, EventHandler h)
        {
            ToolButton b = new ToolButton(UI.buttonImages, image, h, text);

            buttons.Add(b);
            Controls.Add(b);
            return(b);
        }
Example #22
0
        ToolButton CreateButton(List <Control> list, int image, string text, EventHandler h)
        {
            ToolButton b = new ToolButton(buttonImages, image, h, text);

            header.Controls.Add(b);
            list.Add(b);
            return(b);
        }
Example #23
0
            public static ToolButton CreateToolButton(string stockId)
            {
                ToolButton button = new ToolButton(stockId);

                ApplyDefaultDimensions(button);

                return(button);
            }
Example #24
0
 /// <summary>
 /// Invoked when theme is toggled.
 /// Toggles the icon displayed on the "toggle theme" button.
 /// </summary>
 /// <param name="sender">Sender object.</param>
 /// <param name="args">Event arguments.</param>
 public void ToggleTheme(object sender, EventArgs args)
 {
     if (sender is ToolButton)
     {
         ToolButton button = sender as ToolButton;
         button.IconWidget = Utility.Configuration.Settings.DarkTheme ? defaultThemeIcon : darkThemeIcon;
         button.IconWidget.ShowAll();
     }
 }
        public void Property_SetAndGetValue_ReturnsDefaultValue(string propertyName, object expected)
        {
            // Arrange:
            var toolButton    = new ToolButton();
            var privateObject = new PrivateObject(toolButton);

            // Act: // Assert:
            privateObject.GetFieldOrProperty(propertyName).ShouldBe(expected);
        }
Example #26
0
 public ToolbarButton(ICommand cmd) : base(cmd)
 {
     button          = new ToolButton(cmd.Properties.Icon);
     button.Clicked += new EventHandler(OnClicked);
     button.Label    = cmd.Properties.Text;
     this.Add(button);
     button.Show();
     this.ShowAll();
 }
Example #27
0
        private void AddButtonToPanel(FlowLayoutPanel panel, ToolModel toolModel)
        {
            ToolButton buttonTool = new ToolButton();

            buttonTool.Text   = toolModel.TextButton;
            buttonTool.Action = toolModel.ActionButton;
            buttonTool.Click += ButtonTool_Click;
            panel.Controls.Add(buttonTool);
        }
Example #28
0
        // 生成button
        private void GenerateButton()
        {
            // cellLen 不能太小否则内存爆炸,并且卡炸
            if (BackgroundImage.Source != null && this.cellLen >= 32)
            {
                var iter = buttonlist.GetEnumerator();
                iter.MoveNext();
                finalIndex = 0;
                double dCellLen = this.cellLen * this.scale;
                // 清理
                ResetButton();
                ImageCanvas.Children.RemoveRange(buttonStartIndex, ImageCanvas.Children.Count - buttonStartIndex);
                maxWidth  = (int)Math.Ceiling(BackgroundImage.Source.Width / this.cellLen) - 1;
                maxHeight = (int)Math.Ceiling(BackgroundImage.Source.Height / this.cellLen) - 1;
                int y = 0;
                for (double i = 0; i + dCellLen < BackgroundImage.Source.Height * scale; i += dCellLen)
                {
                    int x = 0;
                    for (double j = 0; j + dCellLen < BackgroundImage.Source.Width * scale; j += dCellLen)
                    {
                        if (iter.Current != null)
                        {
                            // 设置xy
                            iter.Current.X = x;
                            iter.Current.Y = y;
                            iter.Current.SetCellLen(dCellLen);
                            // 放置
                            ImageCanvas.Children.Add(iter.Current);
                            Canvas.SetLeft(iter.Current, j + BackgroundImage.Margin.Left);
                            Canvas.SetTop(iter.Current, i + BackgroundImage.Margin.Top);

                            iter.MoveNext();
                        }
                        else
                        {
                            ToolButton button = new ToolButton(finalIndex, dCellLen);
                            buttonlist.Add(button);
                            // 放置
                            ImageCanvas.Children.Add(button);
                            Canvas.SetLeft(button, j + BackgroundImage.Margin.Left);
                            Canvas.SetTop(button, i + BackgroundImage.Margin.Top);
                            Canvas.SetZIndex(button, 10);
                            button.Click += new RoutedEventHandler(ToolButton_Click);
                            // 设置xy
                            button.X = x;
                            button.Y = y;
                        }
                        // 其他操作
                        finalIndex++;
                        x++;
                    }
                    y++;
                }
                isChangedMap = 0;
            }
        }
Example #29
0
        private IList <ToolButton> GetButtonsByTwoPoint(Point p1, Point p2)
        {
            ToolButton leftTopButton = GetLeftTopButon(p1, p2);
            ToolButton btn1          = GetButtonByPoint(p1);
            ToolButton btn2          = GetButtonByPoint(p2);
            int        offsetX       = Math.Abs(btn1.X - btn2.X);
            int        offsetY       = Math.Abs(btn1.Y - btn2.Y);

            return(GetButtons(leftTopButton, offsetX, offsetY));
        }
Example #30
0
 // TODO: This should handle sorting the items
 public void AddItem(ToolButton item)
 {
     if (tb1.NItems <= tb2.NItems)
     {
         tb1.Insert(item, tb1.NItems);
     }
     else
     {
         tb2.Insert(item, tb2.NItems);
     }
 }
Example #31
0
    public ToolButton CreateToolButton()
    {
        GameObject buttonObject = GameObject.Instantiate(ToolButtonPrefab.gameObject);

        buttonObject.transform.SetParent(buttonPoolObject.transform, false);
        ToolButton toolButton = buttonObject.GetComponent <ToolButton>();

        toolButton.Init();

        return(toolButton);
    }
Example #32
0
            public static ToolButton CreateToolButton(string iconFileName, string title)
            {
                var pixBuf = new Pixbuf(iconFileName);
                var image  = new Gtk.Image(pixBuf);

                ToolButton button = new ToolButton(image, title);

                ApplyDefaultDimensions(button);

                return(button);
            }
Example #33
0
    private void ToolButtonAtIndex(ToolButton toolButton, int i)
    {
        toolButton.transform.SetParent(btnWrap.transform, false);

        float posX  = UIConstants.ToolButtonWidth * i + UIConstants.ToolButtonSpacing * (i + 1);
        float width = UIConstants.ToolButtonWidth;

        toolButton.SetPosXAndWidth(posX, width);

        ButtonAtIndex(toolButton, i);
    }
Example #34
0
        private void CreateToolButton(ref int x, string name, string text, Bitmap bitmap)
        {
            ToolButton btn = new ToolButton(x, 250, Program.ShortcutIconSize, Program.ShortcutIconSize)
            {
                Name = name,
                Foreground = new ImageBrush(bitmap)
            };
            //btn.Foreground.Opacity = 200;
            btn.Click += new EventHandler(ToolButton_Click);
            Children.Add(btn);

            TextBlock lbl = new TextBlock(x, btn.Area.Bottom, Program.ShortcutIconSize, 20, Program.FontCourierNew10, text)
            {
                ForeColor = Program.ButtonTextColor,
                TextAlignment = TextAlignment.Center,
                TextVerticalAlignment = VerticalAlignment.Top
            };
            Children.Add(lbl);

            x += btn.Width + 10;
        }
            public ICSDetailsWidget()
                : base()
            {
                menubar = new ICSMenuBar ();
                menubar.disconnectMenuItem.Activated +=
                    on_disconnect_activate;
                menubar.connectMenuItem.Activated +=
                    on_connect_activate;
                menubar.ShowAll ();

                Image img = new Image ();
                img.Stock = Stock.Network;
                toolbutton =
                    new ToolButton (img,
                            Catalog.
                            GetString
                            ("Chess Server"));
                toolbutton.ShowAll ();

                client = new ICSClient ();
                title = String.Format (Catalog.GetString
                               ("ICS: {0}@{1}:{2}"),
                               client.User,
                               client.server,
                               client.port);
                book = new Notebook ();
                book.Show ();

                Add (book);

                obManager =
                    new GameObservationManager (client,
                                    this);

                observableGames =
                    new ObservableGamesWidget (obManager);

                graph = new GameAdvertisementGraph (client);
                book.AppendPage (graph,
                         new Label (Catalog.
                                GetString
                                ("Seek Graph")));
                ads = new GameAdvertisements (client);
                book.AppendPage (ads,
                         new Label (Catalog.
                                GetString
                                ("Game Seeks")));

                book.AppendPage (observableGames,
                         new Label (Catalog.
                                GetString
                                ("Watch Games")));

                shell = new ICSShell (client);
                book.AppendPage (shell,
                         new Label (Catalog.
                                GetString
                                ("Shell")));

                client.ChallengeEvent += OnChallengeEvent;

                client.AuthEvent += OnAuth;
                client.ConnectionErrorEvent +=
                    OnConnectionError;

                ShowConfigWidget ();

                menubar.disconnectMenuItem.Sensitive = false;
                GLib.Idle.Add (delegate ()
                           {
                           Authenticate (); return false;}
                );

                accel = new AccelGroup ();
                menubar.quitMenuItem.
                    AddAccelerator ("activate", accel,
                            new AccelKey (Gdk.Key.
                                      q,
                                      Gdk.
                                      ModifierType.
                                      ControlMask,
                                      AccelFlags.
                                      Visible));
                ShowAll ();
                CsBoardApp.Instance.QuitEvent += OnQuitEvent;
            }
 public GameDbBrowser()
     : base()
 {
     accel = new AccelGroup ();
     title = Catalog.GetString ("Game Database");
     menubar = new AppMenuBar ();
     menubar.ShowAll ();
     Image img =
         new Image (Gdk.Pixbuf.
                LoadFromResource
                ("dbicon.png"));
     toolbutton =
         new ToolButton (img, Catalog.
                 GetString
                 ("Database"));
     toolbutton.ShowAll ();
     menubar.quitMenuItem.
         AddAccelerator ("activate", accel,
                 new AccelKey (Gdk.Key.
                           q,
                           Gdk.
                           ModifierType.
                           ControlMask,
                           AccelFlags.
                           Visible));
 }
Example #37
0
    private void SetHorizontalToolBar()
    {
        ToolButton editbutton = new ToolButton(Stock.Edit);
          editbutton.IsImportant = true;
          editbutton.Sensitive = true;
          editbutton.Clicked += new EventHandler(OnEditButtonClicked);
          toolbar1.Insert(editbutton, -1);

          lockbutton = new ToggleToolButton(Stock.DndMultiple);
          lockbutton.IsImportant = true;
          lockbutton.Sensitive = true;
          lockbutton.Label = "Lock View";
          lockbutton.Clicked += new EventHandler(OnLockButtonClicked);
          toolbar1.Insert(lockbutton, -1);

          streambutton = new ToggleToolButton(Stock.SelectAll);
          streambutton.IsImportant = true;
          streambutton.Sensitive = true;
          streambutton.Label = "Photostream";
          streambutton.Clicked += new EventHandler(OnStreamButtonClicked);
          toolbar1.Insert(streambutton, -1);

          uploadbutton = new ToggleToolButton(Stock.SortAscending);
          uploadbutton.IsImportant = true;
          uploadbutton.Sensitive = true;
          uploadbutton.Label = "Uploads";
          uploadbutton.Clicked += new EventHandler(OnUploadButtonClicked);
          toolbar1.Insert(uploadbutton, -1);

          downloadbutton = new ToggleToolButton(Stock.SortDescending);
          downloadbutton.IsImportant = true;
          downloadbutton.Sensitive = true;
          downloadbutton.Label = "Downloads";
          downloadbutton.Clicked += new EventHandler(OnDownloadButtonClicked);
          toolbar1.Insert(downloadbutton, -1);

          conflictbutton = new ToggleToolButton(Stock.DialogWarning);
          conflictbutton.IsImportant = true;
          conflictbutton.Sensitive = true;
          conflictbutton.Label = "Conflicts";
          conflictbutton.Clicked += new EventHandler(OnConflictButtonClicked);
          toolbar1.Insert(conflictbutton, -1);

          syncbutton = new ToolButton(Stock.Refresh);
          syncbutton.IsImportant = true;
          syncbutton.Sensitive = true;
          syncbutton.Label = "Sync Now";
          syncbutton.Clicked += new EventHandler(ConnectionHandler);
          toolbar1.Insert(syncbutton, -1);

          // Update the stream and conflict buttons with their respective number
          // of photos.
          UpdateToolBarButtons();
    }
Example #38
0
 void EnableButtons(ToolButton[] buttons, bool enable)
 {
     foreach (var toolButton in buttons)
     {
         toolButton.enabled = enable;
     }
 }
Example #39
0
    void CreateComponents()
    {
        fullViewVBox = new VBox (false, 0);
        rootWidget = fullViewVBox;

        CreateMenuBar ();

        CreateToolBar();

        // Create the docking widget and add it to the window.
        dock = new DockFrame ();
        dock.Homogeneous = false;
        dock.DefaultItemHeight = 100;
        dock.DefaultItemWidth = 100;
        //dock.CompactGuiLevel = 1;

        toolbarFrame.AddContent (dock);

        // Create the notebook for the various documents.
        tabControl = new DragNotebook (); //(dock.ShadedContainer);
        tabControl.Scrollable = true;
        tabControl.AppendPage( new Label( "Other page" ), new Label( "Favorite Page  " ) );
        tabControl.AppendPage( new Label( "What page" ), new Label( "Welcome/Start Page  " ) );
        tabControl.AppendPage( new TextView(), new Image( "gtk-new", IconSize.Menu ) );
        tabControl.ShowAll();

        // The main document area
        documentDockItem = dock.AddItem ("Documents");
        documentDockItem.Behavior = DockItemBehavior.Locked;
        documentDockItem.Status = DockItemStatus.AutoHide;
        documentDockItem.DefaultHeight = 100;
        documentDockItem.DefaultWidth = 100;
        documentDockItem.DefaultStatus = DockItemStatus.AutoHide;
        documentDockItem.DefaultLocation = "Document/Right";
        documentDockItem.Expand = true;
        documentDockItem.DrawFrame = true;
        documentDockItem.Label = "Documents";
        documentDockItem.Content = tabControl;
        documentDockItem.DefaultVisible = true;
        documentDockItem.Visible = true;

        DockItem dit = dock.AddItem ("left");
        dit.Status = DockItemStatus.AutoHide;
        dit.DefaultHeight = 100;
        dit.DefaultWidth = 100;
        dit.DefaultStatus = DockItemStatus.AutoHide;
        dit.DefaultLocation = "left";
        dit.Behavior = DockItemBehavior.Normal;
        dit.Label = "Left";
        dit.DefaultVisible = true;
        dit.Visible = true;
        DockItemToolbar tb = dit.GetToolbar(PositionType.Top);
        ToolButton b = new ToolButton(null,"Hello");
        tb.Add(b,false);
        tb.Visible = true;
        tb.ShowAll();

        dit = dock.AddItem ("right");
        dit.Status = DockItemStatus.AutoHide;
        dit.DefaultHeight = 100;
        dit.DefaultWidth = 100;
        dit.DefaultStatus = DockItemStatus.AutoHide;
        dit.DefaultLocation = "Documents/Right";
        dit.Behavior = DockItemBehavior.Normal;
        dit.Label = "Right";
        dit.DefaultVisible = true;
        dit.Visible = true;
        //dit.Icon = Gdk.Pixbuf.LoadFromResource("Cage.Shell.Docking.stock-close-12.png");

        dit = dock.AddItem ("top");
        dit.Status = DockItemStatus.AutoHide;
        dit.DefaultHeight = 100;
        dit.DefaultWidth = 100;
        dit.DefaultStatus = DockItemStatus.AutoHide;
        dit.DefaultLocation = "Documents/Top";
        dit.Behavior = DockItemBehavior.Normal;
        dit.Label = "Top";
        dit.DefaultVisible = true;
        dit.Visible = true;

        dit = dock.AddItem ("bottom");
        dit.Status = DockItemStatus.AutoHide;
        dit.DefaultHeight = 100;
        dit.DefaultWidth = 100;
        dit.DefaultStatus = DockItemStatus.AutoHide;
        dit.DefaultLocation = "Documents/Bottom";
        dit.Behavior = DockItemBehavior.Normal;
        dit.Label = "Bottom";
        dit.DefaultVisible = true;
        dit.Visible = true;

        if ( File.Exists( "toolbar.status" ) )
        {
            toolbarFrame.LoadStatus("toolbar.status");
        }

        if ( File.Exists( "config.layout" ) )
        {
            dock.LoadLayouts( "config.layout" );
        }
        else
        {
            dock.CreateLayout( "test", true );
        }

        dock.CurrentLayout = "test";
        dock.HandlePadding = 0;
        dock.HandleSize = 10;

        dock.SaveLayouts( "config.layout" );
        toolbarFrame.SaveStatus("toolbar.status");

        Add (fullViewVBox);
        fullViewVBox.ShowAll ();

        statusBar = new Gtk.Statusbar();
        fullViewVBox.PackEnd (statusBar, false, true, 0);
    }
 public GameDbBrowser()
     : base()
 {
     title = Catalog.GetString ("Game Database");
     menubar = new AppMenuBar ();
     menubar.ShowAll ();
     Image img =
         new Image (Gdk.Pixbuf.
                LoadFromResource
                ("dbicon.png"));
     toolbutton =
         new ToolButton (img, Catalog.
                 GetString
                 ("Database"));
     toolbutton.ShowAll ();
 }
Example #41
0
        void OnMeshEditorButton(ToolButton cmd)
        {
            switch ((MeshEditor.SelectionType)cmd.commandEnum)
            {
                case SelectionType.Vertex:
                    MeshSelection = SelectionType.Vertex;
                    break;

                case SelectionType.Polygon:
                    MeshSelection = SelectionType.Polygon;
                    break;

                case SelectionType.Edge:
                    MeshSelection = SelectionType.Edge;
                    break;

                case SelectionType.None:
                    MeshSelection = SelectionType.None;
                    break;
            }
        }
Example #42
0
        private HtmlGenericControl InteractiveControls()
        {
            var container = new HtmlGenericControl("div");

            var reasonTextBox = new TextBox
                {
                    ID = "ReasonTextBox",
                    ClientIDMode = ClientIDMode.Static
                };
            var reasonLabel = new Label
                {
                    Text = "Reason (Explain yourself):",
                    AssociatedControlID = reasonTextBox.ID
                };
            container.Controls.Add(reasonLabel);
            container.Controls.Add(reasonTextBox);

            const string msg =
                "If you don't have a reason for doing that, then you probably shouldn't. Reason is required when changing settings.";
            var reasonValidator = new RequiredFieldValidator
                {
                    ControlToValidate = reasonTextBox.ID,
                    Text = "* ",
                    ErrorMessage = msg,
                    EnableClientScript = true
                };
            container.Controls.Add(reasonValidator);

            var downloadButton = new ToolButton
                {
                    ID = "downloadButton",
                    Text = "Download audit log",
                    ToolTip = "Export the audit log and open it in for instance Excel.",
                    SkinID = "Save",
                    CausesValidation = false
                };
            downloadButton.Click += Download_Click;
            container.Controls.Add(downloadButton);

            return container;
        }
Example #43
0
        void OnPrimitivesButton(ToolButton btn)
        {
            var command = btn.commandType;
            var method = command.GetMethod("Create");

            method.Invoke(null, null);

            if (Selection.activeGameObject)
            {
                Utils.FocusSceneCamera(Selection.activeGameObject);
            }
        }
Example #44
0
    private void SetTopLeftToolBar()
    {
        connectbutton = new ToolButton(Stock.Refresh);
          connectbutton.Sensitive = true;
          connectbutton.Clicked += new EventHandler(ConnectionHandler);
          connectbutton.SetTooltip(tips, "Sync Now", "Sync Now");
          toolbar2.Insert(connectbutton, -1);

          ToolButton addsetbutton = new ToolButton(Stock.Add);
          addsetbutton.Sensitive = true;
          addsetbutton.Clicked += new EventHandler(OnAddNewSetEvent);
          addsetbutton.SetTooltip(tips, "Add New Set", "Add New Set");
          toolbar2.Insert(addsetbutton, -1);

          ToolButton editbutton = new ToolButton(Stock.Edit);
          editbutton.Sensitive = true;
          editbutton.Clicked += new EventHandler(OnEditButtonClicked);
          editbutton.SetTooltip(tips, "Edit", "Edit");
          toolbar2.Insert(editbutton, -1);

          uploadfilechooserbutton = new ToolButton(Stock.SortAscending);
          uploadfilechooserbutton.Sensitive = true;
          uploadfilechooserbutton.Clicked += new EventHandler(OnUploadPhotosMenuItemClicked);
          uploadfilechooserbutton.SetTooltip(tips, "Upload Photos", "Upload Photos");
          toolbar2.Insert(uploadfilechooserbutton, -1);

          ToolButton downloadfilechooserbutton = new ToolButton(Stock.SortDescending);
          downloadfilechooserbutton.Sensitive = true;
          downloadfilechooserbutton.Clicked += new EventHandler(OnDownloadPhotosMenuItemClicked);
          downloadfilechooserbutton.SetTooltip(tips, "Download Photos", "Download Photos");
          toolbar2.Insert(downloadfilechooserbutton, -1);

          ToolButton quitbutton = new ToolButton(Stock.Quit);
          quitbutton.Sensitive = true;
          quitbutton.Clicked += new EventHandler(OnQuitEvent);
          quitbutton.SetTooltip(tips, "Quit", "Quit");
          toolbar2.Insert(quitbutton, -1);
    }
Example #45
0
    private void SetCommentsToolBar()
    {
        toolbar3.ToolbarStyle = ToolbarStyle.Icons;
          _addcommentbutton = new ToolButton(Stock.Add);
          _addcommentbutton.Sensitive = true;
          _addcommentbutton.SetTooltip(tips, "Add Comment", "Add Comment");
          _addcommentbutton.Clicked += new EventHandler(OnAddCommentButtonClicked);
          toolbar3.Insert(_addcommentbutton, -1);

          _editcommentbutton = new ToolButton(Stock.Edit);
          _editcommentbutton.Sensitive = true;
          _editcommentbutton.SetTooltip(tips, "Edit Comment", "Edit Comment");
          _editcommentbutton.Clicked += new EventHandler(OnEditCommentButtonClicked);
          toolbar3.Insert(_editcommentbutton, -1);

          _deletecommentbutton = new ToolButton(Stock.Delete);
          _deletecommentbutton.Sensitive = true;
          _deletecommentbutton.SetTooltip(tips, "Delete Comment", "Delete Comment");
          _deletecommentbutton.Clicked += new EventHandler(OnDeleteCommentButtonClicked);
          toolbar3.Insert(_deletecommentbutton, -1);
    }
Example #46
0
    void CreateToolBar()
    {
        toolbarFrame = new DockToolbarFrame();
        ((VBox)rootWidget).PackStart (toolbarFrame, true, true, 0);

        DockToolbar tb1 = new DockToolbar("MyToolbar","The Toolbar");
        tb1.ToolbarStyle = ToolbarStyle.Icons;
        ToolButton b = new ToolButton("gtk-quit");
        b.Clicked += onButtonPressEvent;
        tb1.Add(b);
        tb1.ShowAll();
        tb1.IconSize =Gtk.IconSize.SmallToolbar;
        toolbarFrame.AddBar(tb1);
    }
Example #47
0
    protected void PopulateFilterToolbar()
    {
        int i = 0;

          foreach (CommandSpec CmdSpec in PipeEng.CmdSpecs)
          {
         ToolButton TheButton = new ToolButton(CmdSpec.IconName);
         TheButton.Name = CmdSpec.Name + "Button";
         TheButton.Label = CmdSpec.Name;

         Tooltips TT = new Tooltips();
         TheButton.SetTooltip (TT, CmdSpec.ShortDesc, CmdSpec.ShortDesc);

         TheButton.Sensitive = true;
         TheButton.Clicked += FilterButton_OnActivated;
         TheButton.Show();
         CommandsToolbar.Insert(TheButton,i++);
          }
    }
Example #48
0
        private void createActions()
        {
            this.purgeOldActions();

              var t = new Tooldivider { ID = Control.GetUniqueID("action") };
              this.MyToolbar.Controls.Add(t);
              foreach (CommandItem item in Current.Context.ReportItem.Commands)
              {
            var ctl = new ToolButton
              {
            Header = item.Name,
            Icon = item.Icon,
            Click = string.Concat("ASRMainFormcommand:", item.Name),
            ID = Control.GetUniqueID("action")
              };

            this.MyToolbar.Controls.Add(ctl);
              }

              Context.ClientPage.ClientResponse.Refresh(this.MyToolbar);
        }
Example #49
0
        void OnSystemButton(ToolButton btn)
        {
            switch ((SystemCommands) btn.commandEnum)
            {
                case SystemCommands.Save:
                {
                    var menu = new GenericMenu();

                    menu.AddItem(new GUIContent("Save as mesh"),   false, SaveCallback, ExportOptions.UnityMesh);
                    menu.AddItem(new GUIContent("Save as prefab"), false, SaveCallback, ExportOptions.Prefab);
                    menu.AddItem(new GUIContent("Export to OBJ"),  false, SaveCallback, ExportOptions.OBJ);
                    menu.ShowAsContext();
                }
                break;

                case SystemCommands.Undo:
                    OnUndo();
                    break;

                case SystemCommands.Redo:
                    OnRedo();
                    break;

                case SystemCommands.Help:
                    HelpWindow.ShowWindow();
                    break;

                case SystemCommands.Grid:
                {
                    var menu = new GenericMenu();

                    menu.AddItem(new GUIContent(IsGridVisible()?"Hide grid":"Show grid"), false, GridCallback, GridOptions.Enable);
                    menu.AddItem(new GUIContent("Grid settings"), false, GridCallback, GridOptions.Settings);
                    menu.ShowAsContext();
                }
                break;
            }
        }
Example #50
0
 private void loadMenuItemsRec(Item root, System.Web.UI.Control ctl)
 {
     var menuitems = root.Children;
       foreach (Item mItem in menuitems)
       {
     Control child = null;
     switch (mItem.Template.Key)
     {
       case "toolmenu":
     //Toolmenu tm = new Toolmenu();
     var tm = new Toolmenu { ID = Control.GetUniqueID("T") };
     tm.LoadFromItem(mItem);
     this.loadMenuItemsRec(mItem, tm);
     child = tm;
     break;
       case "toolbar divider":
     var td = new Tooldivider();
     child = td;
     break;
       case "toolbutton":
     var tb = new ToolButton();
     //Toolbutton tb = new Toolbutton();
     tb.LoadFromItem(mItem);
     child = tb;
     break;
       case "toolmenubutton":
     //Toolmenubutton tmb = new Toolmenubutton();
     var tmb = new ToolMenuButton();
     tmb.LoadFromItem(mItem);
     child = tmb;
     break;
       case "menu item":
     var mi = new MenuItem();
     mi.LoadFromItem(mItem);
     child = mi;
     break;
       default:
     break;
     }
     if (child != null)
     {
       ctl.Controls.Add(child);
     }
       }
 }
Example #51
0
 public void registerButton(ToolButton tb, Plugins.IMapPlugin mapPlugin)
 {
     tb.guid = mapPlugin.guid;
     tools[mapPlugin.guid] = mapPlugin;
     tb.CheckedChanged += new EventHandler(toolchanged);
 }
            public OpeningBrowserUI(OpeningsDb db)
                : base()
            {
                menubar = new AppMenuBar ();
                title = Catalog.GetString ("Opening Browser");
                accel = new AccelGroup ();
                menubar.quitMenuItem.
                    AddAccelerator ("activate", accel,
                            new AccelKey (Gdk.Key.
                                      q,
                                      Gdk.
                                      ModifierType.
                                      ControlMask,
                                      AccelFlags.
                                      Visible));
                toolbutton = new ToolButton (Stock.Info);
                toolbutton.Label =
                    Catalog.GetString ("Openings");
                toolbutton.ShowAll ();

                this.db = db;
                store = new TreeStore (typeof (string),
                               typeof (int),
                               typeof (string));
                this.db.PopulateTree (store);
                view = new TreeView ();
                view.Model = store;
                view.AppendColumn (Catalog.
                           GetString ("Moves"),
                           new CellRendererText (),
                           "text", 0);
                view.AppendColumn (Catalog.
                           GetString ("Variations"),
                           new CellRendererText (),
                           "text", 1);
                view.AppendColumn (Catalog.
                           GetString ("Name"),
                           new CellRendererText (),
                           "markup", 2);

                ScrolledWindow win = new ScrolledWindow ();
                win.SetPolicy (PolicyType.Automatic,
                           PolicyType.Automatic);
                win.Add (view);

                boardWidget = new GameViewerBoard ();
                HPaned split = new HPaned ();
                VBox box = new VBox ();
                box.PackStart (boardWidget, true, true, 2);
                split.Pack1 (box, false, true);	// resize, shrink
                split.Pack2 (win, true, true);
                split.ShowAll ();
                //split.Position = 400;
                int width, height;
                CsBoardApp.Instance.Window.GetSize (out width,
                                    out
                                    height);
                split.Position =
                    (int) Math.Round (width * 0.5f);
                split.PositionSet = true;
                PackStart (split, true, true, 2);

                view.CursorChanged += OnCursorChanged;
                ShowAll ();
            }
Example #53
0
        private void DisplayButtonSection(ToolButton[] btns, int buttonsPerLine, GUIStyle btnStyle, OnToolButton callback, System.Enum selection = null)
        {
            var buttons = btns.Count();
            var btn = 0;

            var guiEnabled = GUI.enabled;

            while (btn < buttons)
            {
                GUILayout.BeginHorizontal();

                var defaultColor = GUI.backgroundColor;

                for (var i = 0; i < buttonsPerLine; i++)
                {
                    var meshCommand = btns[btn];

                    if (selection != null && Equals(meshCommand.commandEnum, selection))
                    {
                        GUI.backgroundColor = Color.gray;
                    }

                    GUI.enabled = meshCommand.enabled;

                    if (GUILayout.Button(Resources.Load(meshCommand.icon) as Texture2D, btnStyle))
                    {
                        callback(meshCommand);
                    }

                    btn++;

                    GUI.backgroundColor = defaultColor;

                    if (btn >= buttons)
                        break;
                }

                GUILayout.EndHorizontal();
            }

            GUI.enabled = guiEnabled;
        }