Inheritance: MonoBehaviour
Beispiel #1
0
        public PostService(IPostRepository postRepository, ICommentService commentService, ILinkService linkService, ISmileyService smileyService, TextHelper textHelper)
        {
            Ensure.That(() => postRepository).IsNotNull();
            Ensure.That(() => commentService).IsNotNull();
            Ensure.That(() => linkService).IsNotNull();
            Ensure.That(() => smileyService).IsNotNull();
            Ensure.That(() => textHelper).IsNotNull();

            this.postRepository = postRepository;
            this.commentService = commentService;
            this.linkService = linkService;
            this.smileyService = smileyService;
            this.textHelper = textHelper;
        }
Beispiel #2
0
        /// <summary>
        /// This method returns the number of items imported
        /// </summary>
        /// <param name="text">The contents to be imported.</param>
        /// <param name="tableName">Only used in cases where more than one import takes place.</param>
        /// <param name="expectedCount">Number of expected columns in the csv file</param>
        /// <param name="callback">The method to call to update progress</param>
        /// <returns></returns>
        public static int ImportData(string text, string tableName, int expectedCount, ImportProgressCallback callback)
        {
            // initial value
            int savedCount = 0;

            // locals
            char[]      delimiters  = { ',' };
            int         count       = 0;
            int         totalCount  = 0;
            int         refreshRate = 5;
            List <Word> words       = null;
            RawImport   rawImport   = null;

            // if the fileExists
            if (TextHelper.Exists(text))
            {
                // Create a new instance of a 'Gateway' object.
                Gateway gateway = new Gateway();

                // set the textLines
                List <TextLine> textLines = WordParser.GetTextLines(text.Trim());

                // If the textLines collection exists and has one or more items
                if (ListHelper.HasOneOrMoreItems(textLines))
                {
                    // notify the callback to setup the Graph - table name is optional if you have more than one import
                    callback(textLines.Count, "RawImport");

                    // change the RefreshRate
                    if (textLines.Count > 1000)
                    {
                        // change this to whatever makes since for your app
                        refreshRate = 25;
                    }

                    // set the totalCount
                    totalCount = textLines.Count - 1;

                    // Iterate the collection of TextLine objects
                    foreach (TextLine textLine in textLines)
                    {
                        // Increment the value for count
                        count++;

                        // skip the first row
                        if (count > 1)
                        {
                            // get the list of words
                            words = WordParser.GetWords(textLine.Text, delimiters, true);

                            // if the words collection has exactly the right amount
                            if ((ListHelper.HasOneOrMoreItems(words)) && (words.Count == expectedCount))
                            {
                                // Create a new instance of a 'RawImport' object.
                                rawImport = new RawImport();

                                // Load the RawImport with the words
                                SetRawImportProperties(ref rawImport, words);

                                // save the rawImport object
                                bool saved = gateway.SaveRawImport(ref rawImport);

                                // if the value for saved is true
                                if (saved)
                                {
                                    // Increment the value for savedCount
                                    savedCount++;

                                    // refresh every x number of records
                                    if (savedCount % refreshRate == 0)
                                    {
                                        // update the graph (for a large project, you might want to update every 25, 50 or 100 records or so
                                        callback(savedCount, tableName);
                                    }
                                }
                            }
                        }
                    }
                }
            }

            // return value
            return(savedCount);
        }
        /// <summary>
        /// This method returns the Connection String Line
        /// </summary>
        public TextLine GetConnectionStringLine()
        {
            // initial value
            TextLine connectionStringLine = null;

            // Set the ConnectionStringIndex
            ConnectionStringIndex = -1;

            // local
            int index = -1;

            // set the appConfig file location relative to bin\debug
            string appConfig = "../../App.config";

            // if the file exists
            if (File.Exists(appConfig))
            {
                // get the full path
                string fullPath = Path.GetFullPath(appConfig);

                // Set the AppConfigPath
                AppConfigPath = fullPath;

                // read the text of the AppConfig
                string appConfigText = File.ReadAllText(fullPath);

                // If the appConfigText string exists
                if (TextHelper.Exists(appConfigText))
                {
                    // get the textLines
                    List <TextLine> textLines = WordParser.GetTextLines(appConfigText);

                    // If the textLines collection exists and has one or more items
                    if (ListHelper.HasOneOrMoreItems(textLines))
                    {
                        // store the textLines so they can be updated in the next step
                        AppConfigTextLines = textLines;

                        // Iterate the collection of TextLine objects
                        foreach (TextLine textLine in textLines)
                        {
                            // Increment the value for tempIndex
                            index++;

                            // if this is not a comment line
                            if (!textLine.Text.Trim().StartsWith(HTMLCommentStart))
                            {
                                // if this is the ConnectionStringLine
                                if (textLine.Text.Trim().StartsWith(ConnectionStringStart))
                                {
                                    // get the textLine
                                    connectionStringLine = textLine;

                                    // Set the ConnectionStringIndex
                                    ConnectionStringIndex = index;

                                    // break out of this loop
                                    break;
                                }
                                else if (textLine.Text.Trim().StartsWith(SetupCompleteStart))
                                {
                                    // Set the SetupCompleteIndex
                                    SetupCompleteIndex = index;
                                }
                            }
                        }
                    }
                }
            }

            // return value
            return(connectionStringLine);
        }
Beispiel #4
0
        private void FindFinished(FRResults results)
        {
            UserInterfaceManager.ProgressDialog.Show();
            UserInterfaceManager.ProgressDialog.SetTitle(TextHelper.GetString("Info.UpdatingReferences"));
            MessageBar.Locked = true;
            var    currentTarget = targets[currentTargetIndex];
            string targetName    = Path.GetFileNameWithoutExtension(currentTarget.OldFilePath);
            string oldType       = (currentTarget.OldFileModel.Package + "." + targetName).Trim('.');
            string newType       = (currentTarget.NewPackage + "." + targetName).Trim('.');

            foreach (KeyValuePair <string, List <SearchMatch> > entry in results)
            {
                List <SearchMatch> matches = entry.Value;
                if (matches.Count == 0 || entry.Key == currentTarget.OldFilePath ||
                    entry.Key == currentTarget.NewFilePath)
                {
                    continue;
                }
                string file = entry.Key;
                UserInterfaceManager.ProgressDialog.UpdateStatusMessage(TextHelper.GetString("Info.Updating") + " \"" + file + "\"");
                ScintillaControl sci;
                var actualMatches = new List <SearchMatch>();
                foreach (SearchMatch match in entry.Value)
                {
                    // we have to open/reopen the entry's file
                    // there are issues with evaluating the declaration targets with non-open, non-current files
                    // we have to do it each time as the process of checking the declaration source can change the currently open file!
                    sci = AssociatedDocumentHelper.LoadDocument(file);
                    // if the search result does point to the member source, store it
                    if (RefactoringHelper.DoesMatchPointToTarget(sci, match, currentTargetResult, this.AssociatedDocumentHelper))
                    {
                        actualMatches.Add(match);
                    }
                }
                if (actualMatches.Count == 0)
                {
                    continue;
                }
                int currLine = -1;
                sci = AssociatedDocumentHelper.LoadDocument(file);
                for (int i = actualMatches.Count - 1; i >= 0; i--)
                {
                    var sm = actualMatches[i];
                    if (sm.LineText.Contains(oldType))
                    {
                        sm.Index -= sci.MBSafeTextLength(oldType) - sci.MBSafeTextLength(targetName);
                        sm.Value  = oldType;
                        RefactoringHelper.SelectMatch(sci, sm);
                        sm.Column = sm.Index - sm.LineStart;
                        sci.ReplaceSel(newType);
                        sm.LineEnd  = sci.SelectionEnd;
                        sm.LineText = sci.GetLine(sm.Line - 1);
                        sm.Value    = newType;
                    }
                    else
                    {
                        if (currLine == -1)
                        {
                            currLine = sm.Line - 1;
                        }
                        actualMatches.RemoveAt(i);
                    }
                }
                string directory = Path.GetDirectoryName(file);
                // Let's check if we need to add the import. Check the considerations at the start of the file
                // directory != currentTarget.OwnerPath -> renamed owner directory, so both files in the same place
                if (directory != Path.GetDirectoryName(currentTarget.NewFilePath) && directory != currentTarget.OwnerPath &&
                    ASContext.Context.CurrentModel.Imports.Search(targetName, FlagType.Class & FlagType.Function & FlagType.Namespace, 0) == null)
                {
                    sci.GotoLine(currLine);
                    ASGenerator.InsertImport(new MemberModel(targetName, newType, FlagType.Import, 0), false);
                    int newLine = sci.LineFromPosition(sci.Text.IndexOf(newType));
                    var sm      = new SearchMatch();
                    sm.Line     = newLine + 1;
                    sm.LineText = sci.GetLine(newLine);
                    sm.Column   = 0;
                    sm.Length   = sci.MBSafeTextLength(sm.LineText);
                    sm.Value    = sm.LineText;

                    actualMatches.Insert(0, sm);
                }
                if (actualMatches.Count == 0)
                {
                    continue;
                }
                if (!Results.ContainsKey(file))
                {
                    Results[file] = new List <SearchMatch>();
                }
                Results[file].AddRange(actualMatches);
                //Do we want to open modified files?
                //if (sci.IsModify) AssociatedDocumentHelper.MarkDocumentToKeep(file);
                PluginBase.MainForm.CurrentDocument.Save();
            }

            currentTargetIndex++;

            UserInterfaceManager.ProgressDialog.Hide();
            MessageBar.Locked = false;
            UpdateReferencesNextTarget();
        }
