public void Should_not_split()
        {
            string name = "lonE01-SQL02v.0";
            var nameparser = new NameParser("::", name);

            Assert.That(nameparser.Host, Is.EqualTo(""));
            Assert.That(nameparser.Metric, Is.EqualTo("lonE01-SQL02v.0"));
        }
        public void Should_split_names_to_get_tail_only()
        {
            string name = "LONBTI-ESX01p::lonE01-SQL02v.0::fred";
            var nameparser = new NameParser("::", name);

            Assert.That(nameparser.Host, Is.EqualTo("LONBTI-ESX01p"));
            Assert.That(nameparser.Metric, Is.EqualTo("lonE01-SQL02v.0"));
        }
Esempio n. 3
0
    static PersonGenerator()
    {
        nameParser = new NameParser(PICTURES_COUNT);

        // Might be a little heavy, but since it's only done once, it's not that bad
        pictureIndexesMale = new List<int>(PICTURES_COUNT);
        pictureIndexesFemale = new List<int>(PICTURES_COUNT);

        for (int i = 1; i <= PICTURES_COUNT; i++)
        {
            pictureIndexesFemale.Add(i);
            pictureIndexesMale.Add(i);
        }
    }
        public static string CatchVariableName(ITreeNode treeNode, IDeclaredType exceptionType)
        {
            var namingPolicyManager = new NamingPolicyManager(LanguageManager.Instance, treeNode.GetSolution());
            var nameParser = new NameParser(treeNode.GetSolution(), namingPolicyManager);
            var nameSuggestionManager = new NameSuggestionManager(treeNode.GetSolution(), nameParser, namingPolicyManager);
            var policy = namingPolicyManager.GetPolicy(NamedElementKinds.Locals, treeNode.Language, treeNode.GetSourceFile());

            var namesCollection = nameSuggestionManager.CreateEmptyCollection(
                PluralityKinds.Single, treeNode.Language, true, treeNode.GetSourceFile());

            var entryOptions = new EntryOptions
            {
                PluralityKind = PluralityKinds.Single,
                PredefinedPrefixPolicy = PredefinedPrefixPolicy.Preserve,
                Emphasis = Emphasis.Good,
                SubrootPolicy = SubrootPolicy.Decompose
            };

            namesCollection.Add(exceptionType, entryOptions);
            namesCollection.Prepare(policy.NamingRule, ScopeKind.Common, new SuggestionOptions());

            return namesCollection.FirstName();
        }
Esempio n. 5
0
 public FunctionPointerTypeRule(NameParser nameParser)
 {
     this.nameParser = nameParser;
 }
Esempio n. 6
0
        private async Task <IEnumerable <RemoteSearchResult> > GetSearchResults(ItemLookupInfo idInfo, string searchType, CancellationToken cancellationToken)
        {
            var name       = idInfo.Name;
            var year       = idInfo.Year;
            int?yearInName = null;

            var tmdbSettings = await MovieDbProvider.Current.GetTmdbSettings(cancellationToken).ConfigureAwait(false);

            var tmdbImageUrl = tmdbSettings.images.base_url + "original";

            NameParser.ParseName(name, out name, out yearInName);

            year = year ?? yearInName;

            _logger.Info("MovieDbProvider: Finding id for item: " + name);
            var language = idInfo.MetadataLanguage.ToLower();

            //nope - search for it
            //var searchType = item is BoxSet ? "collection" : "movie";

            var results = await GetSearchResults(name, searchType, year, language, tmdbImageUrl, cancellationToken).ConfigureAwait(false);

            if (results.Count == 0)
            {
                //try in english if wasn't before
                if (!string.Equals(language, "en", StringComparison.OrdinalIgnoreCase))
                {
                    results = await GetSearchResults(name, searchType, year, "en", tmdbImageUrl, cancellationToken).ConfigureAwait(false);
                }
            }

            if (results.Count == 0)
            {
                // try with dot and _ turned to space
                var originalName = name;

                name = name.Replace(",", " ");
                name = name.Replace(".", " ");
                name = name.Replace("_", " ");
                name = name.Replace("-", " ");
                name = name.Replace("!", " ");
                name = name.Replace("?", " ");

                name = name.Trim();

                // Search again if the new name is different
                if (!string.Equals(name, originalName))
                {
                    results = await GetSearchResults(name, searchType, year, language, tmdbImageUrl, cancellationToken).ConfigureAwait(false);

                    if (results.Count == 0 && !string.Equals(language, "en", StringComparison.OrdinalIgnoreCase))
                    {
                        //one more time, in english
                        results = await GetSearchResults(name, searchType, year, "en", tmdbImageUrl, cancellationToken).ConfigureAwait(false);
                    }
                }
            }

            return(results.Where(i =>
            {
                if (year.HasValue && i.ProductionYear.HasValue)
                {
                    return year.Value == i.ProductionYear.Value;
                }

                return true;
            }));
        }
Esempio n. 7
0
 public string GetSubFolderPath()
 {
     return(NameParser.Parse(NameParserType.URL, SubFolderPath.Replace("%host", Helpers.ExpandFolderVariables(LocalhostRoot))));
 }
