public override Task OnNavigatedToAsync(object parameter, NavigationMode mode, IDictionary <string, object> state)
{
if (parameter is long chatId)
{
var chat = CacheService.GetChat(chatId);
if (chat == null)
{
return(Task.CompletedTask);
}
var user = CacheService.GetUser(chat);
if (user == null)
{
return(Task.CompletedTask);
}
Items = new ItemsCollection(ProtoService, user.Id);
RaisePropertyChanged(() => Items);
}
else if (parameter is int userId)
{
Items = new ItemsCollection(ProtoService, userId);
RaisePropertyChanged(() => Items);
}
return(Task.CompletedTask);
}
public void Add()
{
var xmlDoc = new XmlDocument(TestUtility.CreateDefaultNSM().NameTable);
xmlDoc.LoadXml(
$@"<rowItems xmlns=""http://schemas.openxmlformats.org/spreadsheetml/2006/main"" count=""3"">
<i>
<x v=""1""/>
</i>
<i r=""1"">
<x v=""2""/>
</i>
<i r=""1"">
<x v=""3""/>
</i>
</rowItems>" );
var node = xmlDoc.FirstChild;
var itemsCollection = new ItemsCollection(TestUtility.CreateDefaultNSM(), node);
itemsCollection.Add(5, 3);
Assert.AreEqual(4, itemsCollection.Count);
Assert.AreEqual(4, node.ChildNodes.Count);
Assert.AreEqual(5, itemsCollection[3].RepeatedItemsCount);
Assert.AreEqual(1, itemsCollection[3].Count);
}
public CallsViewModel(IProtoService protoService, ICacheService cacheService, ISettingsService settingsService, IEventAggregator aggregator)
: base(protoService, cacheService, settingsService, aggregator)
{
Items = new ItemsCollection(protoService, cacheService);
CallDeleteCommand = new RelayCommand <TLCallGroup>(CallDeleteExecute);
}
protected override Task OnNavigatedToAsync(object parameter, NavigationMode mode, NavigationState state)
{
if (parameter is SettingsNotificationsExceptionsScope scope)
{
switch (scope)
{
case SettingsNotificationsExceptionsScope.PrivateChats:
Scope = new SettingsNotificationsScope(ProtoService, typeof(NotificationSettingsScopePrivateChats), Strings.Resources.NotificationsPrivateChats, Icons.Person);
Items = new ItemsCollection(ProtoService, new NotificationSettingsScopePrivateChats());
break;
case SettingsNotificationsExceptionsScope.GroupChats:
Scope = new SettingsNotificationsScope(ProtoService, typeof(NotificationSettingsScopeGroupChats), Strings.Resources.NotificationsGroups, Icons.People);
Items = new ItemsCollection(ProtoService, new NotificationSettingsScopeGroupChats());
break;
case SettingsNotificationsExceptionsScope.ChannelChats:
Scope = new SettingsNotificationsScope(ProtoService, typeof(NotificationSettingsScopeChannelChats), Strings.Resources.NotificationsChannels, Icons.Megaphone);
Items = new ItemsCollection(ProtoService, new NotificationSettingsScopeChannelChats());
break;
}
RaisePropertyChanged(nameof(Scope));
RaisePropertyChanged(nameof(Items));
Children.Add(Scope);
}
return(base.OnNavigatedToAsync(parameter, mode, state));
}
protected void RefreshItems()
{
if (ItemsCollection != null)
{
ItemsCollection.Refresh();
}
}
bool IList.Contains(object value)
{
TEntity _item = (TEntity)value;
int _ret = GetIndex(_item);
return(ItemsCollection.ContainsKey(_ret));
}
public SettingsEmojiSetView(IProtoService protoService, IEmojiSetService emojiSetService, IEventAggregator aggregator)
{
this.InitializeComponent();
_protoService = protoService;
_aggregator = aggregator;
Title = "Emoji Set";
PrimaryButtonText = Strings.Resources.OK;
SecondaryButtonText = Strings.Resources.Cancel;
#if DEBUG
CloseButtonText = "Reset";
CloseButtonClick += (s, args) =>
{
args.Cancel = true;
foreach (var item in List.ItemsSource as ItemsCollection)
{
if (item.IsOfficial)
{
continue;
}
_protoService.Send(new DeleteFileW(item.Document.Id));
_protoService.Send(new DeleteFileW(item.Thumbnail.Id));
}
};
#endif
_aggregator.Subscribe(this);
List.ItemsSource = _collection = new ItemsCollection(emojiSetService);
}
public ChatsViewModel(IProtoService protoService, ICacheService cacheService, ISettingsService settingsService, IEventAggregator aggregator, INotificationsService notificationsService, ChatList chatList, IChatFilter filter = null)
: base(protoService, cacheService, settingsService, aggregator)
{
_notificationsService = notificationsService;
_chatList = chatList;
Items = new ItemsCollection(protoService, aggregator, this, chatList, filter);
ChatPinCommand = new RelayCommand <Chat>(ChatPinExecute);
ChatArchiveCommand = new RelayCommand <Chat>(ChatArchiveExecute);
ChatMarkCommand = new RelayCommand <Chat>(ChatMarkExecute);
ChatNotifyCommand = new RelayCommand <Chat>(ChatNotifyExecute);
ChatDeleteCommand = new RelayCommand <Chat>(ChatDeleteExecute);
ChatClearCommand = new RelayCommand <Chat>(ChatClearExecute);
ChatSelectCommand = new RelayCommand <Chat>(ChatSelectExecute);
ChatsMarkCommand = new RelayCommand(ChatsMarkExecute);
ChatsNotifyCommand = new RelayCommand(ChatsNotifyExecute);
ChatsArchiveCommand = new RelayCommand(ChatsArchiveExecute);
ChatsDeleteCommand = new RelayCommand(ChatsDeleteExecute);
ChatsClearCommand = new RelayCommand(ChatsClearExecute);
ClearRecentChatsCommand = new RelayCommand(ClearRecentChatsExecute);
TopChatDeleteCommand = new RelayCommand <Chat>(TopChatDeleteExecute);
#if MOCKUP
Items.AddRange(protoService.GetChats(20));
#endif
SelectedItems = new MvxObservableCollection <Chat>();
}
protected void ChangeItemState(object param, CommunicationItemState state, bool isEditing)
{
if (param is CommunicationItemViewModel)
{
// if old state is Appended we have no to change it
if ((param as CommunicationItemViewModel).State == CommunicationItemState.Appended)
{
//if old state is Appended and new state Deleted then delete item
if (state == CommunicationItemState.Deleted)
{
Items.Remove((param as CommunicationItemViewModel));
}
}
else
{
(param as CommunicationItemViewModel).State = state;
}
(param as CommunicationItemViewModel).IsEditing = isEditing;
(param as CommunicationItemViewModel).RaiseCanExecuteChanged();
if (state == CommunicationItemState.Deleted)
{
RefreshItems();
}
if (isEditing)
{
ItemsCollection.MoveCurrentTo(param as CommunicationItemViewModel);
}
OnPropertyChanged("OneItemInCommunicationIsInEditState");
}
}
internal List <UndoRedoManager.RemoveCommand> Remove(bool isRegUndoRedo, bool isGetUndoredo)
{
List <UndoRedoManager.RemoveCommand> commands = null;
if (!IsRemove)
{
return(commands);
}
IsRomoving = true;
ViewItem fi = null;
if (FocusItem != null)
{
for (int i = FocusItem.Index - 1; i >= 0; i--)
{
if (ItemsCollection.GetViewItem(i) is ViewItem item && !item.Selected)
{
fi = item;
break;
}
}
}
commands = ItemsCollection.Remove(GetSelectList <object>(out int level), isRegUndoRedo || isGetUndoredo) as List <UndoRedoManager.RemoveCommand>;
int sindex = fi == null ? 0 : fi.Index + 1;
if (commands != null && isRegUndoRedo)
{
UndoRedoManager.RegistredNewCommand(commands);
}
SetFocus(sindex);
IsRomoving = false;
return(commands);
}
protected override Task OnNavigatedToAsync(object parameter, NavigationMode mode, NavigationState state)
{
if (parameter is long chatId)
{
var chat = CacheService.GetChat(chatId);
if (chat == null)
{
return(Task.CompletedTask);
}
var user = CacheService.GetUser(chat);
if (user == null)
{
return(Task.CompletedTask);
}
Items = new ItemsCollection(ProtoService, user.Id);
RaisePropertyChanged(nameof(Items));
}
else if (parameter is long userId)
{
Items = new ItemsCollection(ProtoService, userId);
RaisePropertyChanged(nameof(Items));
}
return(Task.CompletedTask);
}
public override Task OnNavigatedToAsync(object parameter, NavigationMode mode, IDictionary <string, object> state)
{
Item = null;
IsLoading = true;
var channel = parameter as TLChannel;
var peer = parameter as TLPeerChannel;
if (peer != null)
{
channel = CacheService.GetChat(peer.ChannelId) as TLChannel;
}
if (channel != null)
{
Item = channel;
Items = new ItemsCollection(ProtoService, this, channel);
Items.CollectionChanged += (s, args) => IsEmpty = Items.Count == 0;
RaisePropertyChanged(() => Items);
}
return(Task.CompletedTask);
}
public DataGridSampleWpf()
{
InitializeComponent();
DataContext = this;
Items = new ItemsCollection();
var options = new OptionList();
options.AddOption("Enabled", dataGrid, l => l.IsEnabled);
options.AddOption("Multiple Rows",
dataGrid, c => c.SelectionMode,
DataGridSelectionMode.Extended,
DataGridSelectionMode.Single);
options.AddOption("Full Row Select",
dataGrid, c => c.SelectionUnit,
DataGridSelectionUnit.FullRow,
DataGridSelectionUnit.CellOrRowHeader);
options.AddEnumOption("Grid Lines",
dataGrid, c => c.GridLinesVisibility);
options.AddEnumOption("Headers",
dataGrid, c => c.HeadersVisibility);
options.AddOption("Wide Row Header",
dataGrid, c => c.RowHeaderWidth,
25,
double.NaN);
options.AddOption("Frozen Columns", dataGrid, c => c.FrozenColumnCount);
options.AddOption("Row Details", dataGrid,
c => c.RowDetailsVisibilityMode,
DataGridRowDetailsVisibilityMode.Visible,
DataGridRowDetailsVisibilityMode.Collapsed);
Options = options;
}
private async void FiltersExecute()
{
var chat = _chat;
if (chat == null)
{
return;
}
var supergroup = CacheService.GetSupergroup(chat);
if (supergroup == null)
{
return;
}
var dialog = new SupergroupEventLogFiltersPopup();
var confirm = await dialog.ShowAsync(ProtoService, supergroup.Id, _filters, _userIds);
if (confirm == ContentDialogResult.Primary)
{
Filters = dialog.Filters;
UserIds = dialog.UserIds;
Items = new ItemsCollection(ProtoService, _messageFactory, this, chat.Id, supergroup.IsChannel, dialog.Filters, dialog.AreAllAdministratorsSelected ? new int[0] : dialog.UserIds);
RaisePropertyChanged(() => Items);
}
}
protected override void DeserializeCore(XmlElement nodeElement, SaveContext context)
{
base.DeserializeCore(nodeElement, context);
var wrapperName = nodeElement.ChildNodes.Cast <XmlNode>().FirstOrDefault(x => x.Name == "listWrapper_name");
var wrapperSelected = nodeElement.ChildNodes.Cast <XmlNode>().FirstOrDefault(x => x.Name == "listWrapper_selected");
var wrapperIndex = nodeElement.ChildNodes.Cast <XmlNode>().FirstOrDefault(x => x.Name == "listWrapper_index");
if (wrapperName == null || wrapperSelected == null || wrapperIndex == null)
{
return;
}
if (wrapperName.Attributes == null || wrapperName.Attributes.Count <= 0)
{
return;
}
if (wrapperSelected.Attributes == null || wrapperSelected.Attributes.Count <= 0)
{
return;
}
if (wrapperIndex.Attributes == null || wrapperIndex.Attributes.Count <= 0)
{
return;
}
for (var i = 0; i <= wrapperName.Attributes.Count - 1; i++)
{
var name = wrapperName.Attributes[i].Value;
var selected = wrapperSelected.Attributes[i].Value == "True";
var index = int.Parse(wrapperIndex.Attributes[i].Value);
var itemWrapper = new ListItemWrapper {
Name = name, IsSelected = selected, Index = index
};
ItemsCollection.Add(itemWrapper);
}
}
public void PopulateItems()
{
var e = GetInputElement();
if (e != null)
{
var items = new List <ParameterWrapper>();
// add instance parameters
items.AddRange(GetParameters(e, "Instance"));
// add type parameters
if (e.CanHaveTypeAssigned())
{
var et = DocumentManager.Instance.CurrentDBDocument.GetElement(e.GetTypeId());
if (et != null)
{
items.AddRange(GetParameters(et, "Type"));
}
}
ItemsCollection = new ObservableCollection <ParameterWrapper>(items.OrderBy(x => x.Name));
}
if (SelectedItem == null)
{
SelectedItem = ItemsCollection.FirstOrDefault();
}
}
public override Task OnNavigatedToAsync(object parameter, NavigationMode mode, NavigationState state)
{
if (parameter is int flags)
{
_type = (StickersType)flags;
}
if (_type is StickersType.Installed or StickersType.Masks)
{
Items = new ItemsCollection(ProtoService, _type == StickersType.Masks);
ProtoService.Send(new GetArchivedStickerSets(_type == StickersType.Masks, 0, 1), result =>
{
if (result is StickerSets stickerSets)
{
BeginOnUIThread(() => ArchivedStickersCount = stickerSets.TotalCount);
}
});
ProtoService.Send(new GetTrendingStickerSets(), result =>
{
if (result is StickerSets stickerSets)
{
BeginOnUIThread(() => FeaturedStickersCount = stickerSets.TotalCount);
}
});
}
public IA(ItemsCollection itemsCollection, LinesCollection linesCollection, Map map)
{
this.itemsCollection = itemsCollection;
this.linesCollection = linesCollection;
this.map = map;
ItemController itemPlayer = null;
ItemController itemEnemy = null;
ItemController itemNeutral = null;
foreach (ItemController item in itemsCollection.GetAllItemsController()) {
if (item.owner == 0) {
itemNeutral = item;
}
else if (item.owner == 1) {
itemPlayer = item;
}
else {
itemEnemy = item;
}
}
if (itemPlayer != null && itemEnemy != null)
{
gameController.MakeAShootAtB(itemPlayer, itemEnemy);
}
if (itemNeutral != null && itemEnemy != null)
{
gameController.MakeAShootAtB(itemEnemy, itemNeutral);
}
}
public SupplyCounter(UOObject container, List <UOItemTypeBase> types)
{
this.types = new List <UOItemTypeBase>();
if (!container.Serial.IsValid)
{
throw new ArgumentException("container");
}
this.container = container;
//this.type = type;
//this.color = color;
this.types.AddRange(types.ToArray());
if (container is UOItem)
{
collection = ((UOItem)container).AllItems;
}
else if (container is UOCharacter)
{
collection = ((UOCharacter)container).Layers;
if (Track)
{
Notepad.WriteLine("Layers " + ((UOCharacter)container).Layers.Count());
}
}
else
{
throw new ArgumentException("Invalid container type.");
}
container.Changed += new ObjectChangedEventHandler(container_Changed);
// Init count
Recalc();
}
public static IEnumerable <Item> filterSlot(ItemsCollection itemsCollection, string slot)
{
ItemsFilter filter = new ItemsFilter();
filter.Slots.Add(slot);
return(filter.filter(itemsCollection));
}
/// <summary>
/// Initializes a new instance of the <see cref="T:SupplyCounter"/> class.
/// </summary>
public SupplyCounter(UOObject container, Graphic type, UOColor color)
{
if (!container.Serial.IsValid)
{
throw new ArgumentException("container");
}
if (type.IsInvariant || type == 0)
{
throw new ArgumentOutOfRangeException("type");
}
this.container = container;
this.type = type;
this.color = color;
if (container is UOItem)
{
collection = ((UOItem)container).AllItems;
}
else if (container is UOCharacter)
{
collection = ((UOCharacter)container).Layers;
}
else
{
throw new ArgumentException("Invalid container type.");
}
container.Changed += new ObjectChangedEventHandler(container_Changed);
// Init count
Recalc();
}
/// <summary>
/// Updates the <see cref="Control"/>. This is called for every <see cref="Control"/>, even if it is disabled or
/// not visible.
/// </summary>
/// <param name="currentTime">The current time in milliseconds.</param>
protected override void UpdateControl(TickCount currentTime)
{
base.UpdateControl(currentTime);
if (!IsVisible)
{
return;
}
// Get the current item info
var currItemInfo = ItemsCollection.GetItemInfo(Slot);
// Check if the item info has changed and, if so, re-initialize the sprite
if (currItemInfo != _lastItemInfo)
{
ItemsCollection.PeerTradeForm.InitializeItemInfoSprite(_sprite, currItemInfo);
_lastItemInfo = currItemInfo;
}
// Update the sprite
if (_sprite.GrhData != null)
{
_sprite.Update(currentTime);
}
}
private void OnSearchTextTextChanged()
{
//Запоминаем какой Item выбран
var tmpSelectedItem = SelectedItem;
//Обнуляем счётчик отфильтрованных Item'ов
FiltredItemsCounter = 0;
CollectionViewSource.GetDefaultView(ItemsCollection).Filter = item =>
{
var tEntity = item as TEntity;
if (tEntity?.GetEntityMainPropertyValue() != null)
{
foreach (var filterWord in SearchText.ToLower().Split(_delimiterChars))
{
if (!tEntity.ToString().ToLower().Contains(filterWord.ToLower()))
{
return(false);
}
}
}
FiltredItemsCounter += 1;
if (FiltredItemsCounter == 1)
{
SelectedItem = tEntity;
}
return(true);
};
//RemoveSelectedButtonVisibility = SetVisibilityVisibleBasedOnSuggestListBox(FiltredItemsCounter);
if (FiltredItemsCounter == 1)
{
Messenger.Default.Send(new NotificationMessage(SelectedItem, typeof(TEntity).ToString()));
}
else if (FiltredItemsCounter > 1)
{
SelectedItem = ItemsCollection.FirstOrDefault(item => item == tmpSelectedItem);
}
else
{
SelectedItem = null;
}
if (SearchText.Length > 0)
{
//SuggestListBoxAndControlButtonsVisibility = Visibility.Visible;
}
else
{
//SuggestListBoxAndControlButtonsVisibility = Visibility.Collapsed;
SelectedItem = null;
}
}
/// <summary>
///
/// </summary>
/// <param name="combo"></param>
/// <returns></returns>
public object CreateGallery()
{
var g = PrimaryRibbonModel.CreateGallery();
ItemsCollection.Add(g);
return(g);
}
protected void AppendCommunicationItem(CommunicationItemViewModel item, bool isNew, bool isEditing)
{
if (item != null)
{
if (isNew)
{
item.State = CommunicationItemState.Appended;
item.IsEditing = isEditing;
item.AuthorId = _authorId;
item.AuthorName = _authorName;
item.LastModified = DateTime.Now.ToUniversalTime();
}
DefItemCommands(item);
item.RaiseCanExecuteChanged();
Items.Add(item);
if (isNew && ItemsCollection != null)
{
RefreshItems();
ItemsCollection.MoveCurrentToFirst();
}
item.CommunicationItemPropertyChanged += CommunicationItem_OnPropertyChanged;
OnPropertyChanged("OneItemInCommunicationIsInEditState");
OnPropertyChanged("Items");
OnPropertyChanged("IsShowEmpty");
ModifiedRequest();
}
}
private void Delete(object param)
{
commandBuffer.Add(new Helpers.CategoryCommand <InvoiceVatRate> {
CommandType = Helpers.CommandEnum.Remove, Item = SelectedItem
});
ItemsCollection.Remove(SelectedItem);
}
public override void execute(Data data)
{
ItemsCollection selectedItems;
if (!String.IsNullOrEmpty(ShopID))
{
GameData gameData = (GameData)data;
ItemsCollection items = gameData.ShopData[ShopID].ItemsAll;
selectedItems = items.getRandomItems(Count);
}
else
{
selectedItems = new ItemsCollection(new string[] { ItemID });
}
foreach (Item item in ((Dictionary <string, Item>)selectedItems).Values)
{
GameManager.Instance.PC.itemAdd(item);
if (Equip)
{
GameManager.Instance.PC.currentOutfit.addItem(item);
}
}
}
public MainViewPresenter(ItemsCollection items, MainView view)
{
this._items = items;
this._view = view;
this._view.Presenter = this;
}
public ItemsCollection getRandomItems(int count)
{
var result = new ItemsCollection();
if (Count <= count)
{
if (Count < count)
{
ErrorMessage.Show($"Requesting {count} items from {Count} available items");
}
return(new ItemsCollection(getItemDict().Values));
}
List <Item> possibleItems = getItemDict().Values.ToList();
for (int i = 0; i < count; i++)
{
int index = BER2.Util.Randomness.Random.Range(0, possibleItems.Count);
Item item = possibleItems[index];
result.addItem(item);
possibleItems.RemoveAt(index);
}
return(result);
}
private void SetupNewCharacher()
{
this.Unit.Unit.View.UpdateAsks();
this.Unit.BirthDay = this.BirthDay;
this.Unit.BirthMonth = this.BirthMonth;
if (this.Doll != null)
{
this.Unit.Doll = this.Doll.CreateData();
this.Unit.LeftHandedOverride = new bool?(this.Doll.LeftHanded);
}
if (this.State.Mode != LevelUpState.CharBuildMode.PreGen)
{
ItemsCollection.DoWithoutEvents(delegate
{
LevelUpHelper.AddStartingItems(this.Unit);
});
}
else
{
this.Unit.Body.Initialize();
}
this.Unit.AddStartingInventory();
foreach (Spellbook spellbook in this.Unit.Spellbooks)
{
spellbook.UpdateAllSlotsSize(true);
int num = spellbook.GetTotalFreeSlotsCount();
for (int i = 0; i < 100; i++)
{
if (num <= 0)
{
break;
}
foreach (BlueprintAbility blueprint in BlueprintRoot.Instance.Progression.CharGenMemorizeSpells)
{
AbilityData data = new AbilityData(blueprint, spellbook);
spellbook.Memorize(data, null);
}
int totalFreeSlotsCount = spellbook.GetTotalFreeSlotsCount();
if (num <= totalFreeSlotsCount)
{
break;
}
num = totalFreeSlotsCount;
}
}
RestController.ApplyRest(this.Unit);
if (this.Unit.IsCustomCompanion() && this.State.Mode != LevelUpState.CharBuildMode.Respec)
{
Game.Instance.EntityCreator.AddEntity(this.Unit.Unit, Game.Instance.Player.CrossSceneState);
Game.Instance.Player.RemoteCompanions.Add(this.Unit.Unit);
Game.Instance.Player.InvalidateCharacterLists();
this.Unit.Unit.IsInGame = false;
this.Unit.Unit.AttachToViewOnLoad(null);
if (this.Unit.Unit.View != null)
{
this.Unit.Unit.View.transform.SetParent(Game.Instance.DynamicRoot, true);
}
}
}
public SettingsBlockedChatsViewModel(IProtoService protoService, ICacheService cacheService, ISettingsService settingsService, IEventAggregator aggregator)
: base(protoService, cacheService, settingsService, aggregator)
{
Items = new ItemsCollection(protoService);
BlockCommand = new RelayCommand(BlockExecute);
UnblockCommand = new RelayCommand <MessageSender>(UnblockExecute);
}
protected internal void InitBin()
{
if (this.bin == null)
{
this.bin = new ItemsCollection<Observable>();
this.bin.AfterItemAdd += this.AfterBinItemAdd;
this.bin.AfterItemRemove += this.AfterItemRemove;
this.bin.SingleItemMode = false;
}
}
/**********************************************************/
/********************** CONSTRUCTORS **********************/
/**
* Instantiates, setups and positions all the necessary lines
*/
public LinesCollection(ItemsCollection itemsCollection)
{
GameObject lineObject, itemGameObjectI, itemGameObjectJ;
LineRenderer lineRenderer;
int collectionSize, position = 0;
if (itemsCollection == null) {
ErrorManager.DisplayErrorMessage("LineCollection: Cannot build LinesCollection from an empty ItemsCollection");
return;
}
referenceMatrix = new ReferenceMatrix (itemsCollection.GetCollectionSize ());
collectionSize = (itemsCollection.GetCollectionSize() * (itemsCollection.GetCollectionSize() - 1)) / 2;
this.tabLines = new LineController[collectionSize];
for (int i = 0; i < itemsCollection.GetCollectionSize(); i++) {
for (int j = 0; j < itemsCollection.GetCollectionSize(); j++) {
if (j > i) {
itemGameObjectI = itemsCollection.GetItemObject(i);
itemGameObjectJ = itemsCollection.GetItemObject(j);
lineObject = gameController.InstantiateLine();
lineRenderer = lineObject.GetComponent<LineRenderer>();
lineRenderer.SetPosition(0, new Vector3( itemGameObjectI.transform.position.x, 0, itemGameObjectI.transform.position.z));
lineRenderer.SetPosition(1, new Vector3(itemGameObjectJ.transform.position.x, 0, itemGameObjectJ.transform.position.z));
lineRenderer.SetWidth(0.1f, 0.1f);
tabLines[position] = lineObject.GetComponent<LineController>();
tabLines[position].Deactivate();
tabLines[position].SetOwnerOut(j);
tabLines[position].SetOwnerIn(i);
tabLines[position].SetStartPoint(new Vector3(itemGameObjectI.transform.position.x, 0, itemGameObjectI.transform.position.z));
tabLines[position].SetEndPoint(new Vector3(itemGameObjectJ.transform.position.x, 0, itemGameObjectJ.transform.position.z));
tabLines[position].ComputeConstants();
position++;
}
}
}
}
static World()
{
itemList = new Dictionary<uint, RealItem>(128);
charList = new Dictionary<uint, RealCharacter>(16);
ground = new ItemsCollection(0x00000000, false);
playerSerial = World.InvalidSerial;
uoplayer = new UOPlayer(World.InvalidSerial);
sunLight = 0xFF;
sunLightChanged = new DefaultPublicEvent();
cleanUpInterval = Config.InternalSettings.GetAttribute(5, "CleanUpInterval", "Config", "World");
cleanUpDistance = Config.InternalSettings.GetAttribute(30, "CleanUpDistance", "Config", "World");
cleanUpTimer = new Timer(new TimerCallback(CleanUpCallback), null, 10000, cleanUpInterval * 1000);
worldCleaned = new DefaultPublicEvent();
findDistance = Config.GroundFindDistance;
}
/// <summary>
/// Если контейнер не инициализирован, то на основании характеристик открывшего существа генерируется наполнение
/// </summary>
/// <param name = "_creature"></param>
/// <returns></returns>
public ItemsCollection GetItems(Creature _creature)
{
if (m_items == null)
{
m_items = new ItemsCollection();
foreach (var item in GenerateItems(_creature))
{
if (item is IFaked)
{
m_items.Add((Item) ((IFaked) item).Essence.Clone(_creature));
}
else
{
m_items.Add(item);
}
}
}
return m_items;
}
/// <summary>
/// Saves history to file.
/// </summary>
/// <param name="list">List of items.</param>
public static void Save(ItemsCollection list)
{
StringBuilder text = new StringBuilder();
try
{
if (!System.IO.Directory.Exists(EnvironmentVariables.ConfigPath))
System.IO.Directory.CreateDirectory(EnvironmentVariables.ConfigPath);
using (XmlTextWriter writer = new XmlTextWriter(EnvironmentVariables.ConfigPath + FileName, Encoding.UTF8))
{
writer.Formatting = Formatting.Indented;
writer.WriteProcessingInstruction ("xml", "version='1.0'");
writer.WriteStartElement("items");
foreach (Item i in list)
{
if (i.IsText)
{
text.Remove(0, text.Length);
text.Append(i.Text);
text.Replace("<", "<");
text.Replace(">", ">");
writer.WriteStartElement("item");
writer.WriteStartElement("text");
writer.WriteString(text.ToString());
writer.WriteEndElement();
writer.WriteEndElement();
}
}
writer.WriteEndElement();
writer.Close();
}
}
catch (Exception ex)
{
Tools.PrintInfo(ex, typeof(History));
}
}
public UOItem(uint serial)
: base(serial)
{
items = new ItemsCollection(serial, false);
allItems = new ItemsCollection(serial, true);
}
protected void InitItems()
{
if (this.items == null)
{
this.items = new ItemsCollection<AbstractComponent>();
this.items.BeforeItemAdd += this.BeforeItemAdd;
this.items.AfterItemAdd += this.AfterItemAdd;
this.items.AfterItemRemove += this.AfterItemRemove;
this.items.SingleItemMode = this.SingleItemMode;
}
}
/// <summary>
///
/// </summary>
/// <param name="contentControls"></param>
/// <param name="contentItems"></param>
protected virtual void PopulateItems(ControlCollection contentControls, ItemsCollection<AbstractComponent> contentItems)
{
foreach (Control control in contentControls)
{
AbstractComponent cmp = control as AbstractComponent;
if (cmp != null)
{
contentItems.Add(cmp);
cmp.ID = cmp.ID;
}
else if (control is ContentPlaceHolder || control is UserControl)
{
this.PopulateItems(control.Controls, contentItems);
}
else if(control is LiteralControl || control is Literal)
{
continue;
}
else
{
throw new Exception(string.Format(ServiceMessages.NON_LAYOUT_CONTROL, control.GetType().ToString()));
}
}
}
void Start()
{
itemsCollection = new ItemsCollection();
linesCollection = new LinesCollection (itemsCollection);
map = new Map (itemsCollection.GetCollectionSize ());
this.dragDropManager.SendMessage ("SetLines", this.linesCollection);
referenceMatrix = new ReferenceMatrix()
}
public MainPage()
{
InitializeComponent();
Items = new ItemsCollection();
}
/// <summary>
///
/// </summary>
protected internal void InitPlaceHolder()
{
if (this.placeHolder != null)
{
return;
}
this.placeHolder = new ItemsCollection<AbstractComponent>();
this.placeHolder.BeforeItemAdd += this.BeforeItemAdd;
this.placeHolder.AfterItemAdd += this.AfterItemAdd;
this.placeHolder.AfterItemRemove += this.AfterItemRemove;
this.placeHolder.SingleItemMode = true;
}
/// <summary>
///
/// </summary>
protected internal void InitDockedItems()
{
if (this.dockedItems != null)
{
return;
}
this.dockedItems = new ItemsCollection<AbstractComponent>();
this.dockedItems.BeforeItemAdd += this.BeforeItemAdd;
this.dockedItems.AfterItemAdd += this.AfterItemAdd;
this.dockedItems.AfterItemRemove += this.AfterItemRemove;
this.dockedItems.SingleItemMode = false;
}
private void __BuildControl__control16(ItemsCollection<AbstractComponent> __ctrl)
{
TextField field = this.__BuildControltxtUsername();
__ctrl.Add(field);
TextField field2 = this.__BuildControltxtPassword();
__ctrl.Add(field2);
TextField field3 = this.__BuildControltxtVerifyCode();
__ctrl.Add(field3);
Ext.Net.Image image = this.__BuildControlimgVerify();
__ctrl.Add(image);
DisplayField field4 = this.__BuildControl__control17();
__ctrl.Add(field4);
Ext.Net.LinkButton button = this.__BuildControlbtnChangeImage();
__ctrl.Add(button);
}
private void __BuildControl__control18(ItemsCollection<ButtonBase> __ctrl)
{
Ext.Net.Button button = this.__BuildControlbtnLogin();
__ctrl.Add(button);
}
private void __BuildControl__control12(ItemsCollection<AbstractComponent> __ctrl)
{
FormPanel panel = this.__BuildControl__control13();
__ctrl.Add(panel);
}
public Container(IDeclarationContext parent, string name)
: base(parent, name)
{
_variables = new VariableCollection(this);
_types = new ItemsCollection();
}
private void createSubMenu(ItemsCollection<Component> itemsCollection, DataTable dt, string p)
{
DataRow[] rows = dt.Select("parentid='" + p + "'");
foreach (DataRow row in rows) {
sysprog prog = ConvertHelper.RowToObject<sysprog>(row);
Ext.Net.MenuItem menu = new Ext.Net.MenuItem(prog.ProgName);
if (prog.IsGroup == "1") {
menu.Icon = Icon.Folder;
createSubMenu(menu.Menu, dt, prog.id);
} else {
menu.Icon = Icon.World;
//menu.ID = prog.id;
menu.Listeners.Click.Handler = "showmodule(#{MyDesktop},'" + prog.id + "');";
}
itemsCollection.Add(menu);
}
}