Beispiel #5
0
    /// <summary>
    /// Processes the content.
    /// </summary>
    /// <param name="sb">StringBuilder to write</param>
    /// <param name="source">Source object</param>
    /// <param name="column">Column</param>
    /// <param name="content">Content</param>
    protected void ProcessContent(StringBuilder sb, object source, string column, ref string content)
    {
        bool standard = true;

        switch (column.ToLowerCSafe())
        {
        // Document content
        case "documentcontent":
            EditableItems items = new EditableItems();
            items.LoadContentXml(content);

            // Add regions
            foreach (DictionaryEntry region in items.EditableRegions)
            {
                sb.Append("<span class=\"VersionEditableRegionTitle\">" + (string)region.Key + "</span>");

                string regionContent = HTMLHelper.ResolveUrls((string)region.Value, SystemContext.ApplicationPath);

                sb.Append("<span class=\"VersionEditableRegionText\">" + regionContent + "</span>");
            }

            // Add web parts
            foreach (DictionaryEntry part in items.EditableWebParts)
            {
                sb.Append("<span class=\"VersionEditableWebPartTitle\">" + (string)part.Key + "</span>");

                string regionContent = HTMLHelper.ResolveUrls((string)part.Value, SystemContext.ApplicationPath);
                sb.Append("<span class=\"VersionEditableWebPartText\">" + regionContent + "</span>");
            }

            standard = false;
            break;

        // XML columns
        case "pagetemplatewebparts":
        case "webpartproperties":
        case "reportparameters":
        case "classformdefinition":
        case "classxmlschema":
        case "classformlayout":
        case "userdialogsconfiguration":
            content = HTMLHelper.ReformatHTML(content);
            break;

        // File columns
        case "metafilename":
        {
            Guid metaFileGuid = ValidationHelper.GetGuid(GetValueFromSource(source, "MetaFileGuid"), Guid.Empty);
            if (metaFileGuid != Guid.Empty)
            {
                string metaFileName = ValidationHelper.GetString(GetValueFromSource(source, "MetaFileName"), "");

                content = "<a href=\"" + ResolveUrl(MetaFileInfoProvider.GetMetaFileUrl(metaFileGuid, metaFileName)) + "\" target=\"_blank\" >" + HTMLHelper.HTMLEncode(metaFileName) + "</a>";
                sb.Append(content);

                standard = false;
            }
        }
        break;
        }

        // Standard rendering
        if (standard)
        {
            if (content.Length > 500)
            {
                content = TextHelper.EnsureMaximumLineLength(content, 50, "&#x200B;", true);
            }
            else
            {
                content = HTMLHelper.HTMLEncode(content);
            }

            content = HTMLHelper.EnsureHtmlLineEndings(content);
            content = content.Replace("\t", "&nbsp;&nbsp;&nbsp;&nbsp;");
            sb.Append("<div style=\"max-height: 300px; overflow: auto;\">" + content + "</div>");
        }
    }
        /// <summary>
        /// Gets a label as plain text by removing the accelerator key
        /// </summary>
        public static String GetLabelAsPlainText(String name, Boolean hasBOM)
        {
            String label = TextHelper.GetString(name).Replace("&", "");

            return(hasBOM ? label + " (BOM)" : label);
        }
        public bool FDBuild(Project project, bool runOutput, bool releaseMode, InstalledSDK sdk)
        {
            string directory = Environment.CurrentDirectory;

            Environment.CurrentDirectory = project.Directory;

            string fdBuildDir  = Path.Combine(PathHelper.ToolDir, "fdbuild");
            string fdBuildPath = Path.Combine(fdBuildDir, "fdbuild.exe");

            string arguments = " -ipc " + ipcName;

            if (sdk != null)
            {
                if (!string.IsNullOrEmpty(sdk.Version))
                {
                    arguments += " -version \"" + sdk.Version.Replace(',', ';') + "\"";
                }
                if (!string.IsNullOrEmpty(project.CurrentSDK))
                {
                    arguments += " -compiler \"" + project.CurrentSDK + "\"";
                }
            }

            if (releaseMode)
            {
                arguments += " -notrace";
            }
            arguments += " -library \"" + PathHelper.LibraryDir + "\"";

            foreach (string cp in PluginMain.Settings.GlobalClasspaths)
            {
                arguments += " -cp \"" + Environment.ExpandEnvironmentVariables(cp) + "\"";
            }

            if (project.TargetBuild != null)
            {
                arguments += " -target \"" + project.TargetBuild + "\"";
            }

            arguments = arguments.Replace("\\\"", "\""); // c# console args[] bugfix

            SetStatusBar(TextHelper.GetString("Info.BuildStarted"));
            pluginMain.UpdateUIStatus(ProjectManagerUIStatus.Building);

            // Apache Flex compat
            if (project.Language == "as3")
            {
                string playerglobalHome = Environment.ExpandEnvironmentVariables("%PLAYERGLOBAL_HOME%");
                if (playerglobalHome.StartsWith("%"))
                {
                    setPlayerglobalHomeEnv = true;
                }
                if (setPlayerglobalHomeEnv)
                {
                    Environment.SetEnvironmentVariable("PLAYERGLOBAL_HOME", Path.Combine(project.CurrentSDK, "frameworks/libs/player"));
                }
            }

            // Lets expose current sdk
            Environment.SetEnvironmentVariable("FD_CUR_SDK", project.CurrentSDK ?? "");

            // run FDBuild
            fdProcess.StartProcess(fdBuildPath, "\"" + project.ProjectPath + "\"" + arguments,
                                   project.Directory, delegate(bool success)
            {
                pluginMain.UpdateUIStatus(ProjectManagerUIStatus.NotBuilding);
                if (success)
                {
                    SetStatusBar(TextHelper.GetString("Info.BuildSucceeded"));
                    AddTrustFile(project);
                    OnBuildComplete(project, runOutput);
                }
                else
                {
                    SetStatusBar(TextHelper.GetString("Info.BuildFailed"));
                    OnBuildFailed(project, runOutput);
                }
                Environment.CurrentDirectory = directory;
            });
            return(true);
        }
Beispiel #8
0
 public async Task DeleteForm(string ids)
 {
     long[] idArr = TextHelper.SplitToArray <long>(ids, ',');
     await this.BaseRepository().Delete <LogApiEntity>(idArr);
 }
Beispiel #9
0
 public void ShowNextText(string name, string content, float speed)
 {
     viewController.UpdateNameText(name);
     textHelper.SetNextLine(TextHelper.ReplaceTextTags(content), speed);
 }
    /// <summary>
    /// Creates group forum.
    /// </summary>
    /// <param name="group">Particular group info object</param>
    private void CreateGroupForum(GroupInfo group)
    {
        #region "Create forum group"

        // Get forum group code name
        string forumGroupCodeName = "Forums_group_" + group.GroupGUID;

        // Check if forum group with given name already exists
        if (ForumGroupInfoProvider.GetForumGroupInfo(forumGroupCodeName, CMSContext.CurrentSiteID) != null)
        {
            return;
        }

        // Create forum base URL
        string   baseUrl       = null;
        TreeNode groupDocument = TreeProvider.SelectSingleNode(group.GroupNodeGUID, CMSContext.CurrentDocumentCulture.CultureCode, CMSContext.CurrentSiteName);
        if (groupDocument != null)
        {
            baseUrl = CMSContext.GetUrl(groupDocument.NodeAliasPath + "/" + FORUM_DOCUMENT_ALIAS);
        }

        ForumGroupInfo forumGroupObj = new ForumGroupInfo();
        string         suffix        = " forums";
        forumGroupObj.GroupDisplayName = TextHelper.LimitLength(group.GroupDisplayName, 200 - suffix.Length, "") + suffix;
        forumGroupObj.GroupName        = forumGroupCodeName;
        forumGroupObj.GroupOrder       = 0;
        forumGroupObj.GroupEnableQuote = true;
        forumGroupObj.GroupGroupID     = group.GroupID;
        forumGroupObj.GroupSiteID      = CMSContext.CurrentSiteID;
        forumGroupObj.GroupBaseUrl     = baseUrl;

        // Additional settings
        forumGroupObj.GroupEnableCodeSnippet   = true;
        forumGroupObj.GroupEnableFontBold      = true;
        forumGroupObj.GroupEnableFontColor     = true;
        forumGroupObj.GroupEnableFontItalics   = true;
        forumGroupObj.GroupEnableFontStrike    = true;
        forumGroupObj.GroupEnableFontUnderline = true;
        forumGroupObj.GroupEnableQuote         = true;
        forumGroupObj.GroupEnableURL           = true;
        forumGroupObj.GroupEnableImage         = true;

        // Set forum group info
        ForumGroupInfoProvider.SetForumGroupInfo(forumGroupObj);

        #endregion

        #region "Create forum"

        string codeName = "General_discussion_group_" + group.GroupGUID;

        // Check if forum with given name already exists
        if (ForumInfoProvider.GetForumInfo(codeName, CMSContext.CurrentSiteID, group.GroupID) != null)
        {
            return;
        }

        // Create new forum object
        ForumInfo forumObj = new ForumInfo();
        forumObj.ForumSiteID          = CMSContext.CurrentSiteID;
        forumObj.ForumIsLocked        = false;
        forumObj.ForumOpen            = true;
        forumObj.ForumDisplayEmails   = false;
        forumObj.ForumRequireEmail    = false;
        forumObj.ForumDisplayName     = "General discussion";
        forumObj.ForumName            = codeName;
        forumObj.ForumGroupID         = forumGroupObj.GroupID;
        forumObj.ForumModerated       = false;
        forumObj.ForumAccess          = 40000;
        forumObj.ForumPosts           = 0;
        forumObj.ForumThreads         = 0;
        forumObj.ForumPostsAbsolute   = 0;
        forumObj.ForumThreadsAbsolute = 0;
        forumObj.ForumOrder           = 0;
        forumObj.ForumUseCAPTCHA      = false;
        forumObj.SetValue("ForumHTMLEditor", null);

        // Set security
        forumObj.AllowAccess       = SecurityAccessEnum.GroupMembers;
        forumObj.AllowAttachFiles  = SecurityAccessEnum.GroupMembers;
        forumObj.AllowMarkAsAnswer = SecurityAccessEnum.GroupMembers;
        forumObj.AllowPost         = SecurityAccessEnum.GroupMembers;
        forumObj.AllowReply        = SecurityAccessEnum.GroupMembers;
        forumObj.AllowSubscribe    = SecurityAccessEnum.GroupMembers;

        if (ForumInfoProvider.LicenseVersionCheck(URLHelper.GetCurrentDomain(), FeatureEnum.Forums, VersionActionEnum.Insert))
        {
            ForumInfoProvider.SetForumInfo(forumObj);
        }

        #endregion
    }