Esempio n. 8
0
        private void ControlSettings()
        {
            ImageList imageUploadersImageList = new ImageList();

            imageUploadersImageList.ColorDepth = ColorDepth.Depth32Bit;
            imageUploadersImageList.Images.Add("ImageShack", Resources.ImageShack);
            imageUploadersImageList.Images.Add("TinyPic", Resources.TinyPic);
            imageUploadersImageList.Images.Add("Imgur", Resources.Imgur);
            imageUploadersImageList.Images.Add("Flickr", Resources.Flickr);
            imageUploadersImageList.Images.Add("Photobucket", Resources.Photobucket);
            imageUploadersImageList.Images.Add("Picasa", Resources.Picasa);
            imageUploadersImageList.Images.Add("TwitPic", Resources.TwitPic);
            imageUploadersImageList.Images.Add("TwitSnaps", Resources.TwitSnaps);
            imageUploadersImageList.Images.Add("YFrog", Resources.YFrog);
            tcImageUploaders.ImageList = imageUploadersImageList;

            ImageList fileUploadersImageList = new ImageList();

            fileUploadersImageList.ColorDepth = ColorDepth.Depth32Bit;
            fileUploadersImageList.Images.Add("Dropbox", Resources.Dropbox);
            fileUploadersImageList.Images.Add("GoogleDrive", Resources.GoogleDrive);
            fileUploadersImageList.Images.Add("Box", Resources.Box);
            fileUploadersImageList.Images.Add("Minus", Resources.Minus);
            fileUploadersImageList.Images.Add("FTP", Resources.folder_network);
            fileUploadersImageList.Images.Add("RapidShare", Resources.RapidShare);
            fileUploadersImageList.Images.Add("SendSpace", Resources.SendSpace);
            fileUploadersImageList.Images.Add("Gett", Resources.Gett);
            fileUploadersImageList.Images.Add("Localhostr", Resources.Localhostr);
            fileUploadersImageList.Images.Add("CustomUploader", Resources.globe_network);
            fileUploadersImageList.Images.Add("SharedFolders", Resources.server_network);
            fileUploadersImageList.Images.Add("Email", Resources.mail);
            fileUploadersImageList.Images.Add("Jira", Resources.jira);
            fileUploadersImageList.Images.Add("Mega", Resources.Mega);
            tcFileUploaders.ImageList = fileUploadersImageList;

            ImageList textUploadersImageList = new ImageList();

            textUploadersImageList.ColorDepth = ColorDepth.Depth32Bit;
            textUploadersImageList.Images.Add("Pastebin", Resources.Pastebin);
            textUploadersImageList.Images.Add("Gist", Resources.Gist);
            tcTextUploaders.ImageList = textUploadersImageList;

            ImageList urlShortenersImageList = new ImageList();

            urlShortenersImageList.ColorDepth = ColorDepth.Depth32Bit;
            urlShortenersImageList.Images.Add("Google", Resources.Google);
            urlShortenersImageList.Images.Add("Bitly", Resources.Bitly);
            tcURLShorteners.ImageList = urlShortenersImageList;

            ImageList socialNetworkingServicesImageList = new ImageList();

            socialNetworkingServicesImageList.ColorDepth = ColorDepth.Depth32Bit;
            socialNetworkingServicesImageList.Images.Add("Twitter", Resources.Twitter);
            tcSocialNetworkingServices.ImageList = socialNetworkingServicesImageList;

            tpImageShack.ImageKey         = "ImageShack";
            tpTinyPic.ImageKey            = "TinyPic";
            tpImgur.ImageKey              = "Imgur";
            tpFlickr.ImageKey             = "Flickr";
            tpPhotobucket.ImageKey        = "Photobucket";
            tpPicasa.ImageKey             = "Picasa";
            tpTwitPic.ImageKey            = "TwitPic";
            tpTwitSnaps.ImageKey          = "TwitSnaps";
            tpYFrog.ImageKey              = "YFrog";
            tpDropbox.ImageKey            = "Dropbox";
            tpGoogleDrive.ImageKey        = "GoogleDrive";
            tpBox.ImageKey                = "Box";
            tpMinus.ImageKey              = "Minus";
            tpFTP.ImageKey                = "FTP";
            tpRapidShare.ImageKey         = "RapidShare";
            tpSendSpace.ImageKey          = "SendSpace";
            tpSharedFolder.ImageKey       = "SharedFolders";
            tpEmail.ImageKey              = "Email";
            tpJira.ImageKey               = "Jira";
            tpGe_tt.ImageKey              = "Gett";
            tpHostr.ImageKey              = "Localhostr";
            tpCustomUploaders.ImageKey    = "CustomUploader";
            tpPastebin.ImageKey           = "Pastebin";
            tpGoogleURLShortener.ImageKey = "Google";
            tpBitly.ImageKey              = "Bitly";
            tpTwitter.ImageKey            = "Twitter";
            tpMega.ImageKey               = "Mega";
            tpGist.ImageKey               = "Gist";

            cmsCustomUploaderArgValue = NameParser.CreateCodesMenu(txtCustomUploaderArgValue, ReplacementVariables.n);

            txtCustomUploaderLog.AddContextMenu();
        }
