private void SensorWatchOn()
{
NotifierHelper.Notify("Sensor.SensorWatchOn", "扫描监视");
while (true)
{
TimeSpan x = DateTime.Now - lastScanTime;
if (x.TotalMilliseconds > 6000)
{
if (Sr_status == SensorStatus.Scaning)
{
NotifierHelper.Notify("Sensor.ScanTimeOut", "扫描超时。");
{
SmartRayImageSource.Stop();
Sr_status = SensorStatus.Aborting;
Thread.Sleep(500);
SmartRayImageSource.ImageSource srIs = SmartRayImageSource as SmartRayImageSource.ImageSource;
srIs.ClearDatas();
SmartRayImageSource.SoftTrigger();
objScanState = ScanState.OVERTIME;
//Connection2.Send("OverTime");
NotifierHelper.Notify("ImageSource.SoftTriger");
}
}
break;
}
Thread.Sleep(100);
}
//watchOn.Abort();
NotifierHelper.Notify("Sensor.SensorWatchOnStop", "扫描监视结束");
}
protected void SetScanState(ScanState state, IScanSession scanSession)
{
scanState = state;
switch (state)
{
case ScanState.STOPPED:
if (scanSession != null)
{
scanSession.StopScanning();
}
else
{
picker.StopScanning();
}
break;
case ScanState.SCANNING:
if (HasCameraPermission())
{
picker.StartScanning();
}
else
{
RequestCameraPermission();
}
break;
}
}
/// <summary>
/// Parse using a state machine, does not use the call stack.
/// </summary>
public int Scan(Parser <TInput> parser, int start)
{
this.state = default(ScanState);
this.stackPosition = -1;
Push(parser, start);
while (true)
{
var nextParser = this.state.Parser.Accept(this);
if (nextParser != null)
{
Push(nextParser, inputStart: this.state.InputStart + this.state.InputLength);
}
else
{
var result = this.state.InputLength;
if (this.stackPosition == 0)
{
return(result);
}
else
{
Pop();
this.state.LastResult = result;
}
}
}
}
public DataAnnotationsTests()
{
var state = new ScanState();
var keyBuilder = new ResourceKeyBuilder(state);
var oldKeyBuilder = new OldResourceKeyBuilder(keyBuilder);
var ctx = new ConfigurationContext();
ctx.TypeFactory
.ForQuery <DetermineDefaultCulture.Query>().SetHandler <DetermineDefaultCulture.Handler>()
.ForQuery <GetTranslation.Query>().SetHandler <GetTranslationReturnResourceKeyHandler>();
var queryExecutor = new QueryExecutor(ctx);
var translationBuilder = new DiscoveredTranslationBuilder(queryExecutor);
_sut = new TypeDiscoveryHelper(new List <IResourceTypeScanner>
{
new LocalizedModelTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder),
new LocalizedResourceTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder),
new LocalizedEnumTypeScanner(keyBuilder, translationBuilder),
new LocalizedForeignResourceTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder)
}, ctx);
var expressHelper = new ExpressionHelper(keyBuilder);
_provider = new LocalizationProvider(keyBuilder, expressHelper, new FallbackLanguagesCollection(), queryExecutor);
}
public void NotInheritedModel_ContainsOnlyDeclaredProperties()
{
var state = new ScanState();
var keyBuilder = new ResourceKeyBuilder(state);
var oldKeyBuilder = new OldResourceKeyBuilder(keyBuilder);
var ctx = new ConfigurationContext();
ctx.TypeFactory.ForQuery <DetermineDefaultCulture.Query>().SetHandler <DetermineDefaultCulture.Handler>();
var queryExecutor = new QueryExecutor(ctx);
var translationBuilder = new DiscoveredTranslationBuilder(queryExecutor);
var sut = new TypeDiscoveryHelper(new List <IResourceTypeScanner>
{
new LocalizedModelTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder),
new LocalizedResourceTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder),
new LocalizedEnumTypeScanner(keyBuilder, translationBuilder),
new LocalizedForeignResourceTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder)
}, ctx);
var properties = sut.ScanResources(typeof(SampleViewModelWithBase)).ToList();
var keys = properties.Select(p => p.Key).ToList();
var stringLengthResource = properties.FirstOrDefault(r => r.Key == "DbLocalizationProvider.Tests.DataAnnotations.SampleViewModelWithBase.ChildProperty-StringLength");
Assert.Contains("DbLocalizationProvider.Tests.DataAnnotations.SampleViewModelWithBase.ChildProperty-Description", keys);
Assert.NotNull(stringLengthResource);
Assert.Contains("StringLength", stringLengthResource.Translations.DefaultTranslation());
Assert.DoesNotContain("DbLocalizationProvider.Tests.DataAnnotations.SampleViewModelWithBase.BaseProperty", keys);
Assert.DoesNotContain("DbLocalizationProvider.Tests.DataAnnotations.SampleViewModelWithBase.BaseProperty-Required", keys);
Assert.DoesNotContain("DbLocalizationProvider.Tests.DataAnnotations.SampleViewModelWithBase.ChildProperty-Description-Required", keys);
}
public void RunFullBlockTest()
{
var generator = new FullBlockTestGenerator(Network.Main);
ValidationState validation = new ValidationState(Network.Main);
validation.CheckMerkleRoot = false;
validation.CheckProofOfWork = false;
var scan =
new ScanState(new PubKeyHashScanner(generator.CoinbaseKey.PubKey.ID),
new Chain(),
new Account(),
0);
scan.CheckDoubleSpend = true;
var mainChain = new Chain(Network.Main);
var indexed = new IndexedBlockStore(new InMemoryNoSqlRepository(), CreateBlockStore());
indexed.Put(Network.Main.GetGenesis());
foreach (var test in generator.GetBlocksToTest(true, true).list.OfType <BlockAndValidity>())
{
indexed.Put(test.block);
mainChain.TrySetTip(test.block.Header);
Assert.True(scan.Process(mainChain, indexed) == test.connects);
//if(!)
//{
// Assert.True(test.throwsException);
//}
Assert.Equal(test.heightAfterBlock, scan.Chain.Height);
Assert.Equal(test.hashChainTipAfterBlock, scan.Chain.Tip.HashBlock);
mainChain.SetTip(scan.Chain.Tip);
}
}
public LocalizedResourceDiscoveryTests()
{
var state = new ScanState();
var keyBuilder = new ResourceKeyBuilder(state);
var oldKeyBuilder = new OldResourceKeyBuilder(keyBuilder);
var ctx = new ConfigurationContext();
ctx.TypeFactory.ForQuery <DetermineDefaultCulture.Query>().SetHandler <DetermineDefaultCulture.Handler>();
var queryExecutor = new QueryExecutor(ctx);
var translationBuilder = new DiscoveredTranslationBuilder(queryExecutor);
_sut = new TypeDiscoveryHelper(new List <IResourceTypeScanner>
{
new LocalizedModelTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder),
new LocalizedResourceTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder),
new LocalizedEnumTypeScanner(keyBuilder, translationBuilder),
new LocalizedForeignResourceTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder)
}, ctx);
_expressionHelper = new ExpressionHelper(keyBuilder);
_types = _sut.GetTypesWithAttribute <LocalizedResourceAttribute>().ToList();
Assert.NotEmpty(_types);
}
private void LateUpdate()
{
if (isActive)
{
bool flag = stateCurrent == ScanState.Scan;
if (idleTimer <= 0f)
{
OnHover();
}
SetFXActive(flag);
if (flag)
{
scanSound.Play();
}
else
{
scanSound.Stop();
}
stateLast = stateCurrent;
stateCurrent = ScanState.None;
}
}
private PDAScanner.Result Scan()
{
if (stateCurrent != ScanState.None)
{
return(PDAScanner.Result.None);
}
if (idleTimer > 0f)
{
return(PDAScanner.Result.None);
}
PDAScanner.Result result = PDAScanner.Result.None;
PDAScanner.ScanTarget scanTarget = PDAScanner.scanTarget;
PDAScanner.UpdateTarget(scanDistance, false);
if (scanTarget.isValid && energyMixin.charge > 0f)
{
result = PDAScanner.Scan();
if (result == PDAScanner.Result.Scan)
{
float amount = powerConsumption * Time.deltaTime;
energyMixin.ConsumeEnergy(amount);
stateCurrent = ScanState.Scan;
isScanning = true;
}
else if (result == PDAScanner.Result.Done || result == PDAScanner.Result.Researched)
{
idleTimer = 0.5f;
PDASounds.queue.PlayIfFree(completeSoundAsset);
}
}
return(result);
}
public LocalizedEnumTests()
{
var types = new[] { typeof(DocumentEntity) };
var state = new ScanState();
var keyBuilder = new ResourceKeyBuilder(state);
var oldKeyBuilder = new OldResourceKeyBuilder(keyBuilder);
var ctx = new ConfigurationContext();
ctx.TypeFactory.ForQuery <DetermineDefaultCulture.Query>().SetHandler <DetermineDefaultCulture.Handler>();
var queryExecutor = new QueryExecutor(ctx.TypeFactory);
var translationBuilder = new DiscoveredTranslationBuilder(queryExecutor);
_sut = new TypeDiscoveryHelper(new List <IResourceTypeScanner>
{
new LocalizedModelTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder),
new LocalizedResourceTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder),
new LocalizedEnumTypeScanner(keyBuilder, translationBuilder),
new LocalizedForeignResourceTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder)
}, ctx);
_expressionHelper = new ExpressionHelper(keyBuilder);
Assert.NotEmpty(types);
_properties = types.SelectMany(t => _sut.ScanResources(t));
}
public void HandlePotentialCallBlock(MethodCallBlock <Label> block, EnsuresBlock <Label> priorBlock)
{
if (block == null || this.state != ScanState.InsertingOld)
{
return;
}
int count = this.subroutine.SubroutineFacade.MetaDataProvider.Parameters(block.CalledMethod).Count;
if (!this.subroutine.SubroutineFacade.MetaDataProvider.IsStatic(block.CalledMethod))
{
++count;
}
if (count > 1)
{
this.state = ScanState.OutsideOld;
TypeNode mp = this.subroutine.SubroutineFacade.MetaDataProvider.ManagedPointer(this.next_end_old_type);
priorBlock.EndOldWithoutInstruction(mp);
}
else
{
this.state = ScanState.InsertingOldAfterCall;
this.next_end_old_type = this.subroutine.SubroutineFacade.MetaDataProvider.ReturnType(block.CalledMethod);
}
}
private void UpdateSum()
{
lock (this)
{
if (state != ScanState.SCANNING)
{
return;
}
size.Zero();
size.Add(allFilesSize);
size.folderCount += children.Count;
foreach (FolderInfo fi in children)
{
if (fi.size.childrenDenied)
{
size.childrenDenied = true;
}
else if (fi.State != ScanState.DONE)
{
return; // not ready yet!
}
size.Add(fi.Size);
}
state = ScanState.DONE;
stateChanged = true;
}
if (parent != null)
{
parent.UpdateSum();
}
}
void DecodeUpdate(object sender, EventArgs e)
{
ScanState scanState = e as ScanState;
float wr = MathF.Round((float)scanState.Done * 100 / (float)scanState.Total, 2);
lock (args)
{
args.Decoded = scanState.Done;
args.Done = wr;
args.Info = $"{scanState.Done}/{DSdata.DesktopStatus.NewReplays} ({wr}%), ETA: {scanState.ETA.ToString(@"hh\:mm\:ss")} - Running on {scanState.Threads + 1} Threads.";
args.inDB = scanState.DbDone;
if (scanState.End != DateTime.MinValue)
{
if (scanState.Done == scanState.Total)
{
wr = 100;
}
args.Info = $"{scanState.Done}/{scanState.Total} ({wr}%) - Elapsed Time: {(scanState.End - scanState.Start).ToString(@"hh\:mm\:ss")}";
if (_options.Decoding)
{
DecodeFinished();
}
}
}
OnDataLoaded(args);
}
public void SameModel_MultipleDefinitions_DoesNotThrowException()
{
var state = new ScanState();
var keyBuilder = new ResourceKeyBuilder(state);
var oldKeyBuilder = new OldResourceKeyBuilder(keyBuilder);
var ctx = new ConfigurationContext();
ctx.TypeFactory.ForQuery <DetermineDefaultCulture.Query>().SetHandler <DetermineDefaultCulture.Handler>();
var queryExecutor = new QueryExecutor(ctx.TypeFactory);
var translationBuilder = new DiscoveredTranslationBuilder(queryExecutor);
var sut = new TypeDiscoveryHelper(new List <IResourceTypeScanner>
{
new LocalizedModelTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder),
new LocalizedResourceTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder),
new LocalizedEnumTypeScanner(keyBuilder, translationBuilder),
new LocalizedForeignResourceTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder)
}, ctx);
var resources = sut.ScanResources(typeof(ViewModelWithDuplicateSubModels));
Assert.NotNull(resources);
var count = resources.Count(r => r.Key == "DbLocalizationProvider.Tests.SubModel.MyProperty-StringLength");
Assert.Equal(1, count);
}
void GrabDoneEvt(object sender, SapXferNotifyEventArgs evt)
{
Console.WriteLine("IN Evt");
switch (ScanStatus)
{
case ScanState.Stop:
ScanStatus = ScanState.Wait;
break;
case ScanState.Pause:
PauseProcess(LineCount);
break;
case ScanState.Start:
StartProcess();
break;
default:
evtRealimg(FnBuff2Img(Cam.GetBuffWH()["H"], Cam.GetBuffWH()["W"])(FullBuffdata(), 1));
var zscore = Idc.Zscore(SingleBuffdata().Cast <double>().ToArray <double>());
Task.Run(() => evtSV(Idc.Variance(zscore())()));
break;
}
}
void Update(int BuffCount, int UnitCount, int LineCount)
{
if (BuffCount == Info.BuffLimit)
{
ImgSrcByte = null;
ImgSrcByte = new byte[0];
BuffCount = 0;
if (UnitCount == Info.UnitLimit)
{
UnitCount = 0;
if (LineCount == Info.LineLimit)
{
ScanStatus = ScanState.Stop;
}
else
{
LineCount += 1;
ScanStatus = ScanState.Pause;
}
}
else
{
UnitCount += 1;
}
}
}
public void Test()
{
var state = new ScanState();
var keyBuilder = new ResourceKeyBuilder(state);
var oldKeyBuilder = new OldResourceKeyBuilder(keyBuilder);
var ctx = new ConfigurationContext();
ctx.TypeFactory.ForQuery <DetermineDefaultCulture.Query>().SetHandler <DetermineDefaultCulture.Handler>();
var queryExecutor = new QueryExecutor(ctx.TypeFactory);
var translationBuilder = new DiscoveredTranslationBuilder(queryExecutor);
var sut = new TypeDiscoveryHelper(new List <IResourceTypeScanner>
{
new LocalizedModelTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder),
new LocalizedResourceTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder),
new LocalizedEnumTypeScanner(keyBuilder, translationBuilder),
new LocalizedForeignResourceTypeScanner(keyBuilder, oldKeyBuilder, state, ctx, translationBuilder)
}, ctx);
var expressionHelper = new ExpressionHelper(keyBuilder);
var properties = new[] { typeof(SampleViewModelWithBaseNotInherit), typeof(BaseLocalizedViewModel) }
.Select(t => sut.ScanResources(t))
.ToList();
var childModel = new SampleViewModelWithBaseNotInherit();
var basePropertyKey = expressionHelper.GetFullMemberName(() => childModel.BaseProperty);
Assert.Equal("DbLocalizationProvider.Tests.InheritedModels.BaseLocalizedViewModel.BaseProperty", basePropertyKey);
}
// Marks the next multi-character token as starting at the current position
// then switches to the given state.
private Token StartToken(ScanState newState)
{
mTokenStart = mIndex;
mState = newState;
mBlockCommentDepth = 1;
return(null);
}
private bool TryFindOwner(ScanState suspect, out ScanState owner)
{
owner = state.FirstOrDefault(item => item.DataFile.Id != suspect.DataFile.Id &&
item.Used &&
item.DataFile.Size == suspect.DataFile.Size &&
item.DataFile.Hash == suspect.DataFile.Hash);
return(owner != null);
}
internal void ReloadScanner()
{
var old = _ScanState;
_ScanState = new ScanState(_ScanState.Scanner, _ScanState.Chain.Clone(),
_ScanState.Account.Clone(), ScanState.StartHeight);
old.Dispose();
}
private bool TryFindOwner(ScanState suspect, out ScanState owner)
{
owner = state.FirstOrDefault(item => item.DataFile.Id != suspect.DataFile.Id
&& item.Used
&& item.DataFile.Size == suspect.DataFile.Size
&& item.DataFile.Hash == suspect.DataFile.Hash);
return owner != null;
}
public void OnDisable()
{
scanSound.Stop();
isActive = false;
isToggle = false;
stateCurrent = ScanState.None;
SetInteractColor(Color.white);
SetProgressColor(Color.white);
}
public void OnDisable()
{
scanSound.Stop();
isActive = false;
toggle = false;
stateCurrent = ScanState.None;
Modules.SetInteractColor(Modules.Colors.White);
Modules.SetProgressColor(Modules.Colors.White);
}
private void Pop()
{
this.stackPosition--;
if (this.stackPosition >= 0)
{
this.state = this.stack[this.stackPosition];
}
}
public SizeNode(string displayName, string iconName, ScanState state, FolderSize size, Icon icon, string path)
{
this.displayName = displayName;
this.iconName = iconName;
this.state = state;
this.size = size;
this.icon = icon;
this.path = path;
if (icon == null) throw new ArgumentNullException();
}
private IEnumerator FinishScan()
{
_scanState = ScanState.Finished;
_scanFinished.Invoke();
if (_finishWaitDuration > 0)
{
yield return(new WaitForSeconds(_finishWaitDuration));
}
Finish();
}
public void OnDisable()
{
isActive = false;
isScanning = false;
scanSound.Stop();
SetFXActive(false);
stateCurrent = ScanState.None;
SetProgressColor(Colors.White);
SetInteractColor(Colors.White);
}
public override bool DefaultVisit(Label pc, int index)
{
if (this.state != ScanState.InsertingOld)
{
return(this.current_block.UsesOverriding);
}
this.state = ScanState.OutsideOld;
this.current_block.EndOldWithoutInstruction(this.subroutine.SubroutineFacade.MetaDataProvider.ManagedPointer(this.next_end_old_type));
return(true);
}
public override bool LoadField(Label pc, Field field, Dummy dest, Dummy obj, int data)
{
if (this.state != ScanState.InsertingOld)
{
return(this.current_block.UsesOverriding);
}
this.state = ScanState.OutsideOld;
this.current_block.EndOld(data, this.subroutine.SubroutineFacade.MetaDataProvider.FieldType(field));
return(false);
}
public void detectEmailOrUrl()
{
// scan forward from current ICU position for email address or URL
if (mLast >= mScanOffset)
{
ScanState state = ScanState.START;
int i = new int();
for (i = mLast; i < mTextSize; i++)
{
UInt16 c = mText[i];
// scan only ASCII characters, stop at space
if (!(' ' < c && c <= 0x007E))
{
break;
}
if (state == ScanState.START && c == '@')
{
state = ScanState.SAW_AT;
}
else if (state == ScanState.START && c == ':')
{
state = ScanState.SAW_COLON;
}
else if (state == ScanState.SAW_COLON || state == ScanState.SAW_COLON_SLASH)
{
if (c == '/')
{
state = (ScanState)((int)state + 1); // next state adds a slash
}
else
{
state = ScanState.START;
}
}
}
if (state == ScanState.SAW_AT || state == ScanState.SAW_COLON_SLASH_SLASH)
{
if (!mBreakIterator.isBoundary(i))
{
// If there are combining marks or such at the end of the URL or the
// email address, consider them a part of the URL or the email, and skip
// to the next actual boundary.
i = mBreakIterator.following(i);
}
mInEmailOrUrl = true;
mIteratorWasReset = true;
}
else
{
mInEmailOrUrl = false;
}
mScanOffset = i;
}
}
private void Push(Parser <TInput> parser, int inputStart)
{
this.stackPosition++;
if (this.stackPosition == this.stack.Count)
{
this.stack.Add(new ScanState());
}
this.state = this.stack[this.stackPosition];
this.state.Init(parser, inputStart);
}
/**
* This method should be called to activate the ongoing scanning for artworks.
*
* @param cachedMapping indicates whether cached mapping or live mapping was started
*/
public void EnterScanningMode(bool cachedMapping)
{
this.CurrentScanState = (cachedMapping) ? ScanState.Caching : ScanState.LiveScan;
#if ENABLE_WINMD_SUPPORT
if (this.CurrentScanState == ScanState.LiveScan)
{
// Choose processing method for live scanning
switch (this.liveScanProcessing)
{
case ImageProcessingMethod.FEATURE_MATCHING:
this.configuration.setProcessing(this.matchRecognition);
break;
case ImageProcessingMethod.IMAGE_HASHING:
this.configuration.setProcessing(this.hashRecognition);
break;
case ImageProcessingMethod.HYBRID_MATCHING:
this.configuration.setProcessing(this.hybridRecognition);
break;
default:
this.logger.Log("Image processing method not found.");
return;
}
}
else
{
// The processing method for cached scanning should always be feature matching
this.configuration.setProcessing(this.matchRecognition);
}
// Start Companion
this.RunCompanion();
// Add all artworks models to processing
foreach (Artwork artwork in this.artworks.Values)
{
int artworkID = artwork.artworkID;
if (this.IsIdEligible(artworkID))
{
this.matchRecognition.addModel(new CW.FeatureMatchingModel(artwork.localImagePath, artworkID));
this.hashRecognition.addModel(artwork.localImagePath, artworkID);
this.hybridRecognition.addModel(artwork.localImagePath, artworkID);
this.logger.Log("Artwork " + artworkID + " added to Companion.");
}
}
// Activate photo capture
this.capture.IsActive(true);
#endif
}
public override bool MoveToElement() {
switch (this.state) {
case ScanState.Attr:
case ScanState.AttrVal:
case ScanState.AttrValPseudoValue:
this.attrIndex = 0;
this.qnameOther = this.qnameElement;
if (XmlNodeType.Element == this.parentNodeType)
this.token = BinXmlToken.Element;
else if (XmlNodeType.XmlDeclaration == this.parentNodeType)
this.token = BinXmlToken.XmlDecl;
else if (XmlNodeType.DocumentType == this.parentNodeType)
this.token = BinXmlToken.DocType;
else
Debug.Fail("Unexpected parent NodeType");
this.nodetype = this.parentNodeType;
this.state = ScanState.Doc;
this.pos = this.posAfterAttrs;
this.stringValue = null;
return true;
case ScanState.XmlText:
return UpdateFromTextReader(this.textXmlReader.MoveToElement());
default:
return false;
}
}
public Nesting(ScanState scanState)
{
Levels = 0;
_scanState = scanState;
}
public void Update()
{
if (folderInfo == null) return;
this.size = folderInfo.Size;
this.state = folderInfo.State;
if (fileSummaries.Count == 0 && (folderInfo.State == ScanState.SCANNING || folderInfo.State == ScanState.DONE))
{
FillInFiles();
// If there are no files or directories below, load "them" immediately
// to remove the dummy node.
if (folderInfo.Children.Count == 0 && folderInfo.AllFilesSize.fileCount == 0)
{
LoadChildren();
}
}
}
private Exception ThrowNotSupported(string res)
{
_state = ScanState.Error;
return new NotSupportedException(res);
}
private void InitScanProcess()
{
// once completed reset to new beginning
switch (scanState)
{
case ScanState.Done:
scanState = ScanState.Initialized;
listViewStatus.Items.Clear();
SetButtonState();
return;
case ScanState.Initialized:
// common checks
TvBusinessLayer layer = new TvBusinessLayer();
Card card = layer.GetCardByDevicePath(RemoteControl.Instance.CardDevice(_cardNumber));
if (card.Enabled == false)
{
MessageBox.Show(this, "Tuner is disabled. Please enable the tuner before scanning.");
return;
}
if (!RemoteControl.Instance.CardPresent(card.IdCard))
{
MessageBox.Show(this, "Tuner is not found. Please make sure the tuner is present before scanning.");
return;
}
// Check if the card is locked for scanning.
IUser user;
if (RemoteControl.Instance.IsCardInUse(_cardNumber, out user))
{
MessageBox.Show(this,
"Tuner is locked. Scanning is not possible at the moment. Perhaps you are using another part of a hybrid card?");
return;
}
SetButtonState();
ShowActiveGroup(1); // force progess visible
// End common checks
listViewStatus.Items.Clear();
// Scan type dependent handling
_dvbcChannels.Clear();
switch (ActiveScanType)
{
// use tuning details from file
case ScanTypes.Predefined:
CustomFileName tuningFile = (CustomFileName)mpComboBoxRegion.SelectedItem;
_dvbcChannels = (List<DVBCTuning>)fileFilters.LoadList(tuningFile.FileName, typeof (List<DVBCTuning>));
if (_dvbcChannels == null)
{
_dvbcChannels = new List<DVBCTuning>();
}
break;
// scan Network Information Table for transponder info
case ScanTypes.NIT:
_dvbcChannels.Clear();
DVBCChannel tuneChannel = GetManualTuning();
listViewStatus.Items.Clear();
string line = String.Format("Scan freq:{0} {1} symbolrate:{2} ...", tuneChannel.Frequency,
tuneChannel.ModulationType, tuneChannel.SymbolRate);
ListViewItem item = listViewStatus.Items.Add(new ListViewItem(line));
item.EnsureVisible();
IChannel[] channels = RemoteControl.Instance.ScanNIT(_cardNumber, tuneChannel);
if (channels != null)
{
for (int i = 0; i < channels.Length; ++i)
{
DVBCChannel ch = (DVBCChannel)channels[i];
_dvbcChannels.Add(ch.TuningInfo);
item = listViewStatus.Items.Add(new ListViewItem(ch.TuningInfo.ToString()));
item.EnsureVisible();
}
}
ListViewItem lastItem =
listViewStatus.Items.Add(
new ListViewItem(String.Format("Scan done, found {0} transponders...", _dvbcChannels.Count)));
lastItem.EnsureVisible();
// automatically save list for re-use
SaveTransponderList();
break;
// scan only single inputted transponder
case ScanTypes.SingleTransponder:
DVBCChannel singleTuneChannel = GetManualTuning();
_dvbcChannels.Add(singleTuneChannel.TuningInfo);
break;
}
if (_dvbcChannels.Count != 0)
{
StartScanThread();
}
else
{
scanState = ScanState.Done;
SetButtonState();
}
break;
case ScanState.Scanning:
scanState = ScanState.Cancel;
SetButtonState();
break;
case ScanState.Cancel:
return;
}
}
public override bool Read() {
try {
switch (this.state) {
case ScanState.Init:
return ReadInit(false);
case ScanState.Doc:
return ReadDoc();
case ScanState.XmlText:
if (this.textXmlReader.Read()) {
return UpdateFromTextReader(true);
}
this.state = ScanState.Doc;
this.nodetype = XmlNodeType.None;
this.isEmpty = false;
goto case ScanState.Doc;
case ScanState.Attr:
case ScanState.AttrVal:
case ScanState.AttrValPseudoValue:
// clean up attribute stuff...
MoveToElement();
goto case ScanState.Doc;
default:
return false;
}
}
catch (OverflowException e) {
this.state = ScanState.Error;
throw new XmlException(e.Message, e);
}
catch {
this.state = ScanState.Error;
throw;
}
}
private void ImplReadXmlText()
{
this.CheckAllowContent();
string xmlFragment = this.ParseText();
XmlNamespaceManager nsMgr = new XmlNamespaceManager(this.xnt);
foreach (NamespaceDecl decl in this.namespaces.Values)
{
if (decl.scope > 0)
{
nsMgr.AddNamespace(decl.prefix, decl.uri);
}
}
XmlReaderSettings settings = this.Settings;
settings.ReadOnly = false;
settings.NameTable = this.xnt;
settings.DtdProcessing = DtdProcessing.Prohibit;
if (this.elemDepth != 0)
{
settings.ConformanceLevel = ConformanceLevel.Fragment;
}
settings.ReadOnly = true;
XmlParserContext context = new XmlParserContext(this.xnt, nsMgr, this.XmlLang, this.XmlSpace);
this.textXmlReader = new XmlTextReaderImpl(xmlFragment, context, settings);
if (!this.textXmlReader.Read() || ((this.textXmlReader.NodeType == XmlNodeType.XmlDeclaration) && !this.textXmlReader.Read()))
{
this.state = ScanState.Doc;
this.ReadDoc();
}
else
{
this.state = ScanState.XmlText;
this.UpdateFromTextReader();
}
}
bool ReadInit(bool skipXmlDecl) {
string err = null;
if (!sniffed) {
// check magic header
ushort magic = ReadUShort();
if (magic != 0xFFDF) {
err = Res.XmlBinary_InvalidSignature;
goto Error;
}
}
// check protocol version
this.version = ReadByte();
if (version != 0x1 && version != 0x2) {
err = Res.XmlBinary_InvalidProtocolVersion;
goto Error;
}
// check encoding marker, 1200 == utf16
if (1200 != ReadUShort()) {
err = Res.XmlBinary_UnsupportedCodePage;
goto Error;
}
this.state = ScanState.Doc;
if (BinXmlToken.XmlDecl == PeekToken()) {
this.pos++;
this.attributes[0].Set(new QName(string.Empty, this.xnt.Add("version"), string.Empty), ParseText());
this.attrCount = 1;
if (BinXmlToken.Encoding == PeekToken()) {
this.pos++;
this.attributes[1].Set(new QName(string.Empty, this.xnt.Add("encoding"), string.Empty), ParseText());
this.attrCount++;
}
byte standalone = ReadByte();
switch (standalone) {
case 0:
break;
case 1:
case 2:
this.attributes[this.attrCount].Set(new QName(string.Empty, this.xnt.Add("standalone"), string.Empty), (standalone == 1) ? "yes" : "no");
this.attrCount++;
break;
default:
err = Res.XmlBinary_InvalidStandalone;
goto Error;
}
if (!skipXmlDecl) {
QName xmlDeclQName = new QName(String.Empty, this.xnt.Add("xml"), String.Empty);
this.qnameOther = this.qnameElement = xmlDeclQName;
this.nodetype = XmlNodeType.XmlDeclaration;
this.posAfterAttrs = this.pos;
return true;
}
// else ReadDoc will clear the attributes for us
}
return ReadDoc();
Error:
this.state = ScanState.Error;
throw new XmlException(err, (string[])null);
}
bool ReadDoc() {
switch (this.nodetype) {
case XmlNodeType.CDATA:
FinishCDATA();
break;
case XmlNodeType.EndElement:
FinishEndElement();
break;
case XmlNodeType.Element:
if (this.isEmpty) {
FinishEndElement();
this.isEmpty = false;
}
break;
}
Read:
// clear existing state
this.nodetype = XmlNodeType.None;
this.mark = -1;
if (this.qnameOther.localname.Length != 0)
this.qnameOther.Clear();
ClearAttributes();
this.attrCount = 0;
this.valueType = TypeOfString;
this.stringValue = null;
this.hasTypedValue = false;
this.token = NextToken();
switch (this.token) {
case BinXmlToken.EOF:
if (this.elemDepth > 0)
throw new XmlException(Res.Xml_UnexpectedEOF1, (string[])null);
this.state = ScanState.EOF;
return false;
case BinXmlToken.Element:
ImplReadElement();
break;
case BinXmlToken.EndElem:
ImplReadEndElement();
break;
case BinXmlToken.DocType:
ImplReadDoctype();
if (this.dtdProcessing == DtdProcessing.Ignore)
goto Read;
// nested, don't report doctype
if (prevNameInfo != null)
goto Read;
break;
case BinXmlToken.PI:
ImplReadPI();
if (this.ignorePIs)
goto Read;
break;
case BinXmlToken.Comment:
ImplReadComment();
if (this.ignoreComments)
goto Read;
break;
case BinXmlToken.CData:
ImplReadCDATA();
break;
case BinXmlToken.Nest:
ImplReadNest();
// parse first token in nested document
sniffed = false;
return ReadInit(true);
case BinXmlToken.EndNest:
if (null == this.prevNameInfo)
goto default;
ImplReadEndNest();
return ReadDoc();
case BinXmlToken.XmlText:
ImplReadXmlText();
break;
// text values
case BinXmlToken.SQL_BIT:
case BinXmlToken.SQL_TINYINT:
case BinXmlToken.SQL_SMALLINT:
case BinXmlToken.SQL_INT:
case BinXmlToken.SQL_BIGINT:
case BinXmlToken.SQL_REAL:
case BinXmlToken.SQL_FLOAT:
case BinXmlToken.SQL_MONEY:
case BinXmlToken.SQL_SMALLMONEY:
case BinXmlToken.SQL_DATETIME:
case BinXmlToken.SQL_SMALLDATETIME:
case BinXmlToken.SQL_DECIMAL:
case BinXmlToken.SQL_NUMERIC:
case BinXmlToken.XSD_DECIMAL:
case BinXmlToken.SQL_UUID:
case BinXmlToken.SQL_VARBINARY:
case BinXmlToken.SQL_BINARY:
case BinXmlToken.SQL_IMAGE:
case BinXmlToken.SQL_UDT:
case BinXmlToken.XSD_KATMAI_DATE:
case BinXmlToken.XSD_KATMAI_DATETIME:
case BinXmlToken.XSD_KATMAI_TIME:
case BinXmlToken.XSD_KATMAI_DATEOFFSET:
case BinXmlToken.XSD_KATMAI_DATETIMEOFFSET:
case BinXmlToken.XSD_KATMAI_TIMEOFFSET:
case BinXmlToken.XSD_BINHEX:
case BinXmlToken.XSD_BASE64:
case BinXmlToken.SQL_CHAR:
case BinXmlToken.SQL_VARCHAR:
case BinXmlToken.SQL_TEXT:
case BinXmlToken.SQL_NCHAR:
case BinXmlToken.SQL_NVARCHAR:
case BinXmlToken.SQL_NTEXT:
case BinXmlToken.XSD_BOOLEAN:
case BinXmlToken.XSD_TIME:
case BinXmlToken.XSD_DATETIME:
case BinXmlToken.XSD_DATE:
case BinXmlToken.XSD_BYTE:
case BinXmlToken.XSD_UNSIGNEDSHORT:
case BinXmlToken.XSD_UNSIGNEDINT:
case BinXmlToken.XSD_UNSIGNEDLONG:
case BinXmlToken.XSD_QNAME:
ImplReadData(this.token);
if (XmlNodeType.Text == this.nodetype)
CheckAllowContent();
else if (this.ignoreWhitespace && !this.xmlspacePreserve)
goto Read; // skip to next token
return true;
default:
throw ThrowUnexpectedToken(token);
}
return true;
}
/// <summary>
/// Initialize with script.
/// </summary>
/// <param name="script"></param>
public void Init(string script)
{
this._scanner = new Scanner();
this._scanner.Init(script, '\\', new char[] { '\'', '"' }, new char[] { ' ', '\t' });
this.LAST_POSITION = this._scanner.LAST_POSITION;
this.State = this._scanner.State;
this.Scanner = this._scanner;
}
private void PositionOnAttribute(int i) {
// save element's qname
this.attrIndex = i;
this.qnameOther = this.attributes[i - 1].name;
if (this.state == ScanState.Doc) {
this.parentNodeType = this.nodetype;
}
this.token = BinXmlToken.Attr;
this.nodetype = XmlNodeType.Attribute;
this.state = ScanState.Attr;
this.valueType = TypeOfObject;
this.stringValue = null;
}
public override bool ReadAttributeValue()
{
this.stringValue = null;
switch (this.state)
{
case ScanState.XmlText:
return this.UpdateFromTextReader(this.textXmlReader.ReadAttributeValue());
case ScanState.Attr:
{
if (this.attributes[this.attrIndex - 1].val != null)
{
this.token = BinXmlToken.Error;
this.valueType = TypeOfString;
this.state = ScanState.AttrValPseudoValue;
break;
}
this.pos = this.attributes[this.attrIndex - 1].contentPos;
BinXmlToken token = this.RescanNextToken();
if ((BinXmlToken.Attr != token) && (BinXmlToken.EndAttrs != token))
{
this.token = token;
this.ReScanOverValue(token);
this.valueType = this.GetValueType(token);
this.state = ScanState.AttrVal;
break;
}
return false;
}
case ScanState.AttrVal:
return false;
default:
return false;
}
this.qnameOther.Clear();
this.nodetype = XmlNodeType.Text;
return true;
}
private bool ReadDoc()
{
switch (this.nodetype)
{
case XmlNodeType.Element:
if (this.isEmpty)
{
this.FinishEndElement();
this.isEmpty = false;
}
break;
case XmlNodeType.CDATA:
this.FinishCDATA();
break;
case XmlNodeType.EndElement:
this.FinishEndElement();
break;
}
Label_003B:
this.nodetype = XmlNodeType.None;
this.mark = -1;
if (this.qnameOther.localname.Length != 0)
{
this.qnameOther.Clear();
}
this.ClearAttributes();
this.attrCount = 0;
this.valueType = TypeOfString;
this.stringValue = null;
this.hasTypedValue = false;
this.token = this.NextToken();
switch (this.token)
{
case BinXmlToken.EOF:
if (this.elemDepth > 0)
{
throw new XmlException("Xml_UnexpectedEOF1", null);
}
this.state = ScanState.EOF;
return false;
case BinXmlToken.SQL_SMALLINT:
case BinXmlToken.SQL_INT:
case BinXmlToken.SQL_REAL:
case BinXmlToken.SQL_FLOAT:
case BinXmlToken.SQL_MONEY:
case BinXmlToken.SQL_BIT:
case BinXmlToken.SQL_TINYINT:
case BinXmlToken.SQL_BIGINT:
case BinXmlToken.SQL_UUID:
case BinXmlToken.SQL_DECIMAL:
case BinXmlToken.SQL_NUMERIC:
case BinXmlToken.SQL_BINARY:
case BinXmlToken.SQL_CHAR:
case BinXmlToken.SQL_NCHAR:
case BinXmlToken.SQL_VARBINARY:
case BinXmlToken.SQL_VARCHAR:
case BinXmlToken.SQL_NVARCHAR:
case BinXmlToken.SQL_DATETIME:
case BinXmlToken.SQL_SMALLDATETIME:
case BinXmlToken.SQL_SMALLMONEY:
case BinXmlToken.SQL_TEXT:
case BinXmlToken.SQL_IMAGE:
case BinXmlToken.SQL_NTEXT:
case BinXmlToken.SQL_UDT:
case BinXmlToken.XSD_KATMAI_TIMEOFFSET:
case BinXmlToken.XSD_KATMAI_DATETIMEOFFSET:
case BinXmlToken.XSD_KATMAI_DATEOFFSET:
case BinXmlToken.XSD_KATMAI_TIME:
case BinXmlToken.XSD_KATMAI_DATETIME:
case BinXmlToken.XSD_KATMAI_DATE:
case BinXmlToken.XSD_TIME:
case BinXmlToken.XSD_DATETIME:
case BinXmlToken.XSD_DATE:
case BinXmlToken.XSD_BINHEX:
case BinXmlToken.XSD_BASE64:
case BinXmlToken.XSD_BOOLEAN:
case BinXmlToken.XSD_DECIMAL:
case BinXmlToken.XSD_BYTE:
case BinXmlToken.XSD_UNSIGNEDSHORT:
case BinXmlToken.XSD_UNSIGNEDINT:
case BinXmlToken.XSD_UNSIGNEDLONG:
case BinXmlToken.XSD_QNAME:
this.ImplReadData(this.token);
if (XmlNodeType.Text == this.nodetype)
{
this.CheckAllowContent();
}
else if (this.ignoreWhitespace && !this.xmlspacePreserve)
{
goto Label_003B;
}
return true;
case BinXmlToken.EndNest:
if (this.prevNameInfo == null)
{
break;
}
this.ImplReadEndNest();
return this.ReadDoc();
case BinXmlToken.Nest:
this.ImplReadNest();
this.sniffed = false;
return this.ReadInit(true);
case BinXmlToken.XmlText:
this.ImplReadXmlText();
goto Label_02C9;
case BinXmlToken.CData:
this.ImplReadCDATA();
goto Label_02C9;
case BinXmlToken.Comment:
this.ImplReadComment();
if (!this.ignoreComments)
{
goto Label_02C9;
}
goto Label_003B;
case BinXmlToken.PI:
this.ImplReadPI();
if (!this.ignorePIs)
{
goto Label_02C9;
}
goto Label_003B;
case BinXmlToken.EndElem:
this.ImplReadEndElement();
goto Label_02C9;
case BinXmlToken.Element:
this.ImplReadElement();
goto Label_02C9;
case BinXmlToken.DocType:
this.ImplReadDoctype();
if ((this.dtdProcessing != DtdProcessing.Ignore) && (this.prevNameInfo == null))
{
goto Label_02C9;
}
goto Label_003B;
}
throw this.ThrowUnexpectedToken(this.token);
Label_02C9:
return true;
}
private bool ReadInit(bool skipXmlDecl)
{
string res = null;
if (!this.sniffed && (this.ReadUShort() != 0xffdf))
{
res = "XmlBinary_InvalidSignature";
}
else
{
this.version = this.ReadByte();
if ((this.version != 1) && (this.version != 2))
{
res = "XmlBinary_InvalidProtocolVersion";
}
else if (0x4b0 != this.ReadUShort())
{
res = "XmlBinary_UnsupportedCodePage";
}
else
{
this.state = ScanState.Doc;
if (BinXmlToken.XmlDecl != this.PeekToken())
{
goto Label_01EE;
}
this.pos++;
this.attributes[0].Set(new QName(string.Empty, this.xnt.Add("version"), string.Empty), this.ParseText());
this.attrCount = 1;
if (BinXmlToken.Encoding == this.PeekToken())
{
this.pos++;
this.attributes[1].Set(new QName(string.Empty, this.xnt.Add("encoding"), string.Empty), this.ParseText());
this.attrCount++;
}
byte num2 = this.ReadByte();
switch (num2)
{
case 0:
goto Label_01A2;
case 1:
case 2:
this.attributes[this.attrCount].Set(new QName(string.Empty, this.xnt.Add("standalone"), string.Empty), (num2 == 1) ? "yes" : "no");
this.attrCount++;
goto Label_01A2;
}
res = "XmlBinary_InvalidStandalone";
}
}
this.state = ScanState.Error;
throw new XmlException(res, null);
Label_01A2:
if (!skipXmlDecl)
{
QName name = new QName(string.Empty, this.xnt.Add("xml"), string.Empty);
this.qnameOther = this.qnameElement = name;
this.nodetype = XmlNodeType.XmlDeclaration;
this.posAfterAttrs = this.pos;
return true;
}
Label_01EE:
return this.ReadDoc();
}
public override bool ReadAttributeValue() {
this.stringValue = null;
switch (this.state) {
case ScanState.Attr:
if (null == this.attributes[this.attrIndex - 1].val) {
this.pos = this.attributes[this.attrIndex - 1].contentPos;
BinXmlToken tok = RescanNextToken();
if (BinXmlToken.Attr == tok || BinXmlToken.EndAttrs == tok) {
return false;
}
this.token = tok;
ReScanOverValue(tok);
this.valueType = GetValueType(tok);
this.state = ScanState.AttrVal;
}
else {
this.token = BinXmlToken.Error;
this.valueType = TypeOfString;
this.state = ScanState.AttrValPseudoValue;
}
this.qnameOther.Clear();
this.nodetype = XmlNodeType.Text;
return true;
case ScanState.AttrVal:
return false;
case ScanState.XmlText:
return UpdateFromTextReader(this.textXmlReader.ReadAttributeValue());
default:
return false;
}
}
void ImplReadXmlText() {
CheckAllowContent();
string xmltext = ParseText();
XmlNamespaceManager xnm = new XmlNamespaceManager(this.xnt);
foreach (NamespaceDecl decl in this.namespaces.Values) {
if (decl.scope > 0) {
#if DEBUG
if ((object)decl.prefix != (object)this.xnt.Get(decl.prefix))
throw new Exception("Prefix not interned: \'" + decl.prefix + "\'");
if ((object)decl.uri != (object)this.xnt.Get(decl.uri))
throw new Exception("Uri not interned: \'" + decl.uri + "\'");
#endif
xnm.AddNamespace(decl.prefix, decl.uri);
}
}
XmlReaderSettings settings = this.Settings;
settings.ReadOnly = false;
settings.NameTable = this.xnt;
settings.DtdProcessing = DtdProcessing.Prohibit;
if (0 != this.elemDepth) {
settings.ConformanceLevel = ConformanceLevel.Fragment;
}
settings.ReadOnly = true;
XmlParserContext xpc = new XmlParserContext(this.xnt, xnm, this.XmlLang, this.XmlSpace);
this.textXmlReader = new XmlTextReaderImpl(xmltext, xpc, settings);
if (!this.textXmlReader.Read()
|| ((this.textXmlReader.NodeType == XmlNodeType.XmlDeclaration)
&& !this.textXmlReader.Read())) {
this.state = ScanState.Doc;
ReadDoc();
}
else {
this.state = ScanState.XmlText;
UpdateFromTextReader();
}
}
public override void Close() {
this.state = ScanState.Closed;
this.nodetype = XmlNodeType.None;
this.token = BinXmlToken.Error;
this.stringValue = null;
if (null != this.textXmlReader) {
this.textXmlReader.Close();
this.textXmlReader = null;
}
if (null != this.inStrm && closeInput)
this.inStrm.Close();
this.inStrm = null;
this.pos = this.end = 0;
}
public XmlSqlBinaryReader(System.IO.Stream stream, byte[] data, int len, string baseUri, bool closeInput, XmlReaderSettings settings) {
unicode = System.Text.Encoding.Unicode;
xmlCharType = XmlCharType.Instance;
this.xnt = settings.NameTable;
if (this.xnt == null) {
this.xnt = new NameTable();
this.xntFromSettings = false;
}
else {
this.xntFromSettings = true;
}
this.xml = this.xnt.Add("xml");
this.xmlns = this.xnt.Add("xmlns");
this.nsxmlns = this.xnt.Add(XmlReservedNs.NsXmlNs);
this.baseUri = baseUri;
this.state = ScanState.Init;
this.nodetype = XmlNodeType.None;
this.token = BinXmlToken.Error;
this.elementStack = new ElemInfo[16];
//this.elemDepth = 0;
this.attributes = new AttrInfo[8];
this.attrHashTbl = new int[8];
//this.attrCount = 0;
//this.attrIndex = 0;
this.symbolTables.Init();
this.qnameOther.Clear();
this.qnameElement.Clear();
this.xmlspacePreserve = false;
this.hasher = new SecureStringHasher();
this.namespaces = new Dictionary<String, NamespaceDecl>(hasher);
AddInitNamespace(String.Empty, String.Empty);
AddInitNamespace(this.xml, this.xnt.Add(XmlReservedNs.NsXml));
AddInitNamespace(this.xmlns, this.nsxmlns);
this.valueType = TypeOfString;
// init buffer position, etc
this.inStrm = stream;
if (data != null) {
Debug.Assert(len >= 2 && (data[0] == 0xdf && data[1] == 0xff));
this.data = data;
this.end = len;
this.pos = 2;
this.sniffed = true;
}
else {
this.data = new byte[XmlReader.DefaultBufferSize];
this.end = stream.Read(this.data, 0, XmlReader.DefaultBufferSize);
this.pos = 0;
this.sniffed = false;
}
this.mark = -1;
this.eof = (0 == this.end);
this.offset = 0;
this.closeInput = closeInput;
switch (settings.ConformanceLevel) {
case ConformanceLevel.Auto:
this.docState = 0; break;
case ConformanceLevel.Fragment:
this.docState = 9; break;
case ConformanceLevel.Document:
this.docState = 1; break;
}
this.checkCharacters = settings.CheckCharacters;
this.dtdProcessing = settings.DtdProcessing;
this.ignoreWhitespace = settings.IgnoreWhitespace;
this.ignorePIs = settings.IgnoreProcessingInstructions;
this.ignoreComments = settings.IgnoreComments;
if (TokenTypeMap == null)
GenerateTokenTypeMap();
}
public override bool Read()
{
bool flag;
try
{
switch (this.state)
{
case ScanState.Doc:
break;
case ScanState.XmlText:
if (this.textXmlReader.Read())
{
return this.UpdateFromTextReader(true);
}
this.state = ScanState.Doc;
this.nodetype = XmlNodeType.None;
this.isEmpty = false;
break;
case ScanState.Attr:
case ScanState.AttrVal:
case ScanState.AttrValPseudoValue:
this.MoveToElement();
break;
case ScanState.Init:
return this.ReadInit(false);
default:
goto Label_0071;
}
return this.ReadDoc();
Label_0071:
flag = false;
}
catch (OverflowException exception)
{
this.state = ScanState.Error;
throw new XmlException(exception.Message, exception);
}
catch
{
this.state = ScanState.Error;
throw;
}
return flag;
}
string ValueAsString(BinXmlToken token) {
try {
CheckValueTokenBounds();
switch ( token ) {
case BinXmlToken.SQL_NCHAR:
case BinXmlToken.SQL_NVARCHAR:
case BinXmlToken.SQL_NTEXT:
return GetString( this.tokDataPos, this.tokLen );
case BinXmlToken.XSD_BOOLEAN: {
if ( 0 == this.data[this.tokDataPos] )
return "false";
else
return "true";
}
case BinXmlToken.SQL_BIT:
case BinXmlToken.SQL_TINYINT:
case BinXmlToken.SQL_SMALLINT:
case BinXmlToken.SQL_INT:
case BinXmlToken.SQL_BIGINT:
case BinXmlToken.XSD_BYTE:
case BinXmlToken.XSD_UNSIGNEDSHORT:
case BinXmlToken.XSD_UNSIGNEDINT:
return ValueAsLong().ToString( CultureInfo.InvariantCulture );
case BinXmlToken.XSD_UNSIGNEDLONG:
return ValueAsULong().ToString( CultureInfo.InvariantCulture );
case BinXmlToken.SQL_REAL:
return XmlConvert.ToString( GetSingle( this.tokDataPos ) );
case BinXmlToken.SQL_FLOAT:
return XmlConvert.ToString( GetDouble( this.tokDataPos ) );
case BinXmlToken.SQL_UUID: {
int a; short b, c;
int pos = this.tokDataPos;
a = GetInt32( pos );
b = GetInt16( pos + 4 );
c = GetInt16( pos + 6 );
Guid v = new Guid( a, b, c, data[pos + 8], data[pos + 9], data[pos + 10], data[pos + 11], data[pos + 12], data[pos + 13], data[pos + 14], data[pos + 15] );
return v.ToString();
}
case BinXmlToken.SQL_SMALLMONEY: {
BinXmlSqlMoney v = new BinXmlSqlMoney( GetInt32( this.tokDataPos ) );
return v.ToString();
}
case BinXmlToken.SQL_MONEY: {
BinXmlSqlMoney v = new BinXmlSqlMoney( GetInt64( this.tokDataPos ) );
return v.ToString();
}
case BinXmlToken.XSD_DECIMAL:
case BinXmlToken.SQL_DECIMAL:
case BinXmlToken.SQL_NUMERIC: {
BinXmlSqlDecimal v = new BinXmlSqlDecimal( this.data, this.tokDataPos, token == BinXmlToken.XSD_DECIMAL );
return v.ToString();
}
case BinXmlToken.SQL_CHAR:
case BinXmlToken.SQL_VARCHAR:
case BinXmlToken.SQL_TEXT: {
int pos = this.tokDataPos;
int codepage = GetInt32( pos );
Encoding enc = System.Text.Encoding.GetEncoding( codepage );
return enc.GetString( this.data, pos + 4, this.tokLen - 4 );
}
case BinXmlToken.SQL_VARBINARY:
case BinXmlToken.SQL_BINARY:
case BinXmlToken.SQL_IMAGE:
case BinXmlToken.SQL_UDT:
case BinXmlToken.XSD_BASE64: {
return Convert.ToBase64String( this.data, this.tokDataPos, this.tokLen );
}
case BinXmlToken.XSD_BINHEX:
return BinHexEncoder.Encode( this.data, this.tokDataPos, this.tokLen );
case BinXmlToken.SQL_DATETIME:
case BinXmlToken.SQL_SMALLDATETIME:
case BinXmlToken.XSD_TIME:
case BinXmlToken.XSD_DATE:
case BinXmlToken.XSD_DATETIME:
case BinXmlToken.XSD_KATMAI_DATE:
case BinXmlToken.XSD_KATMAI_DATETIME:
case BinXmlToken.XSD_KATMAI_TIME:
case BinXmlToken.XSD_KATMAI_DATEOFFSET:
case BinXmlToken.XSD_KATMAI_DATETIMEOFFSET:
case BinXmlToken.XSD_KATMAI_TIMEOFFSET:
return ValueAsDateTimeString();
case BinXmlToken.XSD_QNAME: {
int nameNum = ParseMB32( this.tokDataPos );
if ( nameNum < 0 || nameNum >= this.symbolTables.qnameCount )
throw new XmlException( Res.XmlBin_InvalidQNameID, String.Empty );
QName qname = this.symbolTables.qnametable[nameNum];
if ( qname.prefix.Length == 0 )
return qname.localname;
else
return String.Concat( qname.prefix, ":", qname.localname );
}
default:
throw ThrowUnexpectedToken( this.token );
}
}
catch {
this.state = ScanState.Error;
throw;
}
}
public override void Close()
{
_state = ScanState.Closed;
_nodetype = XmlNodeType.None;
_token = BinXmlToken.Error;
_stringValue = null;
if (null != _textXmlReader)
{
_textXmlReader.Close();
_textXmlReader = null;
}
if (null != _inStrm && _closeInput)
_inStrm.Dispose();
_inStrm = null;
_pos = _end = 0;
}
Exception ThrowXmlException(string res) {
this.state = ScanState.Error;
return new XmlException(res, (string[])null);
}
private void Init()
{
// set to same positions as progress
mpGrpAdvancedTuning.Top = mpGrpScanProgress.Top;
mpComboBoxCountry.Items.Clear();
try
{
fileFilters = new FileFilters("DVBC", ref mpComboBoxCountry, ref mpComboBoxRegion);
}
catch (Exception)
{
MessageBox.Show(@"Unable to open TuningParameters\dvbc\*.xml");
return;
}
SetButtonState();
SetDefaults();
buttonText = mpButtonScanTv.Text;
checkBoxCreateSignalGroup.Text = "Create \"" + TvConstants.TvGroupNames.DVBC + "\" group";
scanState = ScanState.Initialized;
}
public XmlSqlBinaryReader(Stream stream, byte[] data, int len, string baseUri, bool closeInput, XmlReaderSettings settings)
{
this.xnt = settings.NameTable;
if (this.xnt == null)
{
this.xnt = new System.Xml.NameTable();
this.xntFromSettings = false;
}
else
{
this.xntFromSettings = true;
}
this.xml = this.xnt.Add("xml");
this.xmlns = this.xnt.Add("xmlns");
this.nsxmlns = this.xnt.Add("http://www.w3.org/2000/xmlns/");
this.baseUri = baseUri;
this.state = ScanState.Init;
this.nodetype = XmlNodeType.None;
this.token = BinXmlToken.Error;
this.elementStack = new ElemInfo[0x10];
this.attributes = new AttrInfo[8];
this.attrHashTbl = new int[8];
this.symbolTables.Init();
this.qnameOther.Clear();
this.qnameElement.Clear();
this.xmlspacePreserve = false;
this.hasher = new SecureStringHasher();
this.namespaces = new Dictionary<string, NamespaceDecl>(this.hasher);
this.AddInitNamespace(string.Empty, string.Empty);
this.AddInitNamespace(this.xml, this.xnt.Add("http://www.w3.org/XML/1998/namespace"));
this.AddInitNamespace(this.xmlns, this.nsxmlns);
this.valueType = TypeOfString;
this.inStrm = stream;
if (data != null)
{
this.data = data;
this.end = len;
this.pos = 2;
this.sniffed = true;
}
else
{
this.data = new byte[0x1000];
this.end = stream.Read(this.data, 0, 0x1000);
this.pos = 0;
this.sniffed = false;
}
this.mark = -1;
this.eof = 0 == this.end;
this.offset = 0L;
this.closeInput = closeInput;
switch (settings.ConformanceLevel)
{
case ConformanceLevel.Auto:
this.docState = 0;
break;
case ConformanceLevel.Fragment:
this.docState = 9;
break;
case ConformanceLevel.Document:
this.docState = 1;
break;
}
this.checkCharacters = settings.CheckCharacters;
this.dtdProcessing = settings.DtdProcessing;
this.ignoreWhitespace = settings.IgnoreWhitespace;
this.ignorePIs = settings.IgnoreProcessingInstructions;
this.ignoreComments = settings.IgnoreComments;
if (TokenTypeMap == null)
{
this.GenerateTokenTypeMap();
}
}
/// <summary>
/// Scan Thread
/// </summary>
private void DoScan()
{
suminfo tv = new suminfo();
suminfo radio = new suminfo();
IUser user = new User();
user.CardId = _cardNumber;
try
{
scanState = ScanState.Scanning;
if (_dvbcChannels.Count == 0)
return;
RemoteControl.Instance.EpgGrabberEnabled = false;
SetButtonState();
TvBusinessLayer layer = new TvBusinessLayer();
Card card = layer.GetCardByDevicePath(RemoteControl.Instance.CardDevice(_cardNumber));
for (int index = 0; index < _dvbcChannels.Count; ++index)
{
if (scanState == ScanState.Cancel)
return;
float percent = ((float)(index)) / _dvbcChannels.Count;
percent *= 100f;
if (percent > 100f)
percent = 100f;
progressBar1.Value = (int)percent;
Application.DoEvents();
DVBCChannel tuneChannel = new DVBCChannel(_dvbcChannels[index]); // new DVBCChannel();
string line = String.Format("{0}tp- {1}", 1 + index, tuneChannel.TuningInfo.ToString());
ListViewItem item = listViewStatus.Items.Add(new ListViewItem(line));
item.EnsureVisible();
if (index == 0)
{
RemoteControl.Instance.Scan(ref user, tuneChannel, -1);
}
IChannel[] channels = RemoteControl.Instance.Scan(_cardNumber, tuneChannel);
UpdateStatus();
if (channels == null || channels.Length == 0)
{
if (RemoteControl.Instance.TunerLocked(_cardNumber) == false)
{
line = String.Format("{0}tp- {1} {2} {3}:No signal", 1 + index, tuneChannel.Frequency,
tuneChannel.ModulationType, tuneChannel.SymbolRate);
item.Text = line;
item.ForeColor = Color.Red;
continue;
}
line = String.Format("{0}tp- {1} {2} {3}:Nothing found", 1 + index, tuneChannel.Frequency,
tuneChannel.ModulationType, tuneChannel.SymbolRate);
item.Text = line;
item.ForeColor = Color.Red;
continue;
}
radio.newChannel = 0;
radio.updChannel = 0;
tv.newChannel = 0;
tv.updChannel = 0;
for (int i = 0; i < channels.Length; ++i)
{
Channel dbChannel;
DVBCChannel channel = (DVBCChannel)channels[i];
bool exists;
TuningDetail currentDetail;
//Check if we already have this tuningdetail. The user has the option to enable channel move detection...
if (checkBoxEnableChannelMoveDetection.Checked)
{
//According to the DVB specs ONID + SID is unique, therefore we do not need to use the TSID to identify a service.
//The DVB spec recommends that the SID should not change if a service moves. This theoretically allows us to
//track channel movements.
currentDetail = layer.GetTuningDetail(channel.NetworkId, channel.ServiceId,
TvBusinessLayer.GetChannelType(channel));
}
else
{
//There are certain providers that do not maintain unique ONID + SID combinations.
//In those cases, ONID + TSID + SID is generally unique. The consequence of using the TSID to identify
//a service is that channel movement tracking won't work (each transponder/mux should have its own TSID).
currentDetail = layer.GetTuningDetail(channel.NetworkId, channel.TransportId, channel.ServiceId,
TvBusinessLayer.GetChannelType(channel));
}
if (currentDetail == null)
{
//add new channel
exists = false;
dbChannel = layer.AddNewChannel(channel.Name);
dbChannel.SortOrder = 10000;
if (channel.LogicalChannelNumber >= 1)
{
dbChannel.SortOrder = channel.LogicalChannelNumber;
}
dbChannel.IsTv = channel.IsTv;
dbChannel.IsRadio = channel.IsRadio;
dbChannel.Persist();
}
else
{
exists = true;
dbChannel = currentDetail.ReferencedChannel();
}
if (dbChannel.IsTv)
{
layer.AddChannelToGroup(dbChannel, TvConstants.TvGroupNames.AllChannels);
if (checkBoxCreateSignalGroup.Checked)
{
layer.AddChannelToGroup(dbChannel, TvConstants.TvGroupNames.DVBC);
}
if (checkBoxCreateGroups.Checked)
{
layer.AddChannelToGroup(dbChannel, channel.Provider);
}
}
if (dbChannel.IsRadio)
{
layer.AddChannelToRadioGroup(dbChannel, TvConstants.RadioGroupNames.AllChannels);
if (checkBoxCreateSignalGroup.Checked)
{
layer.AddChannelToRadioGroup(dbChannel, TvConstants.RadioGroupNames.DVBC);
}
if (checkBoxCreateGroups.Checked)
{
layer.AddChannelToRadioGroup(dbChannel, channel.Provider);
}
}
if (currentDetail == null)
{
layer.AddTuningDetails(dbChannel, channel);
}
else
{
//update tuning details...
TuningDetail td = layer.UpdateTuningDetails(dbChannel, channel, currentDetail);
td.Persist();
}
if (channel.IsTv)
{
if (exists)
{
tv.updChannel++;
}
else
{
tv.newChannel++;
tv.newChannels.Add(channel);
}
}
if (channel.IsRadio)
{
if (exists)
{
radio.updChannel++;
}
else
{
radio.newChannel++;
radio.newChannels.Add(channel);
}
}
layer.MapChannelToCard(card, dbChannel, false);
line = String.Format("{0}tp- {1} {2} {3}:New TV/Radio:{4}/{5} Updated TV/Radio:{6}/{7}", 1 + index,
tuneChannel.Frequency, tuneChannel.ModulationType, tuneChannel.SymbolRate,
tv.newChannel, radio.newChannel, tv.updChannel, radio.updChannel);
item.Text = line;
}
tv.updChannelSum += tv.updChannel;
radio.updChannelSum += radio.updChannel;
}
}
catch (Exception ex)
{
Log.Write(ex);
}
finally
{
RemoteControl.Instance.StopCard(user);
RemoteControl.Instance.EpgGrabberEnabled = true;
progressBar1.Value = 100;
scanState = ScanState.Done;
SetButtonState();
}
listViewStatus.Items.Add(
new ListViewItem(String.Format("Total radio channels updated:{0}, new:{1}", radio.updChannelSum,
radio.newChannelSum)));
foreach (IChannel newChannel in radio.newChannels)
{
listViewStatus.Items.Add(new ListViewItem(String.Format(" -> new channel: {0}", newChannel.Name)));
}
listViewStatus.Items.Add(
new ListViewItem(String.Format("Total tv channels updated:{0}, new:{1}", tv.updChannelSum, tv.newChannelSum)));
foreach (IChannel newChannel in tv.newChannels)
{
listViewStatus.Items.Add(new ListViewItem(String.Format(" -> new channel: {0}", newChannel.Name)));
}
ListViewItem lastItem = listViewStatus.Items.Add(new ListViewItem("Scan done..."));
lastItem.EnsureVisible();
}
Exception ThrowNotSupported(string res) {
this.state = ScanState.Error;
return new NotSupportedException(Res.GetString(res));
}
// not currently used...
//Exception ThrowXmlException(string res, string arg1) {
// this.state = ScanState.Error;
// return new XmlException(res, new string[] {arg1} );
//}
Exception ThrowXmlException(string res, string arg1, string arg2) {
this.state = ScanState.Error;
return new XmlException(res, new string[] { arg1, arg2 });
}
private string ValueAsString(BinXmlToken token)
{
string str;
try
{
int num8;
this.CheckValueTokenBounds();
switch (token)
{
case BinXmlToken.SQL_SMALLINT:
case BinXmlToken.SQL_INT:
case BinXmlToken.SQL_BIT:
case BinXmlToken.SQL_TINYINT:
case BinXmlToken.SQL_BIGINT:
case BinXmlToken.XSD_BYTE:
case BinXmlToken.XSD_UNSIGNEDSHORT:
case BinXmlToken.XSD_UNSIGNEDINT:
return this.ValueAsLong().ToString(CultureInfo.InvariantCulture);
case BinXmlToken.SQL_REAL:
return XmlConvert.ToString(this.GetSingle(this.tokDataPos));
case BinXmlToken.SQL_FLOAT:
return XmlConvert.ToString(this.GetDouble(this.tokDataPos));
case BinXmlToken.SQL_MONEY:
{
BinXmlSqlMoney money2 = new BinXmlSqlMoney(this.GetInt64(this.tokDataPos));
return money2.ToString();
}
case BinXmlToken.SQL_UUID:
{
int tokDataPos = this.tokDataPos;
int a = this.GetInt32(tokDataPos);
short b = this.GetInt16(tokDataPos + 4);
short c = this.GetInt16(tokDataPos + 6);
Guid guid = new Guid(a, b, c, this.data[tokDataPos + 8], this.data[tokDataPos + 9], this.data[tokDataPos + 10], this.data[tokDataPos + 11], this.data[tokDataPos + 12], this.data[tokDataPos + 13], this.data[tokDataPos + 14], this.data[tokDataPos + 15]);
return guid.ToString();
}
case BinXmlToken.SQL_DECIMAL:
case BinXmlToken.SQL_NUMERIC:
case BinXmlToken.XSD_DECIMAL:
{
BinXmlSqlDecimal num5 = new BinXmlSqlDecimal(this.data, this.tokDataPos, token == BinXmlToken.XSD_DECIMAL);
return num5.ToString();
}
case BinXmlToken.SQL_BINARY:
case BinXmlToken.SQL_VARBINARY:
case BinXmlToken.SQL_IMAGE:
case BinXmlToken.SQL_UDT:
case BinXmlToken.XSD_BASE64:
return Convert.ToBase64String(this.data, this.tokDataPos, this.tokLen);
case BinXmlToken.SQL_CHAR:
case BinXmlToken.SQL_VARCHAR:
case BinXmlToken.SQL_TEXT:
{
int pos = this.tokDataPos;
return Encoding.GetEncoding(this.GetInt32(pos)).GetString(this.data, pos + 4, this.tokLen - 4);
}
case BinXmlToken.SQL_NCHAR:
case BinXmlToken.SQL_NVARCHAR:
case BinXmlToken.SQL_NTEXT:
return this.GetString(this.tokDataPos, this.tokLen);
case BinXmlToken.SQL_DATETIME:
case BinXmlToken.SQL_SMALLDATETIME:
case BinXmlToken.XSD_KATMAI_TIMEOFFSET:
case BinXmlToken.XSD_KATMAI_DATETIMEOFFSET:
case BinXmlToken.XSD_KATMAI_DATEOFFSET:
case BinXmlToken.XSD_KATMAI_TIME:
case BinXmlToken.XSD_KATMAI_DATETIME:
case BinXmlToken.XSD_KATMAI_DATE:
case BinXmlToken.XSD_TIME:
case BinXmlToken.XSD_DATETIME:
case BinXmlToken.XSD_DATE:
return this.ValueAsDateTimeString();
case BinXmlToken.SQL_SMALLMONEY:
{
BinXmlSqlMoney money = new BinXmlSqlMoney(this.GetInt32(this.tokDataPos));
return money.ToString();
}
case BinXmlToken.XSD_BINHEX:
return BinHexEncoder.Encode(this.data, this.tokDataPos, this.tokLen);
case BinXmlToken.XSD_BOOLEAN:
if (this.data[this.tokDataPos] != 0)
{
return "true";
}
return "false";
case BinXmlToken.XSD_UNSIGNEDLONG:
return this.ValueAsULong().ToString(CultureInfo.InvariantCulture);
case BinXmlToken.XSD_QNAME:
num8 = this.ParseMB32(this.tokDataPos);
if ((num8 < 0) || (num8 >= this.symbolTables.qnameCount))
{
throw new XmlException("XmlBin_InvalidQNameID", string.Empty);
}
break;
default:
throw this.ThrowUnexpectedToken(this.token);
}
QName name = this.symbolTables.qnametable[num8];
if (name.prefix.Length == 0)
{
return name.localname;
}
return (name.prefix + ":" + name.localname);
}
catch
{
this.state = ScanState.Error;
throw;
}
return str;
}