Beispiel #11
0
        public ProjectMenu()
        {
            AllItems = new List <ToolStripItem>();

            NewProject       = new ToolStripMenuItem(TextHelper.GetString("Label.NewProject"));
            NewProject.Image = Icons.NewProject.Img;
            PluginBase.MainForm.RegisterShortcutItem("ProjectMenu.NewProject", NewProject);
            //AllItems.Add(NewProject);

            OpenProject = new ToolStripMenuItem(TextHelper.GetString("Label.OpenProject"));
            PluginBase.MainForm.RegisterShortcutItem("ProjectMenu.OpenProject", OpenProject);
            //AllItems.Add(OpenProject);

            ImportProject = new ToolStripMenuItem(TextHelper.GetString("Label.ImportProject"));
            PluginBase.MainForm.RegisterShortcutItem("ProjectMenu.ImportProject", ImportProject);
            //AllItems.Add(ImportProject);

            CloseProject = new ToolStripMenuItem(TextHelper.GetString("Label.CloseProject"));
            PluginBase.MainForm.RegisterShortcutItem("ProjectMenu.CloseProject", CloseProject);
            AllItems.Add(CloseProject);

            OpenResource              = new ToolStripMenuItem(TextHelper.GetString("Label.OpenResource"));
            OpenResource.Image        = PluginBase.MainForm.FindImage("209");
            OpenResource.ShortcutKeys = Keys.Control | Keys.R;
            PluginBase.MainForm.RegisterShortcutItem("ProjectMenu.OpenResource", OpenResource);
            AllItems.Add(OpenResource);

            TestMovie              = new ToolStripMenuItem(TextHelper.GetString("Label.TestMovie"));
            TestMovie.Image        = Icons.GreenCheck.Img;
            TestMovie.ShortcutKeys = Keys.F5;
            PluginBase.MainForm.RegisterShortcutItem("ProjectMenu.TestMovie", TestMovie);
            AllItems.Add(TestMovie);

            RunProject = new ToolStripMenuItem(TextHelper.GetString("Label.RunProject"));
            PluginBase.MainForm.RegisterShortcutItem("ProjectMenu.RunProject", RunProject);
            AllItems.Add(RunProject);

            BuildProject              = new ToolStripMenuItem(TextHelper.GetString("Label.BuildProject"));
            BuildProject.Image        = Icons.Gear.Img;
            BuildProject.ShortcutKeys = Keys.F8;
            PluginBase.MainForm.RegisterShortcutItem("ProjectMenu.BuildProject", BuildProject);
            AllItems.Add(BuildProject);

            CleanProject = new ToolStripMenuItem(TextHelper.GetString("Label.CleanProject"));
            CleanProject.ShortcutKeys = Keys.Shift | Keys.F8;
            PluginBase.MainForm.RegisterShortcutItem("ProjectMenu.CleanProject", CleanProject);
            AllItems.Add(CleanProject);

            Properties       = new ToolStripMenuItem(TextHelper.GetString("Label.Properties"));
            Properties.Image = Icons.Options.Img;
            PluginBase.MainForm.RegisterShortcutItem("ProjectMenu.Properties", Properties);
            AllItems.Add(Properties);

            base.Text = TextHelper.GetString("Label.Project");
            base.DropDownItems.Add(NewProject);
            base.DropDownItems.Add(OpenProject);
            base.DropDownItems.Add(ImportProject);
            base.DropDownItems.Add(CloseProject);
            base.DropDownItems.Add(new ToolStripSeparator());
            base.DropDownItems.Add(OpenResource);
            base.DropDownItems.Add(new ToolStripSeparator());
            base.DropDownItems.Add(TestMovie);
            base.DropDownItems.Add(RunProject);
            base.DropDownItems.Add(BuildProject);
            base.DropDownItems.Add(CleanProject);
            base.DropDownItems.Add(new ToolStripSeparator());
            base.DropDownItems.Add(Properties);
        }
Beispiel #12
0
        public FDMenus(IMainForm mainForm)
        {
            // modify the file menu
            ToolStripMenuItem fileMenu = (ToolStripMenuItem)mainForm.FindMenuItem("FileMenu");

            RecentProjects = new RecentProjectsMenu();
            fileMenu.DropDownItems.Insert(5, RecentProjects);

            // modify the view menu
            ToolStripMenuItem viewMenu = (ToolStripMenuItem)mainForm.FindMenuItem("ViewMenu");

            View       = new ToolStripMenuItem(TextHelper.GetString("Label.MainMenuItem"));
            View.Image = Icons.Project.Img;
            viewMenu.DropDownItems.Add(View);
            PluginBase.MainForm.RegisterShortcutItem("ViewMenu.ShowProject", View);

            // modify the tools menu - add a nice GUI classpath editor
            ToolStripMenuItem toolsMenu = (ToolStripMenuItem)mainForm.FindMenuItem("ToolsMenu");

            GlobalClasspaths = new ToolStripMenuItem(TextHelper.GetString("Label.GlobalClasspaths"));
            GlobalClasspaths.ShortcutKeys = Keys.F9 | Keys.Control;
            GlobalClasspaths.Image        = Icons.Classpath.Img;
            toolsMenu.DropDownItems.Insert(toolsMenu.DropDownItems.Count - 4, GlobalClasspaths);
            PluginBase.MainForm.RegisterShortcutItem("ToolsMenu.GlobalClasspaths", GlobalClasspaths);

            ProjectMenu = new ProjectMenu();

            MenuStrip mainMenu = mainForm.MenuStrip;

            mainMenu.Items.Insert(5, ProjectMenu);

            ToolStrip toolBar = mainForm.ToolStrip;

            toolBar.Items.Add(new ToolStripSeparator());

            toolBar.Items.Add(RecentProjects.ToolbarSelector);

            BuildProject             = new ToolStripButton(Icons.Gear.Img);
            BuildProject.Name        = "BuildProject";
            BuildProject.ToolTipText = TextHelper.GetStringWithoutMnemonics("Label.BuildProject");
            PluginBase.MainForm.RegisterSecondaryItem("ProjectMenu.BuildProject", BuildProject);
            toolBar.Items.Add(BuildProject);

            TestMovie             = new ToolStripButton(Icons.GreenCheck.Img);
            TestMovie.Name        = "TestMovie";
            TestMovie.ToolTipText = TextHelper.GetStringWithoutMnemonics("Label.TestMovie");
            PluginBase.MainForm.RegisterSecondaryItem("ProjectMenu.TestMovie", TestMovie);
            toolBar.Items.Add(TestMovie);

            ConfigurationSelector             = new ToolStripComboBoxEx();
            ConfigurationSelector.Name        = "ConfigurationSelector";
            ConfigurationSelector.ToolTipText = TextHelper.GetString("ToolTip.SelectConfiguration");
            ConfigurationSelector.Items.AddRange(new string[] { TextHelper.GetString("Info.Debug"), TextHelper.GetString("Info.Release") });
            ConfigurationSelector.DropDownStyle = ComboBoxStyle.DropDownList;
            ConfigurationSelector.AutoSize      = false;
            ConfigurationSelector.Enabled       = false;
            ConfigurationSelector.Width         = ScaleHelper.Scale(GetThemeWidth("ProjectManager.TargetBuildSelectorWidth", 85));
            ConfigurationSelector.Margin        = new Padding(1, 0, 0, 0);
            ConfigurationSelector.FlatStyle     = PluginBase.MainForm.Settings.ComboBoxFlatStyle;
            ConfigurationSelector.Font          = PluginBase.Settings.DefaultFont;
            toolBar.Items.Add(ConfigurationSelector);
            PluginBase.MainForm.RegisterShortcutItem("ProjectMenu.ConfigurationSelectorToggle", Keys.Control | Keys.F5);
            PluginBase.MainForm.RegisterSecondaryItem("ProjectMenu.ConfigurationSelectorToggle", ConfigurationSelector);

            TargetBuildSelector             = new ToolStripComboBoxEx();
            TargetBuildSelector.Name        = "TargetBuildSelector";
            TargetBuildSelector.ToolTipText = TextHelper.GetString("ToolTip.TargetBuild");
            TargetBuildSelector.AutoSize    = false;
            TargetBuildSelector.Width       = ScaleHelper.Scale(GetThemeWidth("ProjectManager.ConfigurationSelectorWidth", 120));
            TargetBuildSelector.Margin      = new Padding(1, 0, 0, 0);
            TargetBuildSelector.FlatStyle   = PluginBase.MainForm.Settings.ComboBoxFlatStyle;
            TargetBuildSelector.Font        = PluginBase.Settings.DefaultFont;
            toolBar.Items.Add(TargetBuildSelector);
            PluginBase.MainForm.RegisterShortcutItem("ProjectMenu.TargetBuildSelector", Keys.Control | Keys.F7);
            PluginBase.MainForm.RegisterSecondaryItem("ProjectMenu.TargetBuildSelector", TargetBuildSelector);
            EnableTargetBuildSelector(false);
        }