Esempio n. 9
0
        public TaskSettingsForm(TaskSettings hotkeySetting, bool isDefault = false)
        {
            InitializeComponent();
            Icon         = ShareXResources.Icon;
            TaskSettings = hotkeySetting;
            IsDefault    = isDefault;

            if (IsDefault)
            {
                Text = Application.ProductName + " - Task settings";
                tcHotkeySettings.TabPages.Remove(tpTask);
                chkUseDefaultGeneralSettings.Visible    = chkUseDefaultImageSettings.Visible = chkUseDefaultCaptureSettings.Visible = chkUseDefaultActions.Visible =
                    chkUseDefaultUploadSettings.Visible = chkUseDefaultIndexerSettings.Visible = chkUseDefaultAdvancedSettings.Visible = false;
                panelGeneral.BorderStyle = BorderStyle.None;
            }
            else
            {
                Text = Application.ProductName + " - Task settings for " + TaskSettings;
                tbDescription.Text = TaskSettings.Description;
                cbUseDefaultAfterCaptureSettings.Checked = TaskSettings.UseDefaultAfterCaptureJob;
                cbUseDefaultAfterUploadSettings.Checked  = TaskSettings.UseDefaultAfterUploadJob;
                cbUseDefaultDestinationSettings.Checked  = TaskSettings.UseDefaultDestinations;
                chkUseDefaultGeneralSettings.Checked     = TaskSettings.UseDefaultGeneralSettings;
                chkUseDefaultImageSettings.Checked       = TaskSettings.UseDefaultImageSettings;
                chkUseDefaultCaptureSettings.Checked     = TaskSettings.UseDefaultCaptureSettings;
                chkUseDefaultActions.Checked             = TaskSettings.UseDefaultActions;
                chkUseDefaultUploadSettings.Checked      = TaskSettings.UseDefaultUploadSettings;
                chkUseDefaultIndexerSettings.Checked     = TaskSettings.UseDefaultIndexerSettings;
                chkUseDefaultAdvancedSettings.Checked    = TaskSettings.UseDefaultAdvancedSettings;
            }

            AddEnumItems <HotkeyType>(x => TaskSettings.Job = x, cmsTask);
            AddMultiEnumItems <AfterCaptureTasks>(x => TaskSettings.AfterCaptureJob   = TaskSettings.AfterCaptureJob.Swap(x), cmsAfterCapture);
            AddMultiEnumItems <AfterUploadTasks>(x => TaskSettings.AfterUploadJob     = TaskSettings.AfterUploadJob.Swap(x), cmsAfterUpload);
            AddEnumItems <ImageDestination>(x => TaskSettings.ImageDestination        = x, cmsImageUploaders);
            AddEnumItems <TextDestination>(x => TaskSettings.TextDestination          = x, cmsTextUploaders);
            AddEnumItems <FileDestination>(x => TaskSettings.FileDestination          = x, cmsFileUploaders);
            AddEnumItems <UrlShortenerType>(x => TaskSettings.URLShortenerDestination = x, cmsURLShorteners);
            AddEnumItems <SocialNetworkingService>(x => TaskSettings.SocialNetworkingServiceDestination = x, cmsSocialNetworkingServices);

            SetEnumChecked(TaskSettings.Job, cmsTask);
            SetMultiEnumChecked(TaskSettings.AfterCaptureJob, cmsAfterCapture);
            SetMultiEnumChecked(TaskSettings.AfterUploadJob, cmsAfterUpload);
            SetEnumChecked(TaskSettings.ImageDestination, cmsImageUploaders);
            SetEnumChecked(TaskSettings.TextDestination, cmsTextUploaders);
            SetEnumChecked(TaskSettings.FileDestination, cmsFileUploaders);
            SetEnumChecked(TaskSettings.URLShortenerDestination, cmsURLShorteners);
            SetEnumChecked(TaskSettings.SocialNetworkingServiceDestination, cmsSocialNetworkingServices);

            // FTP
            if (Program.UploadersConfig != null && Program.UploadersConfig.FTPAccountList.Count > 1)
            {
                chkOverrideFTP.Checked = TaskSettings.OverrideFTP;
                cboFTPaccounts.Items.Clear();
                cboFTPaccounts.Items.AddRange(Program.UploadersConfig.FTPAccountList.ToArray());
                cboFTPaccounts.SelectedIndex = TaskSettings.FTPIndex.BetweenOrDefault(0, Program.UploadersConfig.FTPAccountList.Count - 1);
            }

            UpdateDestinationStates();
            UpdateUploaderMenuNames();

            // General
            cbPlaySoundAfterCapture.Checked     = TaskSettings.GeneralSettings.PlaySoundAfterCapture;
            cbShowAfterCaptureTasksForm.Checked = TaskSettings.GeneralSettings.ShowAfterCaptureTasksForm;
            cbPlaySoundAfterUpload.Checked      = TaskSettings.GeneralSettings.PlaySoundAfterUpload;
            chkShowAfterUploadForm.Checked      = TaskSettings.GeneralSettings.ShowAfterUploadForm;
            cbTrayBalloonTipAfterUpload.Checked = TaskSettings.GeneralSettings.TrayBalloonTipAfterUpload;
            cbShowToastWindowAfterTask.Checked  = TaskSettings.GeneralSettings.ShowToastWindowAfterTask;
            cbHistorySave.Checked = TaskSettings.GeneralSettings.SaveHistory;

            // Image - Quality
            cbImageFormat.SelectedIndex     = (int)TaskSettings.ImageSettings.ImageFormat;
            nudImageJPEGQuality.Value       = TaskSettings.ImageSettings.ImageJPEGQuality;
            cbImageGIFQuality.SelectedIndex = (int)TaskSettings.ImageSettings.ImageGIFQuality;
            nudUseImageFormat2After.Value   = TaskSettings.ImageSettings.ImageSizeLimit;
            cbImageFormat2.SelectedIndex    = (int)TaskSettings.ImageSettings.ImageFormat2;

            // Image - Effects
            chkShowImageEffectsWindowAfterCapture.Checked = TaskSettings.ImageSettings.ShowImageEffectsWindowAfterCapture;
            cbImageEffectOnlyRegionCapture.Checked        = TaskSettings.ImageSettings.ImageEffectOnlyRegionCapture;

            // Capture
            cbShowCursor.Checked             = TaskSettings.CaptureSettings.ShowCursor;
            cbCaptureTransparent.Checked     = TaskSettings.CaptureSettings.CaptureTransparent;
            cbCaptureShadow.Enabled          = TaskSettings.CaptureSettings.CaptureTransparent;
            cbCaptureShadow.Checked          = TaskSettings.CaptureSettings.CaptureShadow;
            nudCaptureShadowOffset.Value     = TaskSettings.CaptureSettings.CaptureShadowOffset;
            cbCaptureClientArea.Checked      = TaskSettings.CaptureSettings.CaptureClientArea;
            cbScreenshotDelay.Checked        = TaskSettings.CaptureSettings.IsDelayScreenshot;
            nudScreenshotDelay.Value         = TaskSettings.CaptureSettings.DelayScreenshot;
            cbCaptureAutoHideTaskbar.Checked = TaskSettings.CaptureSettings.CaptureAutoHideTaskbar;

            if (TaskSettings.CaptureSettings.SurfaceOptions == null)
            {
                TaskSettings.CaptureSettings.SurfaceOptions = new SurfaceOptions();
            }
            pgShapesCapture.SelectedObject = TaskSettings.CaptureSettings.SurfaceOptions;

            // Capture / Screen recorder
            cbScreenRecorderOutput.Items.AddRange(Helpers.GetEnumDescriptions <ScreenRecordOutput>());
            cbScreenRecorderOutput.SelectedIndex  = (int)TaskSettings.CaptureSettings.ScreenRecordOutput;
            nudScreenRecorderFPS.Value            = TaskSettings.CaptureSettings.ScreenRecordFPS;
            cbScreenRecorderFixedDuration.Checked = TaskSettings.CaptureSettings.ScreenRecordFixedDuration;
            nudScreenRecorderDuration.Enabled     = TaskSettings.CaptureSettings.ScreenRecordFixedDuration;
            nudScreenRecorderDuration.Value       = (decimal)TaskSettings.CaptureSettings.ScreenRecordDuration;
            nudScreenRecorderStartDelay.Value     = (decimal)TaskSettings.CaptureSettings.ScreenRecordStartDelay;

            gbCommandLineEncoderSettings.Enabled             = TaskSettings.CaptureSettings.ScreenRecordOutput == ScreenRecordOutput.AVICommandLine;
            txtScreenRecorderCommandLinePath.Text            = TaskSettings.CaptureSettings.ScreenRecordCommandLinePath;
            txtScreenRecorderCommandLineArgs.Text            = TaskSettings.CaptureSettings.ScreenRecordCommandLineArgs;
            txtScreenRecorderCommandLineOutputExtension.Text = TaskSettings.CaptureSettings.ScreenRecordCommandLineOutputExtension;

            // Actions
            TaskHelpers.AddDefaultExternalPrograms(TaskSettings);

            foreach (ExternalProgram fileAction in TaskSettings.ExternalPrograms)
            {
                AddFileAction(fileAction);
            }

            // Watch folders
            cbWatchFolderEnabled.Checked = TaskSettings.WatchFolderEnabled;

            if (TaskSettings.WatchFolderList == null)
            {
                TaskSettings.WatchFolderList = new List <WatchFolderSettings>();
            }
            else
            {
                foreach (WatchFolderSettings watchFolder in TaskSettings.WatchFolderList)
                {
                    AddWatchFolder(watchFolder);
                }
            }

            // Upload / Name pattern
            txtNameFormatPattern.Text             = TaskSettings.UploadSettings.NameFormatPattern;
            txtNameFormatPatternActiveWindow.Text = TaskSettings.UploadSettings.NameFormatPatternActiveWindow;
            cmsNameFormatPattern               = NameParser.CreateCodesMenu(txtNameFormatPattern, ReplacementVariables.n);
            cmsNameFormatPatternActiveWindow   = NameParser.CreateCodesMenu(txtNameFormatPatternActiveWindow, ReplacementVariables.n);
            cbFileUploadUseNamePattern.Checked = TaskSettings.UploadSettings.FileUploadUseNamePattern;

            // Upload / Clipboard upload
            cbClipboardUploadAutoDetectURL.Checked = TaskSettings.UploadSettings.ClipboardUploadAutoDetectURL;

            // Indexer
            pgIndexerConfig.SelectedObject = TaskSettings.IndexerSettings;

            // Advanced
            pgTaskSettings.SelectedObject = TaskSettings.AdvancedSettings;

            UpdateDefaultSettingVisibility();
            loaded = true;
        }
Esempio n. 10
0
 public MemberTypeRule(NameParser nameParser)
 {
     this.nameParser = nameParser;
 }
Esempio n. 11
0
        public void it_returns_an_empty_string_when_parsing_an_empty_string()
        {
            string result = NameParser.Parse("");

            result.Should().Be("");
        }
Esempio n. 12
0
		private static String generateShortName(NameParser nameParser)
		{
			String name = nameParser.OriginalName;
			String s = name;
			
			if (nameParser.PathPackageAndFilename)
			{
				s = nameParser.Filename;
			}
			else
			{
				/* do we have a file name? */
				int dotAt = name.LastIndexOf('.');
				if (dotAt > 1)
				{
					/* yes let's strip the directory off */
					int lastSlashAt = name.LastIndexOf('\\', dotAt);
					lastSlashAt = Math.Max(lastSlashAt, name.LastIndexOf('/', dotAt));
					
					s = name.Substring(lastSlashAt + 1);
				}
				else
				{
					/* not a file name ... */
					s = name;
				}
			}
			return s.Trim();
		}
    public override IList<IResult> Get()
    {
        var rtn = new List<IResult>();

        try
        {
            foreach (var o in this.GetWmiObject(this.Sql, this.machineName, RootPath))
            {
                var value = -1;
                var dateTime = DateTime.Now;
                var name = string.Empty;

                foreach (var col in o.Properties)
                {
                    if (col.Type == CimType.String)
                    {
                        var np =  new NameParser("::", Convert.ToString(col.Value));
                        name = np.Metric;
                    }

                    if (col.Type == CimType.UInt32)
                    {
                        value = Convert.ToInt32(col.Value);
                    }

                    if (col.Type == CimType.UInt64)
                    {
                        value = Convert.ToInt32(col.Value);
                    }

                    if (col.Type == CimType.DateTime)
                    {
                        dateTime = Convert.ToDateTime(col.Value);
                    }
                }

                this.Log.Debug(string.Format("Name {0} value {1} datetime {2}", name, value, dateTime));
                var r = new Result(name, dateTime, this.Path);
                r.SetValue(value);
                rtn.Add(r);
            }
        }
        catch (ManagementException e)
        {
            this.Log.Error(string.Format("Error with {0} {1} {2}", this.Type, this.Path, this.Sql));
            this.Log.Error(e.Message);
            this.Log.Error(e.StackTrace);
        }

        return rtn;
    }