Beispiel #13
0
        /// <summary>
        /// Renames the given the set of matched references
        /// </summary>
        private void OnFindAllReferencesCompleted(object sender, RefactorCompleteEventArgs <IDictionary <string, List <SearchMatch> > > eventArgs)
        {
            UserInterfaceManager.ProgressDialog.Show();
            UserInterfaceManager.ProgressDialog.SetTitle(TextHelper.GetString("Info.UpdatingReferences"));
            MessageBar.Locked = true;
            var isParameterVar = (Target.Member?.Flags & FlagType.ParameterVar) > 0;

            foreach (var entry in eventArgs.Results)
            {
                UserInterfaceManager.ProgressDialog.UpdateStatusMessage(TextHelper.GetString("Info.Updating") + " \"" + entry.Key + "\"");
                // re-open the document and replace all the text
                var doc           = AssociatedDocumentHelper.LoadDocument(entry.Key);
                var sci           = doc.SciControl;
                var targetMatches = entry.Value;
                if (isParameterVar)
                {
                    var lineFrom = Target.Context.ContextFunction.LineFrom;
                    var lineTo   = Target.Context.ContextFunction.LineTo;
                    var search   = new FRSearch(NewName)
                    {
                        WholeWord = true, NoCase = false, SingleLine = true
                    };
                    var matches = search.Matches(sci.Text, sci.PositionFromLine(lineFrom), lineFrom);
                    matches.RemoveAll(it => it.Line <lineFrom || it.Line> lineTo);
                    if (matches.Count != 0)
                    {
                        sci.BeginUndoAction();
                        try
                        {
                            for (var i = 0; i < matches.Count; i++)
                            {
                                var match = matches[i];
                                var expr  = ASComplete.GetExpressionType(sci, sci.MBSafePosition(match.Index) + sci.MBSafeTextLength(match.Value));
                                if (expr.IsNull())
                                {
                                    continue;
                                }
                                var replacement = string.Empty;
                                var flags       = expr.Member.Flags;
                                if ((flags & FlagType.Static) > 0)
                                {
                                    var classNameWithDot = ASContext.Context.CurrentClass.Name + ".";
                                    if (!expr.Context.Value.StartsWith(classNameWithDot))
                                    {
                                        replacement = classNameWithDot + NewName;
                                    }
                                }
                                else if ((flags & FlagType.LocalVar) == 0)
                                {
                                    var decl = expr.Context.Value;
                                    if (!decl.StartsWith("this.") && !decl.StartsWith("super."))
                                    {
                                        replacement = "this." + NewName;
                                    }
                                }
                                if (string.IsNullOrEmpty(replacement))
                                {
                                    continue;
                                }
                                RefactoringHelper.SelectMatch(sci, match);
                                sci.EnsureVisible(sci.LineFromPosition(sci.MBSafePosition(match.Index)));
                                sci.ReplaceSel(replacement);
                                for (var j = 0; j < targetMatches.Count; j++)
                                {
                                    var targetMatch = targetMatches[j];
                                    if (targetMatch.Line <= match.Line)
                                    {
                                        continue;
                                    }
                                    FRSearch.PadIndexes(targetMatches, j, match.Value, replacement);
                                    if (targetMatch.Line == match.Line + 1)
                                    {
                                        targetMatch.LineText = sci.GetLine(match.Line);
                                        targetMatch.Column  += replacement.Length - match.Value.Length;
                                    }
                                    break;
                                }
                                FRSearch.PadIndexes(matches, i + 1, match.Value, replacement);
                            }
                        }
                        finally
                        {
                            sci.EndUndoAction();
                        }
                    }
                }
                // replace matches in the current file with the new name
                RefactoringHelper.ReplaceMatches(targetMatches, sci, NewName);
                //Uncomment if we want to keep modified files
                //if (sci.IsModify) AssociatedDocumentHelper.MarkDocumentToKeep(entry.Key);
                doc.Save();
            }
            if (newFileName != null)
            {
                RenameFile(eventArgs.Results);
            }
            Results = eventArgs.Results;
            AssociatedDocumentHelper.CloseTemporarilyOpenedDocuments();
            if (OutputResults)
            {
                ReportResults();
            }
            UserInterfaceManager.ProgressDialog.Hide();
            MessageBar.Locked = false;
            FireOnRefactorComplete();
        }
Beispiel #14
0
#pragma warning restore 0649

    public void setControlScheme(MicrogameTraits.ControlScheme controlScheme)
    {
        //TODO re-enable command warnings?
        controlRenderer.sprite = GameController.instance.getControlSprite(controlScheme);
        controlText.text       = TextHelper.getLocalizedTextNoWarnings("control." + controlScheme.ToString().ToLower(), getDefaultControlString(controlScheme));
    }
Beispiel #15
0
 private void autoButton_Click(object sender, EventArgs e)
 {
     autoStart        = !autoStart;
     autoButton.Image = PluginBase.MainForm.FindImage(autoStart ? "510" : "514");
     autoButton.Text  = TextHelper.GetString(autoStart ? "Label.AutoStartProfilerON" : "Label.AutoStartProfilerOFF");
 }
    /// <summary>
    /// Overrides OnPreRender method.
    /// </summary>
    protected override void OnPreRender(EventArgs e)
    {
        base.OnPreRender(e);

        // Apply filter
        if (!DataHelper.DataSourceIsEmpty(mGeneratedVariants))
        {
            string query = string.Empty;
            foreach (int categoryId in VariantFilter.SelectedOptionIDs.Keys.ToList())
            {
                // Build query from selected options Ids
                if (mGeneratedVariants.Tables[0].Columns[categoryId.ToString()] != null)
                {
                    // Build query where column named categoryId satisfies conditions
                    query = SqlHelper.AddWhereCondition(query, ("[" + categoryId + "] IN (" + TextHelper.Join(",", VariantFilter.SelectedOptionIDs[categoryId]) + ")"));
                    query = SqlHelper.AddWhereCondition(query, ("[" + categoryId + "] IS NULL"), "OR");
                }
            }

            if (query != string.Empty)
            {
                // Apply query, save result, clear dataTable and put result to daTable
                DataTable dataTable = mGeneratedVariants.Tables[0].Clone();
                mGeneratedVariants.Tables[0].Select(query, "RowNumber").CopyToDataTable(dataTable, LoadOption.OverwriteChanges);
                mGeneratedVariants.Tables.Remove("VariantsDT");
                mGeneratedVariants.Tables.Add(dataTable);
            }
            else
            {
                // No ids selected, clear grid
                mGeneratedVariants.Tables.Remove("VariantsDT");
            }

            SetupVariants(false);
        }

        ManipulateFilter();

        VariantGrid.Visible = (VariantGrid.RowsCount <= 500);
        lblSpecify.Visible  = !VariantGrid.Visible;
    }
Beispiel #17
0
    /// <summary>
    /// Prepares the layout of the web part.
    /// </summary>
    protected override void PrepareLayout()
    {
        StartLayout();

        Append("<div");

        // Width
        string width = Width;

        if (!string.IsNullOrEmpty(width))
        {
            Append(" style=\"width: ", width, "\"");
        }

        if (IsDesign)
        {
            Append(" id=\"", ShortClientID, "_env\">");

            Append("<table class=\"LayoutTable\" cellspacing=\"0\" style=\"width: 100%;\">");

            if (ViewModeIsDesign())
            {
                Append("<tr><td class=\"LayoutHeader\" colspan=\"2\">");

                // Add header container
                AddHeaderContainer();

                Append("</td></tr>");
            }

            Append("<tr><td id=\"", ShortClientID, "_info\" style=\"width: 100%;\">");
        }
        else
        {
            Append(">");
        }

        // Add the tabs
        var acc = new CMSAccordion();

        acc.ID = "acc";
        AddControl(acc);

        if (IsDesign)
        {
            Append("</td>");

            if (AllowDesignMode)
            {
                // Width resizer
                Append("<td class=\"HorizontalResizer\" onmousedown=\"" + GetHorizontalResizerScript("env", "Width", false, "info") + " return false;\">&nbsp;</td>");
            }

            Append("</tr>");
        }

        // Pane headers
        string[] headers = TextHelper.EnsureLineEndings(PaneHeaders, "\n").Split('\n');

        for (int i = 1; i <= Panes; i++)
        {
            // Create new pane
            var pane = new CMSAccordionPane();
            pane.ID = "pane" + i;

            // Prepare the header
            string header = null;
            if (headers.Length >= i)
            {
                header = ResHelper.LocalizeString(headers[i - 1]);
                header = HTMLHelper.HTMLEncode(header);
            }
            if (String.IsNullOrEmpty(header))
            {
                header = "Pane " + i;
            }

            pane.Header = new TextTransformationTemplate(header);
            acc.Panes.Add(pane);

            pane.WebPartZone = AddZone(ID + "_" + i, header, pane.ContentContainer);
        }

        // Setup the accordion
        if ((ActivePaneIndex >= 1) && (ActivePaneIndex <= acc.Panes.Count))
        {
            acc.SelectedIndex = ActivePaneIndex - 1;
        }

        acc.ContentCssClass        = ContentCSSClass;
        acc.HeaderCssClass         = HeaderCSSClass;
        acc.HeaderSelectedCssClass = SelectedHeaderCSSClass;

        acc.FadeTransitions    = FadeTransitions;
        acc.TransitionDuration = TransitionDuration;
        acc.RequireOpenedPane  = RequireOpenedPane;

        // If no active pane is selected and doesn't require opened one, do not preselect any
        if (!acc.RequireOpenedPane && (ActivePaneIndex < 0))
        {
            acc.SelectedIndex = -1;
        }

        if (IsDesign)
        {
            if (AllowDesignMode)
            {
                Append("<tr><td class=\"LayoutFooter cms-bootstrap\" colspan=\"2\"><div class=\"LayoutFooterContent\">");

                // Pane actions
                Append("<div class=\"LayoutLeftActions\">");

                AppendAddAction(ResHelper.GetString("Layout.AddPane"), "Panes");
                if (Panes > 1)
                {
                    AppendRemoveAction(ResHelper.GetString("Layout.RemoveLastPane"), "Panes");
                }

                Append("</div></div></td></tr>");
            }

            Append("</table>");
        }

        Append("</div>");

        FinishLayout();
    }