Esempio n. 14
0
 public void it_throws_an_exception_when_parsing_null()
 {
     (new Action(() => NameParser.Parse((string)null))).Should().Throw <ArgumentNullException>();
 }
Esempio n. 15
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="recordingFile"></param>
        public void AddOrUpdateRecordingFile(String recordingFile)
        {
            try
            {
                NameParser parser = new NameParser();
                parser.SingleFileInitialise(recordingFile);

                Speaker spk = this.Speaker.SingleOrDefault(x => x.Name == parser.Speaker);
                if (spk == null)
                {
                    spk = new Speaker()
                    {
                        Name = parser.Speaker
                    };
                    this.Speaker.AddOrUpdate(x => x.Name, spk);
                    this.SaveChanges();
                }

                Category cty = this.Category.SingleOrDefault(x => x.Name == parser.Category);
                if (cty == null)
                {
                    cty = new Category()
                    {
                        // Vocal tract videos are of vowel sounds, and so need to be categorised as such.
                        // However, the category section of the filename is also used to differentiate between videos and vocal tracts.
                        Name = parser.Category.Equals("vocaltract") ? "vowel" : parser.Category
                    };
                    this.Category.AddOrUpdate(x => x.Name, cty);
                    this.SaveChanges();
                }

                Word word = this.Word.SingleOrDefault(x => x.Name == parser.Word);
                if (word == null)
                {
                    word = new Word()
                    {
                        Name       = parser.Word,
                        CategoryId = cty.CategoryId
                    };
                    this.Word.AddOrUpdate(x => x.Name, word);
                    this.SaveChanges();
                }

                Recording rd = this.Recording.SingleOrDefault(x => x.Name == parser.Recording);;
                if (rd == null)
                {
                    rd = new Recording()
                    {
                        Name      = parser.Recording,
                        SpeakerId = spk.SpeakerId,
                        WordId    = word.WordId
                    };
                    this.Recording.AddOrUpdate(x => x.Name, rd);
                    this.SaveChanges();
                }

                SingleFile sf = this.SingleFile.SingleOrDefault(x => x.Name == parser.FullName);
                if (sf == null)
                {
                    sf = new SingleFile()
                    {
                        Name    = parser.FullName,
                        Address = parser.Address,
                    };
                    if (parser.MediaFormat.Equals("audio"))
                    {
                        sf.Audio = rd;
                    }
                    else if (parser.MediaFormat.Equals("video"))
                    {
                        sf.Video = rd;
                    }
                    else if (parser.MediaFormat.Equals("vocaltract"))
                    {
                        sf.VocalTract = rd;
                    }
                    this.SingleFile.AddOrUpdate(x => x.Name, sf);
                    this.SaveChanges();
                }
            }
            catch (Exception exp)
            {
                Console.WriteLine(exp);
            }
        }
Esempio n. 16
0
        public string GetSubFolderPath()
        {
            NameParser parser = new NameParser(NameParserType.URL);

            return(parser.Parse(SubFolderPath.Replace("%host", Host)));
        }
Esempio n. 17
0
 public WatermarkForm(WatermarkConfig watermarkConfig)
 {
     InitializeComponent();
     config    = watermarkConfig;
     codesMenu = NameParser.CreateCodesMenu(txtWatermarkText, ReplacementVariables.t);
 }
Esempio n. 18
0
        private string GetObjectKey(string fileName)
        {
            string objectPrefix = NameParser.Parse(NameParserType.FolderPath, S3Settings.ObjectPrefix.Trim('/'));

            return(URLHelpers.CombineURL(objectPrefix, fileName));
        }
Esempio n. 19
0
        public void it_returns_the_same_string_when_parsing_a_single_word()
        {
            string result = NameParser.Parse("foo");

            result.Should().Be("foo");
        }
Esempio n. 20
0
		private static readonly String m_newline = Environment.NewLine; //$NON-NLS-1$
		
		/// <param name="name">filename in "basepath;package;filename" format
		/// </param>
		public DModule(SourceLocator sourceLocator, int id, int bitmap, String name, String script)
		{
			// If the caller gave us the script text, then we will create m_script
			// now.  But if the caller gave us an empty string, then we won't bother
			// looking for a disk file until someone actually asks for it.
			if (script != null && script.Length > 0)
			{
				m_script = new ScriptText(script);
				m_gotRealScript = true;
			}
			
			NameParser nameParser = new NameParser(name);
			
			m_sourceLocator = sourceLocator;
			m_rawName = name;
			m_basePath = nameParser.BasePath; // may be null
			m_bitmap = bitmap;
			m_id = id;
			m_shortName = generateShortName(nameParser);
			m_path = generatePath(nameParser);
			m_line2Offset = new System.Collections.ArrayList();
			m_line2Func = new System.Collections.ArrayList();
			m_func2FirstLine = new System.Collections.Hashtable();
			m_func2LastLine = new System.Collections.Hashtable();
			m_packageName = nameParser.Package;
			m_gotAllFncNames = false;
		}
Esempio n. 21
0
        public void it_returns_two_strings_when_parsing_words_separated_by_semicolons()
        {
            string result = NameParser.Parse("foo_bar");

            result.Should().Be("foo bar");
        }
Esempio n. 22
0
		/// <summary> Produce a name that contains a file specification including full path.
		/// File names may come in as 'mx.bla : file:/bla.foo.as' or as
		/// 'file://bla.foo.as' or as 'C:\'(?) or as 'basepath;package;filename'
		/// </summary>
		private static String generatePath(NameParser nameParser)
		{
			String name = nameParser.OriginalName;
			String s = name;
			
			/* strip off first colon of stuff if package exists */
			int colonAt = name.IndexOf(':');
			if (colonAt > 1 && !name.StartsWith("Actions for"))
			//$NON-NLS-1$
			{
				if (name[colonAt + 1] == ' ')
					s = name.Substring(colonAt + 2);
			}
			else if (name.IndexOf('.') > - 1 && name[0] != '<')
			{
				/* some other type of file name */
				s = nameParser.recombine();
			}
			else
			{
				// no path
				s = ""; //$NON-NLS-1$
			}
			return s.Trim();
		}
Esempio n. 23
0
        public override Image Apply(Image img)
        {
            if (string.IsNullOrEmpty(Text))
            {
                return(img);
            }

            using (Font textFont = TextFont)
            {
                if (textFont == null || textFont.Size < 1)
                {
                    return(img);
                }

                NameParser parser = new NameParser(NameParserType.Text);

                if (img != null)
                {
                    parser.ImageWidth  = img.Width;
                    parser.ImageHeight = img.Height;
                }

                string parsedText = parser.Parse(Text);

                Size      textSize           = Helpers.MeasureText(parsedText, textFont);
                Size      watermarkSize      = new Size(Padding.Left + textSize.Width + Padding.Right, Padding.Top + textSize.Height + Padding.Bottom);
                Point     watermarkPosition  = Helpers.GetPosition(Placement, Offset, img.Size, watermarkSize);
                Rectangle watermarkRectangle = new Rectangle(watermarkPosition, watermarkSize);

                if (AutoHide && !new Rectangle(0, 0, img.Width, img.Height).Contains(watermarkRectangle))
                {
                    return(img);
                }

                using (Graphics g = Graphics.FromImage(img))
                {
                    g.SmoothingMode = SmoothingMode.HighQuality;

                    using (GraphicsPath gp = new GraphicsPath())
                    {
                        gp.AddRoundedRectangleProper(watermarkRectangle, CornerRadius);

                        if (DrawBackground)
                        {
                            Brush backgroundBrush = null;

                            try
                            {
                                if (UseGradient)
                                {
                                    if (UseCustomGradient && Gradient != null && Gradient.IsValid)
                                    {
                                        backgroundBrush = new LinearGradientBrush(watermarkRectangle, Color.Transparent, Color.Transparent, Gradient.Type);
                                        ColorBlend colorBlend = new ColorBlend();
                                        IEnumerable <GradientStop> gradient = Gradient.Colors.OrderBy(x => x.Location);
                                        colorBlend.Colors    = gradient.Select(x => x.Color).ToArray();
                                        colorBlend.Positions = gradient.Select(x => x.Location / 100).ToArray();
                                        ((LinearGradientBrush)backgroundBrush).InterpolationColors = colorBlend;
                                    }
                                    else
                                    {
                                        backgroundBrush = new LinearGradientBrush(watermarkRectangle, BackgroundColor, BackgroundColor2, GradientType);
                                    }
                                }
                                else
                                {
                                    backgroundBrush = new SolidBrush(BackgroundColor);
                                }

                                g.FillPath(backgroundBrush, gp);
                            }
                            finally
                            {
                                if (backgroundBrush != null)
                                {
                                    backgroundBrush.Dispose();
                                }
                            }
                        }

                        if (DrawBorder)
                        {
                            int borderSize = BorderSize.Min(1);

                            if (borderSize.IsEvenNumber())
                            {
                                g.PixelOffsetMode = PixelOffsetMode.Half;
                            }

                            using (Pen borderPen = new Pen(BorderColor, borderSize))
                            {
                                g.DrawPath(borderPen, gp);
                            }

                            g.PixelOffsetMode = PixelOffsetMode.Default;
                        }
                    }

                    float centerX = watermarkRectangle.Width / 2f - (Padding.Right - Padding.Left);
                    float centerY = watermarkRectangle.Height / 2f - (Padding.Bottom - Padding.Top);

                    if (DrawTextShadow)
                    {
                        using (Brush textShadowBrush = new SolidBrush(TextShadowColor))
                        {
                            g.DrawString(parsedText, textFont, textShadowBrush, watermarkRectangle.X + Padding.Left + TextShadowOffset.X,
                                         watermarkRectangle.Y + Padding.Top + TextShadowOffset.Y);
                        }
                    }

                    using (Brush textBrush = new SolidBrush(TextColor))
                    {
                        g.DrawString(parsedText, textFont, textBrush, watermarkRectangle.X + Padding.Left, watermarkRectangle.Y + Padding.Top);
                    }
                }
            }

            return(img);
        }