Beispiel #18
0
        /// <summary>
        /// Markdown blocks processing
        /// </summary>
        /// <param name="b"></param>
        /// <param name="recursionLevel"></param>
        protected List <string> BlockProcessing(MarkdownBlock b, int recursionLevel)
        {
            string        forecolor = string.Empty;
            string        backcolor = string.Empty;
            string        underline = string.Empty;
            int           maxWidth  = client.screenWidth - recursionLevel * 2;
            List <string> Text      = new List <string>();

            switch (b.Type)
            {
            case MarkdownBlockType.Root:
                break;

            case MarkdownBlockType.Paragraph:
                string para = "";
                foreach (var i in ((ParagraphBlock)b).Inlines)
                {
                    para += ProcessInline(i);
                }
                Text.AddRange(TextHelper.WordWrap(para, maxWidth));
                Text.Add(string.Empty);
                break;

            case MarkdownBlockType.Quote:
                break;

            case MarkdownBlockType.Code:
                forecolor = ANSI.GetStyleForeColor("Code_Color", mdStyles);
                backcolor = ANSI.GetStyleBackColor("Code_Back", mdStyles);
                List <string> rows = TextHelper.SplitString(((CodeBlock)b).Text);
                foreach (string s in rows)
                {
                    Text.Add(backcolor + forecolor + ANSI.ClearCurrentLine + s + ANSI.WriteMode());
                }
                Text.Add(ANSI.WriteMode());
                break;

            case MarkdownBlockType.Header:
                HeaderBlock hb = (HeaderBlock)b;
                Text.AddRange(ANSI.Header(hb.ToString(), hb.HeaderLevel, maxWidth));
                break;

            case MarkdownBlockType.List:
                ListBlock lb     = (ListBlock)b;
                string    indent = new string(' ', recursionLevel * 2);
                foreach (var li in lb.Items)
                {
                    List <string> lir     = new List <string>();
                    bool          isFirst = true;
                    foreach (var lib in li.Blocks)
                    {
                        lir.AddRange(BlockProcessing(lib, recursionLevel + 1));
                    }
                    foreach (string s in lir)
                    {
                        Text.Add((isFirst ? "- " : "  ") + s);
                        isFirst = false;
                    }
                }
                break;

            case MarkdownBlockType.ListItemBuilder:
                break;

            case MarkdownBlockType.HorizontalRule:
                Text.Add(TextHelper.HR('-', maxWidth));
                break;

            case MarkdownBlockType.Table:
                TableBlock tb       = (TableBlock)b;
                int        colWidth = maxWidth / tb.ColumnDefinitions.Count;
                foreach (var tr in tb.Rows)
                {
                    string trs = string.Empty;
                    foreach (var tc in tr.Cells)
                    {
                        string tcs = string.Empty;
                        foreach (var i in tc.Inlines)
                        {
                            tcs += ProcessInline(i);
                        }
                        trs += TextHelper.Truncate(tcs, colWidth - 1).PadRight(colWidth);
                    }
                    Text.Add(trs);
                }
                break;

            case MarkdownBlockType.LinkReference:
                break;

            case MarkdownBlockType.YamlHeader:
                break;

            default:
                break;
            }
            return(Text);
        }
    /// <summary>
    /// Page_load event.
    /// </summary>
    protected void Page_Load(object sender, EventArgs e)
    {
        // Check permissions and UI elements
        var user = MembershipContext.AuthenticatedUser;

        if (user != null)
        {
            if (!user.IsAuthorizedPerUIElement("CMS.Users", "CmsDesk.Roles"))
            {
                RedirectToUIElementAccessDenied("CMS.Users", "CmsDesk.Roles");
            }

            if (!MembershipContext.AuthenticatedUser.IsAuthorizedPerResource("CMS.Roles", "Read"))
            {
                RedirectToAccessDenied("CMS.Roles", "Read");
            }
        }

        ScriptHelper.RegisterJQuery(Page);

        // Get user id and site Id from query
        mUserId = QueryHelper.GetInteger("userid", 0);

        // Show content placeholder where site selector can be shown
        CurrentMaster.DisplaySiteSelectorPanel = true;

        if ((SiteID > 0) && !MembershipContext.AuthenticatedUser.CheckPrivilegeLevel(UserPrivilegeLevelEnum.Admin))
        {
            plcSites.Visible = false;
            CurrentMaster.DisplaySiteSelectorPanel = false;
        }

        if (mUserId > 0)
        {
            // Check that only global administrator can edit global administrator's accounts
            mUserInfo = UserInfo.Provider.Get(mUserId);
            CheckUserAvaibleOnSite(mUserInfo);
            EditedObject = mUserInfo;

            if (!CheckGlobalAdminEdit(mUserInfo))
            {
                plcTable.Visible = false;
                ShowError(GetString("Administration-User_List.ErrorGlobalAdmin"));
                return;
            }

            // Set site selector
            siteSelector.DropDownSingleSelect.AutoPostBack = true;
            siteSelector.AllowAll   = false;
            siteSelector.AllowEmpty = false;

            // Global roles only for global admin
            if (MembershipContext.AuthenticatedUser.CheckPrivilegeLevel(UserPrivilegeLevelEnum.GlobalAdmin))
            {
                siteSelector.AllowGlobal = true;
            }

            // Only sites assigned to user
            siteSelector.UserId           = mUserId;
            siteSelector.OnlyRunningSites = false;
            siteSelector.UniSelector.OnSelectionChanged += UniSelector_OnSelectionChanged;

            if (!RequestHelper.IsPostBack())
            {
                mSiteId = SiteContext.CurrentSiteID;

                // If user is member of current site
                if (UserSiteInfo.Provider.Get(mUserId, mSiteId) != null)
                {
                    // Force uniselector to preselect current site
                    siteSelector.Value = mSiteId;
                }

                // Force to load data
                siteSelector.Reload(true);
            }

            // Get truly selected item
            mSiteId = ValidationHelper.GetInteger(siteSelector.Value, 0);
        }

        usRoles.OnSelectionChanged += usRoles_OnSelectionChanged;
        string siteIDWhere = (mSiteId <= 0) ? " SiteID IS NULL " : " SiteID =" + mSiteId;

        usRoles.WhereCondition = siteIDWhere;

        usRoles.SelectItemPageUrl     = "~/CMSModules/Membership/Pages/Users/User_Edit_Add_Item_Dialog.aspx";
        usRoles.ListingWhereCondition = siteIDWhere + " AND UserID=" + mUserId;
        usRoles.ReturnColumnName      = "RoleID";
        usRoles.DynamicColumnName     = false;
        usRoles.GridName               = "User_Role_List.xml";
        usRoles.AdditionalColumns      = "ValidTo";
        usRoles.OnAdditionalDataBound += usMemberships_OnAdditionalDataBound;
        usRoles.DialogWindowHeight     = 760;

        // Exclude generic roles
        string    genericWhere = String.Empty;
        ArrayList genericRoles = RoleInfoProvider.GetGenericRoles();

        if (genericRoles.Count != 0)
        {
            foreach (string role in genericRoles)
            {
                genericWhere += "'" + SqlHelper.EscapeQuotes(role) + "',";
            }

            genericWhere            = genericWhere.TrimEnd(',');
            usRoles.WhereCondition += " AND ( RoleName NOT IN (" + genericWhere + ") )";
        }

        // Get the active roles for this site
        var roleIds = new IDQuery <RoleInfo>().Where(siteIDWhere).Column("RoleID");
        var data    = UserRoleInfo.Provider.Get().WhereEquals("UserID", mUserId).And().WhereIn("RoleID", roleIds).Columns("RoleID").TypedResult;

        if (data.Any())
        {
            mCurrentValues = TextHelper.Join(";", data.Select(i => i.RoleID));
        }

        // If not postback or site selection changed
        if (!RequestHelper.IsPostBack() || (mSiteId != Convert.ToInt32(ViewState["rolesOldSiteId"])))
        {
            // Set values
            usRoles.Value = mCurrentValues;
        }

        // Store selected site id
        ViewState["rolesOldSiteId"] = mSiteId;

        string script = "function setNewDateTime(date) {$cmsj('#" + hdnDate.ClientID + "').val(date);}";

        ScriptHelper.RegisterClientScriptBlock(Page, typeof(string), "key", ScriptHelper.GetScript(script));

        string eventTarget   = Request[postEventSourceID];
        string eventArgument = Request[postEventArgumentID];

        if (eventTarget == ucCalendar.DateTimeTextBox.UniqueID)
        {
            if (!MembershipContext.AuthenticatedUser.IsAuthorizedPerResource("CMS.Users", "ManageUserRoles"))
            {
                RedirectToAccessDenied("CMS.Users", "Manage user roles");
            }

            int id = ValidationHelper.GetInteger(hdnDate.Value, 0);
            if (id != 0)
            {
                DateTime     dt  = ValidationHelper.GetDateTime(eventArgument, DateTimeHelper.ZERO_TIME);
                UserRoleInfo uri = UserRoleInfo.Provider.Get(mUserId, id);
                if (uri != null)
                {
                    uri.ValidTo = dt;
                    UserRoleInfo.Provider.Set(uri);

                    // Invalidate user
                    UserInfoProvider.InvalidateUser(mUserId);

                    ShowChangesSaved();
                }
            }
        }
    }
Beispiel #20
0
        public bool Build(Project project, bool runOutput, bool releaseMode)
        {
            // save modified files
            mainForm.CallCommand("SaveAllModified", null);

            string       compiler = null;
            InstalledSDK sdk      = null;

            if (project.IsCompilable)
            {
                sdk      = GetProjectSDK(project);
                compiler = GetCompilerPath(project, sdk);
            }
            project.TraceEnabled = !releaseMode;

            if (project.OutputType == OutputType.OtherIDE)
            {
                // compile using associated IDE
                string error;
                string command = project.GetOtherIDE(runOutput, releaseMode, out error);

                if (error != null)
                {
                    ErrorManager.ShowInfo(TextHelper.GetString(error));
                }
                else
                {
                    if (command == "FlashIDE")
                    {
                        RunFlashIDE(project, runOutput, releaseMode);
                    }
                    else
                    {
                        Hashtable data = new Hashtable();
                        data["command"]     = command;
                        data["project"]     = project;
                        data["runOutput"]   = runOutput;
                        data["releaseMode"] = releaseMode;
                        DataEvent de = new DataEvent(EventType.Command, "ProjectManager.RunWithAssociatedIDE", data);
                        EventManager.DispatchEvent(project, de);
                        if (de.Handled)
                        {
                            return(true);
                        }
                    }
                }
                return(false);
            }
            else if (project.OutputType == OutputType.CustomBuild)
            {
                // validate commands not empty
                if (project.PreBuildEvent.Trim().Length == 0 && project.PostBuildEvent.Trim().Length == 0)
                {
                    String info = TextHelper.GetString("Info.NoOutputAndNoBuild");
                    TraceManager.Add(info);
                }
            }
            else if (project.IsCompilable)
            {
                // ask the project to validate itself
                string error;
                project.ValidateBuild(out error);

                if (error != null)
                {
                    ErrorManager.ShowInfo(TextHelper.GetString(error));
                    return(false);
                }

                if (project.OutputPath.Length == 0)
                {
                    String info = TextHelper.GetString("Info.SpecifyValidOutputSWF");
                    ErrorManager.ShowInfo(info);
                    return(false);
                }

                if (compiler == null || (!Directory.Exists(compiler) && !File.Exists(compiler)))
                {
                    string info = TextHelper.GetString("Info.CheckSDKSettings");
                    MessageBox.Show(info, TextHelper.GetString("Title.ConfigurationRequired"), MessageBoxButtons.OK);
                    return(false);
                }
            }

            // close running AIR projector
            if (project.MovieOptions.Platform.StartsWith("AIR"))
            {
                foreach (Process proc in Process.GetProcessesByName("adl"))
                {
                    try { proc.Kill(); proc.WaitForExit(10 * 1000); }
                    catch { }
                }
            }

            return(FDBuild(project, runOutput, releaseMode, sdk));
        }
        // <Summary>
        // This method is used to export a StoredProcedure object to xml.
        // </Summary>
        public string ExportStoredProcedure(StoredProcedure storedProcedure, int indent = 0)
        {
            // initial value
            string storedProcedureXml = "";

            // locals
            string indentString  = TextHelper.Indent(indent);
            string indentString2 = TextHelper.Indent(indent + 2);

            // If the storedProcedure object exists
            if (NullHelper.Exists(storedProcedure))
            {
                // Create a StringBuilder
                StringBuilder sb = new StringBuilder();

                // Append the indentString
                sb.Append(indentString);

                // Write the open storedProcedure node
                sb.Append("<StoredProcedure>" + Environment.NewLine);

                // Write out each property

                // Write out the value for DoesNotHaveParameters

                sb.Append(indentString2);
                sb.Append("<DoesNotHaveParameters>" + storedProcedure.DoesNotHaveParameters + "</DoesNotHaveParameters>" + Environment.NewLine);

                // Write out the value for Parameters

                // Create the ParametersWriter
                ParametersWriter parametersWriter = new ParametersWriter();

                // Export the Parameters collection to xml
                string storedProcedureParameterXml = parametersWriter.ExportList(storedProcedure.Parameters, indent + 2);
                sb.Append(storedProcedureParameterXml);
                sb.Append(Environment.NewLine);

                // Write out the value for ProcedureName

                sb.Append(indentString2);
                sb.Append("<ProcedureName>" + storedProcedure.ProcedureName + "</ProcedureName>" + Environment.NewLine);

                // Write out the value for ReturnSetSchema

                // Create the ReturnSetSchemaWriter
                ReturnSetSchemaWriter returnSetSchemaWriter = new ReturnSetSchemaWriter();

                // Export the ReturnSetSchemas collection to xml
                string dataFieldXml = returnSetSchemaWriter.ExportList(storedProcedure.ReturnSetSchema, indent + 2);
                sb.Append(dataFieldXml);
                sb.Append(Environment.NewLine);

                // Write out the value for StoredProcedureType

                sb.Append(indentString2);
                sb.Append("<StoredProcedureType>" + storedProcedure.StoredProcedureType + "</StoredProcedureType>" + Environment.NewLine);

                // Write out the value for Text

                // I accidently overwrote this line making the video:
                // The xml has to be formatted if the procedure text contains any greater than or less than symbos or ampersands:
                string encodedText = XmlPatternHelper.Encode(storedProcedure.Text);

                sb.Append(indentString2);
                sb.Append("<Text>" + encodedText + "</Text>" + Environment.NewLine);

                // Append the indentString
                sb.Append(indentString);

                // Write out the close storedProcedure node
                sb.Append("</StoredProcedure>" + Environment.NewLine);

                // set the return value
                storedProcedureXml = sb.ToString();
            }
            // return value
            return(storedProcedureXml);
        }
Beispiel #22
0
        public override string Desc(Player player, string sett)
        {
            var names = SplitHelper.Separator(sett).Select(s => L.b.researches[s].Name());

            return(S.T("reqResearch", TextHelper.CommaSep(names.ToArray())));
        }
Beispiel #23
0
    /// <summary>
    /// Prepares the layout of the web part.
    /// </summary>
    protected override void PrepareLayout()
    {
        StartLayout();

        Append("<div");

        // Width
        string width = Width;

        if (!string.IsNullOrEmpty(width))
        {
            Append(" style=\"width: ", width, "\"");
        }

        if (IsDesign)
        {
            Append(" id=\"", ShortClientID, "_env\">");

            Append("<table class=\"LayoutTable\" cellspacing=\"0\" style=\"width: 100%;\">");

            switch (ViewMode)
            {
            case ViewModeEnum.Design:
            case ViewModeEnum.DesignDisabled:
            {
                Append("<tr><td class=\"LayoutHeader\" colspan=\"2\">");

                // Add header container
                AddHeaderContainer();

                Append("</td></tr>");
            }
            break;
            }

            Append("<tr><td style=\"width: 100%;\">");
        }
        else
        {
            Append(">");
        }

        // Add the tabs
        tabs    = new TabContainer();
        tabs.ID = "tabs";
        AddControl(tabs);

        if (IsDesign)
        {
            Append("</td>");

            // Resizers
            if (AllowDesignMode)
            {
                // Width resizer
                Append("<td class=\"HorizontalResizer\" onmousedown=\"", GetHorizontalResizerScript("env", "Width", false, "tabs_body"), " return false;\">&nbsp;</td></tr>");

                // Height resizer
                Append("<tr><td class=\"VerticalResizer\" onmousedown=\"", GetVerticalResizerScript("tabs_body", "Height"), " return false;\">&nbsp;</td>");
                Append("<td class=\"BothResizer\" onmousedown=\"", GetHorizontalResizerScript("env", "Width", false, "tabs_body"), " ", GetVerticalResizerScript("tabs_body", "Height"), " return false;\">&nbsp;</td>");
            }

            Append("</tr>");
        }

        // Tab headers
        string[] headers = TextHelper.EnsureLineEndings(TabHeaders, "\n").Split('\n');

        if ((ActiveTabIndex >= 1) && (ActiveTabIndex <= Tabs))
        {
            tabs.ActiveTabIndex = ActiveTabIndex - 1;
        }

        bool hideEmpty = HideEmptyTabs;

        for (int i = 1; i <= Tabs; i++)
        {
            // Create new tab
            CMSTabPanel tab = new CMSTabPanel();
            tab.ID = "tab" + i;

            // Prepare the header
            string header = null;
            if (headers.Length >= i)
            {
                header = ResHelper.LocalizeString(headers[i - 1]);
                header = HTMLHelper.HTMLEncode(header);
            }
            if (String.IsNullOrEmpty(header))
            {
                header = "Tab " + i;
            }

            tab.HeaderText      = header;
            tab.HideIfZoneEmpty = hideEmpty;

            tabs.Tabs.Add(tab);

            tab.WebPartZone = AddZone(ID + "_" + i, header, tab);
        }

        // Setup the tabs
        tabs.ScrollBars = ControlsHelper.GetScrollbarsEnum(Scrollbars);

        if (!String.IsNullOrEmpty(TabsCSSClass))
        {
            tabs.CssClass = TabsCSSClass;
        }

        tabs.TabStripPlacement = GetTabStripPlacement(TabStripPlacement);

        if (!String.IsNullOrEmpty(Height))
        {
            tabs.Height = new Unit(Height);
        }

        if (IsDesign)
        {
            // Footer
            if (AllowDesignMode)
            {
                Append("<tr><td class=\"LayoutFooter cms-bootstrap\" colspan=\"2\"><div class=\"LayoutFooterContent\">");

                Append("<div class=\"LayoutLeftActions\">");

                // Pane actions
                AppendAddAction(ResHelper.GetString("Layout.AddTab"), "Tabs");
                if (Tabs > 1)
                {
                    AppendRemoveAction(ResHelper.GetString("Layout.RemoveTab"), "Tabs");
                }

                Append("</div></div></td></tr>");
            }

            Append("</table>");
        }

        Append("</div>");

        FinishLayout();
    }