Esempio n. 24
0
        public override Image Apply(Image img)
        {
            if (string.IsNullOrEmpty(Text))
            {
                return(img);
            }

            using (Font textFont = TextFont)
            {
                if (textFont == null || textFont.Size < 1)
                {
                    return(img);
                }

                NameParser parser = new NameParser(NameParserType.Text)
                {
                    Picture = img
                };
                string parsedText = parser.Parse(Text);

                Size      textSize           = Helpers.MeasureText(parsedText, textFont);
                Size      watermarkSize      = new Size(textSize.Width + BackgroundPadding * 2, textSize.Height + BackgroundPadding * 2);
                Point     watermarkPosition  = Helpers.GetPosition(Placement, Offset, img.Size, watermarkSize);
                Rectangle watermarkRectangle = new Rectangle(watermarkPosition, watermarkSize);

                if (AutoHide && !new Rectangle(0, 0, img.Width, img.Height).Contains(watermarkRectangle))
                {
                    return(img);
                }

                using (Bitmap bmpWatermark = new Bitmap(watermarkSize.Width, watermarkSize.Height))
                    using (Graphics gWatermark = Graphics.FromImage(bmpWatermark))
                    {
                        gWatermark.SetHighQuality();

                        if (DrawBackground)
                        {
                            using (GraphicsPath backgroundPath = new GraphicsPath())
                            {
                                Rectangle backgroundRect = new Rectangle(0, 0, watermarkSize.Width, watermarkSize.Height);
                                backgroundPath.AddRoundedRectangle(backgroundRect, CornerRadius);

                                Brush backgroundBrush = null;

                                try
                                {
                                    if (UseGradient)
                                    {
                                        backgroundBrush = new LinearGradientBrush(backgroundRect, BackgroundColor, BackgroundColor2, GradientType);

                                        if (UseCustomGradient && CustomGradientList != null && CustomGradientList.Count > 1)
                                        {
                                            ColorBlend colorBlend = new ColorBlend();
                                            IEnumerable <GradientStop> gradient = CustomGradientList.OrderBy(x => x.Offset);
                                            colorBlend.Colors    = gradient.Select(x => x.Color).ToArray();
                                            colorBlend.Positions = gradient.Select(x => x.Offset).ToArray();
                                            ((LinearGradientBrush)backgroundBrush).InterpolationColors = colorBlend;
                                        }
                                    }
                                    else
                                    {
                                        backgroundBrush = new SolidBrush(BackgroundColor);
                                    }

                                    gWatermark.FillPath(backgroundBrush, backgroundPath);
                                }
                                finally
                                {
                                    if (backgroundBrush != null)
                                    {
                                        backgroundBrush.Dispose();
                                    }
                                }

                                using (Pen borderPen = new Pen(BorderColor))
                                {
                                    gWatermark.DrawPath(borderPen, backgroundPath);
                                }
                            }
                        }

                        gWatermark.TextRenderingHint = TextRenderingHint.AntiAliasGridFit;

                        using (StringFormat sf = new StringFormat {
                            Alignment = StringAlignment.Center, LineAlignment = StringAlignment.Center
                        })
                        {
                            float centerX = bmpWatermark.Width / 2f;
                            float centerY = bmpWatermark.Height / 2f;

                            if (DrawTextShadow)
                            {
                                using (Brush textShadowBrush = new SolidBrush(TextShadowColor))
                                {
                                    gWatermark.DrawString(parsedText, textFont, textShadowBrush,
                                                          centerX + TextShadowOffset.X, centerY + TextShadowOffset.Y, sf);
                                }
                            }

                            using (Brush textBrush = new SolidBrush(TextColor))
                            {
                                gWatermark.DrawString(parsedText, textFont, textBrush, centerX, centerY, sf);
                            }
                        }

                        using (Graphics gResult = Graphics.FromImage(img))
                        {
                            gResult.SetHighQuality();
                            gResult.DrawImage(bmpWatermark, watermarkRectangle);
                        }
                    }
            }

            return(img);
        }
Esempio n. 25
0
 public void NameParser_Parse_thows_exception_when_null_is_passed(string fullName)
 {
     var parser = new NameParser().Parse(fullName);
 }
Esempio n. 26
0
 private static IParser <ServiceAttributeInfo> AttributeParser(Context context) =>
 from name in NameParser.Named("attribute name")
 from parameters in AttributeParameterParser(context).Delimited(",").Bracketed("(", ")").OrDefault()
 select new ServiceAttributeInfo(name.Value, parameters,
                                 context.GetPart(ServicePartKind.Name, name));
Esempio n. 27
0
        public override Bitmap Apply(Bitmap bmp)
        {
            if (string.IsNullOrEmpty(Text))
            {
                return(bmp);
            }

            using (Font font = Font)
            {
                if (font == null || font.Size < 1)
                {
                    return(bmp);
                }

                NameParser parser = new NameParser(NameParserType.Text);
                parser.ImageWidth  = bmp.Width;
                parser.ImageHeight = bmp.Height;

                string parsedText = parser.Parse(Text);

                using (Graphics g = Graphics.FromImage(bmp))
                    using (GraphicsPath gp = new GraphicsPath())
                    {
                        g.SmoothingMode   = SmoothingMode.HighQuality;
                        g.PixelOffsetMode = PixelOffsetMode.Half;

                        gp.FillMode = FillMode.Winding;
                        float emSize = g.DpiY * font.SizeInPoints / 72;
                        gp.AddString(parsedText, font.FontFamily, (int)font.Style, emSize, Point.Empty, StringFormat.GenericDefault);

                        if (Angle != 0)
                        {
                            using (Matrix matrix = new Matrix())
                            {
                                matrix.Rotate(Angle);
                                gp.Transform(matrix);
                            }
                        }

                        RectangleF pathRect = gp.GetBounds();

                        if (pathRect.IsEmpty)
                        {
                            return(bmp);
                        }

                        Size      textSize      = pathRect.Size.ToSize().Offset(1);
                        Point     textPosition  = Helpers.GetPosition(Placement, Offset, bmp.Size, textSize);
                        Rectangle textRectangle = new Rectangle(textPosition, textSize);

                        if (AutoHide && !new Rectangle(0, 0, bmp.Width, bmp.Height).Contains(textRectangle))
                        {
                            return(bmp);
                        }

                        using (Matrix matrix = new Matrix())
                        {
                            matrix.Translate(textRectangle.X - pathRect.X, textRectangle.Y - pathRect.Y);
                            gp.Transform(matrix);
                        }

                        // Draw text shadow
                        if (Shadow && ((!ShadowUseGradient && ShadowColor.A > 0) || (ShadowUseGradient && ShadowGradient.IsVisible)))
                        {
                            using (Matrix matrix = new Matrix())
                            {
                                matrix.Translate(ShadowOffset.X, ShadowOffset.Y);
                                gp.Transform(matrix);

                                if (Outline && OutlineSize > 0)
                                {
                                    if (ShadowUseGradient)
                                    {
                                        using (LinearGradientBrush textShadowBrush = ShadowGradient.GetGradientBrush(
                                                   Rectangle.Round(textRectangle).Offset(OutlineSize + 1).LocationOffset(ShadowOffset)))
                                            using (Pen textShadowPen = new Pen(textShadowBrush, OutlineSize)
                                            {
                                                LineJoin = LineJoin.Round
                                            })
                                            {
                                                g.DrawPath(textShadowPen, gp);
                                            }
                                    }
                                    else
                                    {
                                        using (Pen textShadowPen = new Pen(ShadowColor, OutlineSize)
                                        {
                                            LineJoin = LineJoin.Round
                                        })
                                        {
                                            g.DrawPath(textShadowPen, gp);
                                        }
                                    }
                                }
                                else
                                {
                                    if (ShadowUseGradient)
                                    {
                                        using (Brush textShadowBrush = ShadowGradient.GetGradientBrush(
                                                   Rectangle.Round(textRectangle).Offset(1).LocationOffset(ShadowOffset)))
                                        {
                                            g.FillPath(textShadowBrush, gp);
                                        }
                                    }
                                    else
                                    {
                                        using (Brush textShadowBrush = new SolidBrush(ShadowColor))
                                        {
                                            g.FillPath(textShadowBrush, gp);
                                        }
                                    }
                                }

                                matrix.Reset();
                                matrix.Translate(-ShadowOffset.X, -ShadowOffset.Y);
                                gp.Transform(matrix);
                            }
                        }

                        // Draw text outline
                        if (Outline && OutlineSize > 0)
                        {
                            if (OutlineUseGradient)
                            {
                                if (OutlineGradient.IsVisible)
                                {
                                    using (LinearGradientBrush textOutlineBrush = OutlineGradient.GetGradientBrush(Rectangle.Round(textRectangle).Offset(OutlineSize + 1)))
                                        using (Pen textOutlinePen = new Pen(textOutlineBrush, OutlineSize)
                                        {
                                            LineJoin = LineJoin.Round
                                        })
                                        {
                                            g.DrawPath(textOutlinePen, gp);
                                        }
                                }
                            }
                            else if (OutlineColor.A > 0)
                            {
                                using (Pen textOutlinePen = new Pen(OutlineColor, OutlineSize)
                                {
                                    LineJoin = LineJoin.Round
                                })
                                {
                                    g.DrawPath(textOutlinePen, gp);
                                }
                            }
                        }

                        // Draw text
                        if (UseGradient)
                        {
                            if (Gradient.IsVisible)
                            {
                                using (Brush textBrush = Gradient.GetGradientBrush(Rectangle.Round(textRectangle).Offset(1)))
                                {
                                    g.FillPath(textBrush, gp);
                                }
                            }
                        }
                        else if (Color.A > 0)
                        {
                            using (Brush textBrush = new SolidBrush(Color))
                            {
                                g.FillPath(textBrush, gp);
                            }
                        }
                    }

                return(bmp);
            }
        }
Esempio n. 28
0
        public void it_returns_two_strings_when_parsing_a_words_using_pascal_case()
        {
            string result = NameParser.Parse("FooBar");

            result.Should().Be("Foo Bar");
        }
Esempio n. 29
0
 public string GetHttpHomePath()
 {
     return(NameParser.Parse(NameParserType.URL, HttpHomePath.Replace("%host", Host)));
 }