Beispiel #24
0
 private void UpdateReferencesNextTarget()
 {
     if (currentTargetIndex < targets.Count)
     {
         var       currentTarget = targets[currentTargetIndex];
         FileModel oldFileModel  = currentTarget.OldFileModel;
         FRSearch  search;
         string    oldType;
         if (string.IsNullOrEmpty(oldFileModel.Package))
         {
             search           = new FRSearch("package");
             search.WholeWord = true;
             oldType          = Path.GetFileNameWithoutExtension(currentTarget.OldFilePath);
         }
         else
         {
             search  = new FRSearch("package\\s+(" + oldFileModel.Package + ")");
             oldType = oldFileModel.Package + "." + Path.GetFileNameWithoutExtension(currentTarget.OldFilePath);
         }
         search.IsRegex    = true;
         search.Filter     = SearchFilter.None;
         oldType           = oldType.Trim('.');
         MessageBar.Locked = true;
         string             newFilePath        = currentTarget.NewFilePath;
         ScintillaControl   sci                = AssociatedDocumentHelper.LoadDocument(currentTarget.TmpFilePath ?? newFilePath);
         List <SearchMatch> matches            = search.Matches(sci.Text);
         string             packageReplacement = "package";
         if (currentTarget.NewPackage != "")
         {
             packageReplacement += " " + currentTarget.NewPackage;
         }
         RefactoringHelper.ReplaceMatches(matches, sci, packageReplacement);
         int offset = "package ".Length;
         foreach (SearchMatch match in matches)
         {
             match.Column  += offset;
             match.LineText = sci.GetLine(match.Line - 1);
             match.Value    = currentTarget.NewPackage;
         }
         if (matches.Count > 0)
         {
             if (!Results.ContainsKey(newFilePath))
             {
                 Results[newFilePath] = new List <SearchMatch>();
             }
             Results[newFilePath].AddRange(matches);
         }
         //Do we want to open modified files?
         //if (sci.IsModify) AssociatedDocumentHelper.MarkDocumentToKeep(file);
         PluginBase.MainForm.CurrentDocument.Save();
         MessageBar.Locked = false;
         UserInterfaceManager.ProgressDialog.Show();
         UserInterfaceManager.ProgressDialog.SetTitle(TextHelper.GetString("Info.FindingReferences"));
         UserInterfaceManager.ProgressDialog.UpdateStatusMessage(TextHelper.GetString("Info.SearchingFiles"));
         currentTargetResult = RefactoringHelper.GetRefactorTargetFromFile(oldFileModel.FileName, AssociatedDocumentHelper);
         if (currentTargetResult != null)
         {
             RefactoringHelper.FindTargetInFiles(currentTargetResult, UserInterfaceManager.ProgressDialog.UpdateProgress, FindFinished, true, true);
         }
         else
         {
             currentTargetIndex++;
             UserInterfaceManager.ProgressDialog.Hide();
             UpdateReferencesNextTarget();
         }
     }
     else
     {
         MoveRefactoredFiles();
         ReopenInitialFiles();
         FireOnRefactorComplete();
     }
 }
Beispiel #25
0
    /// <summary>
    /// Prepares the layout of the web part.
    /// </summary>
    protected override void PrepareLayout()
    {
        StartLayout(true);

        // Pane headers
        string[] headers = TextHelper.EnsureLineEndings(PaneHeaders, "\n").Split('\n');

        for (int i = 1; i <= Panes; i++)
        {
            // Create new pane
            AccordionPane pane = new AccordionPane();
            pane.ID = "pane" + i;

            // Prepare the header
            string header = null;
            if (headers.Length >= i)
            {
                header = ResHelper.LocalizeString(headers[i - 1]);
            }
            if (String.IsNullOrEmpty(header))
            {
                header = "Pane " + i;
            }

            string title = header;

            if (IsDesign)
            {
                header = EditableWebPartProperty.GetHTMLCode(null, this, "PaneHeaders", i, EditablePropertyTypeEnum.TextBox, header, null, null, null, true);
            }
            else
            {
                header = EditableWebPartProperty.ApplyReplacements(HttpUtility.HtmlEncode(header), false);
            }

            pane.Header = new TextTransformationTemplate(header);
            acc.Panes.Add(pane);

            var zone = AddZone(ID + "_" + i, title, pane.ContentContainer);
            zone.Wireframe = true;
        }

        // Setup the accordion
        if ((ActivePaneIndex >= 1) && (ActivePaneIndex <= acc.Panes.Count))
        {
            acc.SelectedIndex = ActivePaneIndex - 1;
        }

        // If no active pane is selected and doesn't require opened one, do not preselect any
        if (!acc.RequireOpenedPane && (ActivePaneIndex < 0))
        {
            acc.SelectedIndex = -1;
        }

        // Wireframe design
        acc.CssClass               = "WireframeAccordion";
        acc.ContentCssClass        = "WireframeAccordionContent";
        acc.HeaderCssClass         = "WireframeAccordionHeader";
        acc.HeaderSelectedCssClass = "WireframeAccordionSelectedHeader";

        acc.RequireOpenedPane = RequireOpenedPane;
        acc.AutoSize          = AutoSize.None;

        // Set width / height
        string width = Width;

        if (!String.IsNullOrEmpty(width))
        {
            acc.Width = new Unit(width);
        }

        if (IsDesign && AllowDesignMode)
        {
            // Pane actions
            if (Panes > 1)
            {
                AppendRemoveAction(GetString("Layout.RemoveLastPane"), "Panes", "CMSModules/CMS_PortalEngine/Wireframes/Remove.png", null);
                Append(" ");
            }
            AppendAddAction(GetString("Layout.AddPane"), "Panes", "CMSModules/CMS_PortalEngine/Wireframes/Add.png", null);

            resElem.ResizedElementID = acc.ClientID;
        }

        // Render the actions
        string actions = FinishLayout(false);

        if (!String.IsNullOrEmpty(actions))
        {
            pnlActions.Visible = true;
            ltlActions.Text    = actions;
        }
    }
Beispiel #26
0
        // <Summary>
        // This method is used to export a DataTable object to xml.
        // </Summary>
        public string ExportDataTable(DataTable dataTable, int indent = 0)
        {
            // initial value
            string dataTableXml = "";

            // locals
            string indentString  = TextHelper.Indent(indent);
            string indentString2 = TextHelper.Indent(indent + 2);

            // If the dataTable object exists
            if (NullHelper.Exists(dataTable))
            {
                // Create a StringBuilder
                StringBuilder sb = new StringBuilder();

                // Append the indentString
                sb.Append(indentString);

                // Write the open dataTable node
                sb.Append("<DataTable>" + Environment.NewLine);

                // Write out each property

                // (Manually added Name to the top so you do not have to scroll down to find the name

                // Write out the value for Name

                sb.Append(indentString2);
                sb.Append("<Name>" + dataTable.Name + "</Name>" + Environment.NewLine);

                // Write out the value for CheckConstraints

                // Create the CheckConstraintsWriter
                CheckConstraintsWriter checkConstraintsWriter = new CheckConstraintsWriter();

                // Export the CheckConstraints collection to xml
                string checkConstraintXml = checkConstraintsWriter.ExportList(dataTable.CheckConstraints, indent + 2);
                sb.Append(checkConstraintXml);
                sb.Append(Environment.NewLine);

                // Write out the value for Fields

                // Create the FieldsWriter
                FieldsWriter fieldsWriter = new FieldsWriter();

                // Export the Fields collection to xml
                string dataFieldXml = fieldsWriter.ExportList(dataTable.Fields, indent + 2);
                sb.Append(dataFieldXml);
                sb.Append(Environment.NewLine);

                // Write out the value for ForeignKeys

                // Create the foreignKeyWriter
                ForeignKeysWriter foreignKeyWriter = new ForeignKeysWriter();

                // Write out the value for ForeignKeys
                string foreignKeyXml = foreignKeyWriter.ExportList(dataTable.ForeignKeys, indent + 2);
                sb.Append(foreignKeyXml);
                sb.Append(Environment.NewLine);

                // Write out the value for Indexes

                // Create the IndexesWriter
                IndexesWriter indexesWriter = new IndexesWriter();

                // Export the Indexes collection to xml
                string dataIndexXml = indexesWriter.ExportList(dataTable.Indexes, indent + 2);
                sb.Append(dataIndexXml);
                sb.Append(Environment.NewLine);

                // Write out the value for IsView

                sb.Append(indentString2);
                sb.Append("<IsView>" + dataTable.IsView + "</IsView>" + Environment.NewLine);



                // Write out the value for SchemaName

                sb.Append(indentString2);
                sb.Append("<SchemaName>" + dataTable.SchemaName + "</SchemaName>" + Environment.NewLine);

                // Append the indentString
                sb.Append(indentString);

                // Write out the close dataTable node
                sb.Append("</DataTable>" + Environment.NewLine);

                // set the return value
                dataTableXml = sb.ToString();
            }
            // return value
            return(dataTableXml);
        }
Beispiel #27
0
        public void ExtractStringLiterals_NullArg()
        {
            var result = TextHelper.ExtractStringLiterals(null);

            Assert.IsEmpty(result);
        }
        /// <summary>
        /// This method returns the Connection String
        /// </summary>
        public bool InstallConnectionString(TextLine connectionStringLine)
        {
            // initial value
            bool installed = false;

            // locals
            string   newText = "";
            string   encryptedConnectionString = "";
            TextLine useEncryptionTextLine     = null;

            // verify the AppConfigPath was found
            if ((HasAppConfigPath) && (File.Exists(AppConfigPath)))
            {
                // if the AppConfigTextLinex collection exists and the ConnectionStringIndex is set and in range
                if ((ListHelper.HasOneOrMoreItems(AppConfigTextLines)) && (HasConnectionStringIndex) && (ConnectionStringIndex < AppConfigTextLines.Count))
                {
                    // If the connectionStringLine object exists
                    if ((NullHelper.Exists(connectionStringLine)) && (TextHelper.Exists(ConnectionString)))
                    {
                        // if UseEncryption is true
                        if (UseEncryptionCheckBox.Checked)
                        {
                            // get the textLine for useEncryption (this also sets the useEncryptionIndex
                            useEncryptionTextLine = GetUseEncryptionTextLine(UseCustomKeyCheckBox.Checked);

                            // if use custom encryption key
                            if ((UseCustomKeyCheckBox.Checked) && (EncryptionKeyControl.HasText))
                            {
                                // get the encryptionKey value
                                string encryptionKey = EncryptionKeyControl.Text;

                                // Encrypt the ConnectrionString using the EncryptionKey provided by user
                                encryptedConnectionString = CryptographyHelper.EncryptString(ConnectionString, encryptionKey);
                            }
                            else
                            {
                                // Encrypt the ConnectrionString using the default EncryptionKey
                                encryptedConnectionString = CryptographyHelper.EncryptString(ConnectionString);
                            }

                            // Get the nextText
                            newText = "    <add key=\"ConnectionString\" value=\"" + encryptedConnectionString + "\" />";
                        }
                        else
                        {
                            // Get the nextText
                            newText = "    <add key=\"ConnectionString\" value=\"" + ConnectionString + "\" />";
                        }

                        // If the UseEncryptionIndex value is set
                        if (UseEncryptionIndex > 0)
                        {
                            // Change the text from false to true in UseEncryptionIndex Line
                            AppConfigTextLines[UseEncryptionIndex].Text = "    " + UseEncryptionStart + "\"" + "true" + "\"" + " />";
                        }

                        // If the EncryptionKeyIndex value is set
                        if (EncryptionKeyIndex > 0)
                        {
                            // local
                            string encryptedEncryptionKey = CryptographyHelper.EncryptString(EncryptionKeyControl.Text);

                            // Change the text from false to true in UseEncryptionIndex Line
                            AppConfigTextLines[EncryptionKeyIndex].Text = "    " + EncryptionKeyStart + "\"" + encryptedEncryptionKey + "\"" + " />";
                        }

                        // Replace out all false values for true

                        // Change the text to true in SetupComplete Line
                        AppConfigTextLines[SetupCompleteIndex].Text = "    " + SetupCompleteStart + "\"" + "true" + "\"" + " />";

                        // set the text for this line
                        AppConfigTextLines[ConnectionStringIndex].Text = newText;

                        // Get the text
                        string updatedAppConfigText = WriteOutAppConfigText();

                        // if the text exist
                        if (TextHelper.Exists(updatedAppConfigText))
                        {
                            // Delete the AppConfig file
                            File.Delete(AppConfigPath);

                            // write out the app.config text
                            File.AppendAllText(AppConfigPath, updatedAppConfigText);

                            // success
                            UserCancelled = false;

                            // just in case this is visible after a Test still
                            this.CopiedImage.Visible = false;

                            // Show the Installed Image
                            this.InstalledImage.Visible = true;

                            // Change the text to finished
                            this.CancelButton.Text = "Finished";

                            // Start the timer (this form will close in 5 seconds if the user doesn't close it sooner)
                            InstalledTimer.Enabled = true;
                        }
                    }
                }
            }

            // return value
            return(installed);
        }
Beispiel #29
0
        public void ExtractStringLiterals_EmptyArg()
        {
            var result = TextHelper.ExtractStringLiterals(string.Empty);

            Assert.IsEmpty(result);
        }
Beispiel #30
0
    /// <summary>
    /// Displays data in table.
    /// </summary>
    /// <param name="ds">Dataset with data</param>
    protected void DisplayData(DataSet ds)
    {
        if (!DataHelper.DataSourceIsEmpty(ds))
        {
            // Prepare list of tables
            SortedDictionary <string, DataTable> tables = new SortedDictionary <string, DataTable>();
            foreach (DataTable dt in ds.Tables)
            {
                if (!DataHelper.DataSourceIsEmpty(dt))
                {
                    tables.Add(GetString("ObjectType." + dt.TableName), dt);
                }
            }

            // Generate the tables
            foreach (DataTable dt in tables.Values)
            {
                pnlContent.Controls.Add(new LiteralControl("<h3>" + GetString("ObjectType." + dt.TableName) + "</h3>"));

                if (dt.Columns.Count >= 6)
                {
                    StringBuilder sb;

                    // Write all rows
                    foreach (DataRow dr in dt.Rows)
                    {
                        sb = new StringBuilder();

                        sb.Append("<table class=\"table table-hover\">");

                        // Add header
                        sb.AppendFormat("<thead><tr class=\"unigrid-head\"><th>{0}</th><th class=\"main-column-100\">{1}</th></tr></thead><tbody>", GetString("General.FieldName"), GetString("General.Value"));

                        // Add values
                        foreach (DataColumn dc in dt.Columns)
                        {
                            sb.AppendFormat("<tr><td><strong>{0}</strong></td><td class=\"wrap-normal\">", dc.ColumnName);

                            string content = null;

                            // Binary columns
                            if ((dc.DataType == typeof(byte[])) && (dr[dc.ColumnName] != DBNull.Value))
                            {
                                content = "<binary data>";
                            }
                            else
                            {
                                content = ValidationHelper.GetString(dr[dc.ColumnName], String.Empty);
                            }

                            bool standard = true;
                            switch (dc.ColumnName.ToLowerCSafe())
                            {
                            // Document content
                            case "documentcontent":
                                EditableItems items = new EditableItems();
                                items.LoadContentXml(ValidationHelper.GetString(dr[dc.ColumnName], String.Empty));

                                // Add regions
                                foreach (DictionaryEntry region in items.EditableRegions)
                                {
                                    sb.Append("<span class=\"VersionEditableRegionTitle\">" + (string)region.Key + "</span>");

                                    string regionContent = HTMLHelper.ResolveUrls((string)region.Value, SystemContext.ApplicationPath);

                                    sb.Append("<span class=\"VersionEditableRegionText\">" + regionContent + "</span>");
                                }

                                // Add web parts
                                foreach (DictionaryEntry part in items.EditableWebParts)
                                {
                                    sb.Append("<span class=\"VersionEditableWebPartTitle\">" + (string)part.Key + "</span>");

                                    string regionContent = HTMLHelper.ResolveUrls((string)part.Value, SystemContext.ApplicationPath);
                                    sb.Append("<span class=\"VersionEditableWebPartText\">" + regionContent + "</span>");
                                }

                                standard = false;
                                break;

                            // XML columns
                            case "pagetemplatewebparts":
                            case "webpartproperties":
                            case "reportparameters":
                            case "classformdefinition":
                            case "classxmlschema":
                            case "classformlayout":
                                content = HTMLHelper.ReformatHTML(content);
                                break;
                            }

                            // Standard rendering
                            if (standard)
                            {
                                content = HttpUtility.HtmlEncode(content);
                                content = TextHelper.EnsureHTMLLineEndings(content);
                                content = content.Replace("\t", "&nbsp;&nbsp;&nbsp;&nbsp;");
                                sb.Append("<div style=\"max-height: 300px; overflow: auto;\">" + content + "</div>");
                            }

                            sb.Append("</td></tr>");
                        }

                        sb.Append("</tbody></table><br />\n");

                        pnlContent.Controls.Add(new LiteralControl(sb.ToString()));
                    }
                }
                else
                {
                    GridView newGrid = new GridView();
                    newGrid.ID = "grid" + dt.TableName;
                    newGrid.EnableViewState             = false;
                    newGrid.HeaderStyle.HorizontalAlign = HorizontalAlign.Left;
                    newGrid.CellPadding = 3;
                    newGrid.GridLines   = GridLines.Horizontal;

                    pnlContent.Controls.Add(newGrid);

                    newGrid.DataSource = ds;
                    newGrid.DataMember = dt.TableName;

                    newGrid.DataBind();
                }
            }
        }
    }
Beispiel #31
0
        public void ExtractStringLiterals_NoLiterals()
        {
            var result = TextHelper.ExtractStringLiterals("   I like green 'apples'");

            Assert.IsEmpty(result);
        }