private void MouseClickEnd(System.Windows.Input.MouseButtonEventArgs e)
{
if (designerItem.ParentID == Guid.Empty)//common widget
{
e.Handled = false;
designerItem.OnPageChildMouseUp();
bIsMousePressMove = false;
}
else//group children
{
e.Handled = false;
designerItem.OnGroupChildMouseUp();
bIsMousePressMove = false;
}
#region handle Hamburger Menu Eidtor
//shift/control key down, close hamburger menu edit UI
if ((Keyboard.Modifiers & (ModifierKeys.Shift | ModifierKeys.Control)) != ModifierKeys.None)
{
_selectionService.GetCurrentPage().CancelEditHamburgerPage();
}
else
{
//click hamburger, open edit hamburger menu edit UI.
WidgetViewModBase widgetVM = designerItem.DataContext as WidgetViewModBase;
if (widgetVM != null && widgetVM.Type == ObjectType.HamburgerMenu)
{
_selectionService.GetCurrentPage().EditHanburgerPage();
}
}
#endregion
return;
}
public Rect GetBoundingRect()
{
WidgetViewModBase VM = DataContext as WidgetViewModBase;
if (VM != null)
{
return(VM.GetBoundingRectangle());
}
return(new Rect(-1, -1, 0, 0));
}
private void EditListItemsCommandHandler(object obj)
{
WidgetViewModBase widgetVM = _selectionService.GetSelectedWidgets()[0] as WidgetViewModBase;
if (widgetVM is ListboxWidgetViewModel)
{
(widgetVM as ListboxWidgetViewModel).EditListItems();
}
else if (widgetVM is DroplistWidgetViewModel)
{
(widgetVM as DroplistWidgetViewModel).EditListItems();
}
}
public DeleteWidgetCommand(PageEditorViewModel pageVM, WidgetViewModBase widgetVM)
{
_pageVM = pageVM;
_widgetVM = widgetVM;
foreach (IPageView pageView in _pageVM.PageEditorModel.PageViews)
{
if (pageView.Widgets.Contains(_widgetVM.WidgetID))
{
_placedPageViewGuids.Add(pageView.Guid);
}
}
}
private void DefaultStyleCommandHandler(object obj)
{
List <IWidgetPropertyData> allSelects = _selectionService.GetSelectedWidgets();
if (allSelects.Count == 1)
{
WidgetViewModBase widgetVM = allSelects[0] as WidgetViewModBase;
if (widgetVM != null)
{
widgetVM.SetStyleAsDefaultStyle();
}
}
}
private void RotateThumb_DragStarted(object sender, DragStartedEventArgs e)
{
_infoItems.Clear();
if (this.designerItem == null)
{
return;
}
this.canvas = VisualTreeHelper.GetParent(VisualTreeHelper.GetParent(VisualTreeHelper.GetParent(this.designerItem))) as Canvas;
if (this.canvas == null)
{
return;
}
ContentPresenter wrapper = VisualTreeHelper.GetParent(VisualTreeHelper.GetParent(designerItem)) as ContentPresenter;
this.centerPoint = wrapper.TranslatePoint(
new Point(wrapper.ActualWidth * designerItem.RenderTransformOrigin.X,
wrapper.ActualHeight * designerItem.RenderTransformOrigin.Y),
this.canvas);
//this.centerPoint = wrapper.TranslatePoint(
// new Point(wrapper.ActualWidth/2,
// wrapper.ActualHeight/2),
// this.canvas);
Point startPoint = Mouse.GetPosition(this.canvas);
this.startVector = Point.Subtract(startPoint, this.centerPoint);
this.rotateTransform = designerItem.RenderTransform as RotateTransform;
if (this.rotateTransform == null)
{
designerItem.RenderTransform = new RotateTransform(0);
this.initialAngle = 0;
}
else
{
this.initialAngle = this.rotateTransform.Angle;
}
groupIntialAngle = 0;
if (this.designerItem.IsGroup == true)
{
WidgetViewModBase group = this.designerItem.DataContext as WidgetViewModBase;
groupCenterX = group.Left + group.ItemWidth / 2;
groupCenterY = group.Top + group.ItemHeight / 2;
}
}
private void DeselectOtherWidgets()
{
if (_pageVM != null)
{
foreach (IWidgetPropertyData widget in _pageVM.GetSelectedwidgets())
{
WidgetViewModBase widgetVM = widget as WidgetViewModBase;
if (widgetVM != null && widgetVM != _widgetVM)
{
widgetVM.IsSelected = false;
}
}
}
}
public DeleteWidgetInGroupSubCommand(PageEditorViewModel pageVM, WidgetViewModBase widgetVM)
{
_pageVM = pageVM;
_widgetVM = widgetVM;
_parentGroupInVM = _pageVM.PageEditorModel.Groups[widgetVM.ParentID];
_parentGroupInDOM = _widgetVM.WidgetModel.RealParentGroup;
foreach (IPageView pageView in _pageVM.PageEditorModel.PageViews)
{
if (pageView.Widgets.Contains(_widgetVM.WidgetID))
{
_placedPageViewGuids.Add(pageView.Guid);
}
}
}
public bool IsCanEditImage()
{
List <IWidgetPropertyData> wdgs = _selectionService.GetSelectedWidgets();
if (wdgs.Count != 1)
{
return(false);
}
WidgetViewModBase wdg = wdgs[0] as WidgetViewModBase;
if (wdg.Type == ObjectType.Image)
{
return(true);
}
return(false);
}
//public void RemoveWidgetFromDom(Guid wdgGID)
public void RemoveWidgetFromDom(WidgetViewModBase wdg)
{
if (_activeView == null)
{
return;
}
Guid wdgGID = wdg.widgetGID;
IsDirty = true;
if (wdg is MasterWidgetViewModel)
{
_activeView.DeleteMaster(wdgGID);
}
else
{
_activeView.DeleteWidget(wdgGID);
}
}
protected override void OnMouseLeftButtonUp(System.Windows.Input.MouseButtonEventArgs e)
{
base.OnMouseLeftButtonUp(e);
bIsMouseClicked = false;
if (adorner != null)
{
AdornerLayer adornerLayer = adorner.Parent as AdornerLayer;
if (adornerLayer != null)
{
adornerLayer.Remove(adorner);
}
}
if (designerItem == null)
{
return;
}
e.Handled = false;
//Cursor = Cursors.SizeAll;
//designerItem.IsStyleBrushModel = false;
if (designerItem == null)
{
return;
}
WidgetViewModBase wVM = designerItem.DataContext as WidgetViewModBase;
if (wVM == null)
{
return;
}
wVM.IsBrushModel = false;
if (bIsMousePressMove == false) //click
{
MouseClickEnd(e);
}
else//move
{
MouseDragEnd(e);
}
//IsCtrlPressed = false;
}
internal void CopyWidget(WidgetViewModBase wdgItem, bool bIsCut)
{
//implement copy operation
ISerializeWriter serializeWriter = _document.CreateSerializeWriter(_curAdaptiveViewGID);
wdgItem.WidgetModel.SerializeObject(serializeWriter);
Stream stream = serializeWriter.WriteToStream();
if (stream == null)
{
return;
}
//Clipboard operation
try
{
var data = new DataObject();
_copyTime = 0;
_copyGID = Guid.NewGuid();
data.SetData(@"ProtoNowCopyID", _copyGID);
data.SetData(@"ProtoNowAdaptiveID", _curAdaptiveViewGID);
data.SetData(@"ProtoNowWidgets", stream);
//Copy to Clipboard
Clipboard.Clear();
Clipboard.SetDataObject(data);
//Clipboard.SetDataObject(data, true);
//Reset Copy ID
if (bIsCut == true)
{
_copyGID = Guid.Empty;
}
}
catch (System.Exception ex)
{
Debug.WriteLine(ex.Message);
return;
}
}
public void WdgMgrDeleteSelection(List <Guid> list)
{
if (_busyIndicator.IsShow == true)
{
return;
}
List <WidgetViewModBase> DeleteList = new List <WidgetViewModBase>();
foreach (Guid id in list)
{
WidgetViewModBase widget = Items.FirstOrDefault(a => a.WidgetID == id);
if (widget != null)
{
DeleteList.Add(widget);
}
}
OnItemListDelete(DeleteList);
}
private void OnIsCtrlPressedChanged()
{
if (designerItem == null)
{
return;
}
WidgetViewModBase wVM = designerItem.DataContext as WidgetViewModBase;
if (wVM == null)
{
return;
}
if (IsCtrlPressed == true && Mouse.LeftButton == MouseButtonState.Pressed && bIsMouseClicked == true)
{
wVM.IsBrushModel = null;
}
else
{
wVM.IsBrushModel = false;
}
}
private void UpdateAddedMaster2Canvas(Guid masterPageGuid)
{
List <IRegion> masters = _model.QueryMaster(masterPageGuid);
if (masters == null || masters.Count < 1)
{
return;
}
foreach (IRegion master in masters)
{
var tar = items.FirstOrDefault(c => c.widgetGID == master.Guid);
if (tar != null)
{
continue;
}
WidgetViewModBase widgetVM = InsertWidget2Canvas(master, IsSelected);
if (widgetVM != null)
{
widgetVM.ParentPageVM = this;
}
}
}
override protected void OnItemRemoved(object obj)
{
if (obj == null)
{
List <WidgetViewModBase> ToRemoveList = new List <WidgetViewModBase>();
foreach (WidgetViewModBase wdgItem in Items)
{
if (wdgItem.IsSelected == true)
{
//Remove item from selection service
wdgItem.IsSelected = false;
//construct the widget list to be removed
ToRemoveList.Add(wdgItem);
}
}
foreach (WidgetViewModBase it in ToRemoveList)
{
Guid gid = it.widgetGID;
Items.Remove(it);
_model.RemoveWidgetFromDom(gid);
}
}
else
{
WidgetViewModBase wdgVM = obj as WidgetViewModBase;
if (wdgVM == null)
{
return;
}
Guid gid = wdgVM.widgetGID;
Items.Remove(wdgVM);
_model.RemoveWidgetFromDom(gid);
}
}
public void WdgMgrEditSelection()
{
if (_busyIndicator.IsShow == true)
{
return;
}
//TODO:
if (_selectionService.WidgetNumber != 1)
{
return;
}
WidgetViewModBase wdg = _selectionService.GetSelectedWidgets()[0] as WidgetViewModBase;
if (wdg == null || wdg is GroupViewModel)
{
return;
}
wdg.CanEdit = true;
//TODO:2015/09 edit mode for special
//wdg.type!=WidgetType.SVG
}
/// <summary>
/// Create menu when select one widget.
/// </summary>
private void MenuFor1Widget()
{
ContextMenu contextMenu = new ContextMenu();
contextMenu.IsOpen = true;
List <IWidgetPropertyData> wdgs = _selectionService.GetSelectedWidgets();
if (wdgs == null || wdgs.Count <= 0)
{
return;
}
WidgetViewModBase wdg = wdgs[0] as WidgetViewModBase;
if (wdg == null)
{
return;
}
if (wdg.IsGroup == true)
{
//TODO:Add Group context Menu
AddCopyPasete2Menu(contextMenu);
AddLibrary2Menu(contextMenu);
//Add master convert menu
GroupViewModel group = wdg as GroupViewModel;
var target = group.WidgetChildren.FirstOrDefault(a => a is MasterWidgetViewModel);
if (target == null)
{
AddConvertMaster2Menu(contextMenu);
}
AddUnplace2Menu(contextMenu);
AddUnGroup2Menu(contextMenu);
AddOrder2Menu(contextMenu);
}
else
{
IRegion selObject = ActivePage.WidgetsAndMasters[_selectionService.GetSelectedWidgetGUIDs()[0]];
if (selObject == null)
{
return;
}
if (selObject is IMaster)
{
AddCopyPasete2Menu(contextMenu);
AddExport2Menu(contextMenu);
AddLibrary2Menu(contextMenu);
AddUnplace2Menu(contextMenu);
if (wdg.RealParentGroupGID == Guid.Empty)
{
AddMasterOperationMenu(contextMenu, (wdg as MasterWidgetViewModel).IsLocked2MasterLocation);
}
else
{
AddMasterOperationMenu(contextMenu, (wdg as MasterWidgetViewModel).IsLocked2MasterLocation, true);
}
AddOrder2Menu(contextMenu, false);
}
else if (selObject is IWidget)
{
var widget = selObject as IWidget;
switch (widget.WidgetType)
{
case WidgetType.Image:
AddCopyPasete2Menu(contextMenu);
AddExport2Menu(contextMenu);
AddLibrary2Menu(contextMenu);
AddConvertMaster2Menu(contextMenu);
contextMenu.Items.Add(new ContextMenuItem(GlobalData.FindResource("ContextMenu_ImportImage"), ImportImageCommand));
contextMenu.Items.Add(new Separator());
AddUnplace2Menu(contextMenu);
AddTooltip2Menu(contextMenu);
AddOrder2Menu(contextMenu);
break;
case WidgetType.RadioButton:
case WidgetType.Checkbox:
case WidgetType.TextField:
case WidgetType.TextArea:
case WidgetType.Button:
case WidgetType.Shape:
AddCopyPasete2Menu(contextMenu);
AddExport2Menu(contextMenu);
AddLibrary2Menu(contextMenu);
AddConvertMaster2Menu(contextMenu);
AddEditText2Menu(contextMenu);
contextMenu.Items.Add(new Separator());
AddUnplace2Menu(contextMenu);
AddTooltip2Menu(contextMenu);
AddOrder2Menu(contextMenu);
AddDefaultstyleToMenu(contextMenu);
break;
case WidgetType.HotSpot:
case WidgetType.SVG:
AddCopyPasete2Menu(contextMenu);
AddExport2Menu(contextMenu);
AddLibrary2Menu(contextMenu);
AddConvertMaster2Menu(contextMenu);
AddUnplace2Menu(contextMenu);
AddTooltip2Menu(contextMenu);
AddOrder2Menu(contextMenu);
break;
case WidgetType.Line:
AddCopyPasete2Menu(contextMenu);
AddExport2Menu(contextMenu);
AddLibrary2Menu(contextMenu);
AddConvertMaster2Menu(contextMenu, false);
if (AdaptiveViewsList.Count > 1)
{
contextMenu.Items.Add(new Separator());
AddUnplace2Menu(contextMenu, false);
}
//AddTooltip2Menu(contextMenu);
AddOrder2Menu(contextMenu);
AddDefaultstyleToMenu(contextMenu);
break;
case WidgetType.ListBox:
case WidgetType.DropList:
AddCopyPasete2Menu(contextMenu, true);
AddExport2Menu(contextMenu);
AddEditItems2Menu(contextMenu);
contextMenu.Items.Add(new Separator());
AddLibrary2Menu(contextMenu);
AddConvertMaster2Menu(contextMenu);
AddUnplace2Menu(contextMenu);
AddTooltip2Menu(contextMenu);
AddOrder2Menu(contextMenu);
AddDefaultstyleToMenu(contextMenu);
break;
case WidgetType.Toast:
case WidgetType.DynamicPanel:
AddCopyPasete2Menu(contextMenu);
AddExport2Menu(contextMenu);
AddLibrary2Menu(contextMenu);
AddConvertMaster2Menu(contextMenu);
AddUnplace2Menu(contextMenu);
AddTooltip2Menu(contextMenu);
AddOrder2Menu(contextMenu);
break;
case WidgetType.HamburgerMenu:
AddCopyPasete2Menu(contextMenu);
AddExport2Menu(contextMenu);
AddLibrary2Menu(contextMenu);
AddConvertMaster2Menu(contextMenu, false);
contextMenu.Items.Add(new Separator());
contextMenu.Items.Add(new ContextMenuItem(GlobalData.FindResource("ContextMenu_ImportImage"), ImportImageCommand));
contextMenu.Items.Add(new Separator());
AddUnplace2Menu(contextMenu);
AddTooltip2Menu(contextMenu);
AddOrder2Menu(contextMenu);
break;
}
}
}
}
public bool ExportObj2Image()
{
if (1 != _selectionService.WidgetNumber)
{
return(false);
}
WidgetViewModBase wdg = _selectionService.GetSelectedWidgets()[0] as WidgetViewModBase;
if (wdg == null)
{
return(false);
}
try
{
DesignerCanvas layout = EditorCanvas as DesignerCanvas;
if (layout == null)
{
return(false);
}
BaseWidgetItem it = layout.SelectedItems.ToList <BaseWidgetItem>()[0];
if (it == null)
{
return(false);
}
RenderTargetBitmap bmp = new RenderTargetBitmap((int)it.ActualWidth, (int)it.ActualHeight, 96, 96, PixelFormats.Pbgra32);
bmp.Render(VisualTreeHelper.GetChild(it, 0) as Visual);
//show file save dialog
string imagFile = "";
SaveFileDialog saveFileDialog = new SaveFileDialog();
//saveFileDialog.Filter = "PNG File(*.png)|*.png|JPG File(*.jpg)|*.jpg|BMP File(*.bmp)|*.bmp|GIF File(*.gif)|*.gif|TIF File(*.tif)|*.tif";
saveFileDialog.Filter = "PNG File(*.png)|*.png";
saveFileDialog.FileName = wdg.Type.ToString() + "-" + wdg.WidgetID.ToString().Substring(0, 8);
if (saveFileDialog.ShowDialog() == true)
{
imagFile = saveFileDialog.FileName;
}
else
{
return(false);
}
//export image
string extensionString = Path.GetExtension(imagFile);
BitmapEncoder encoder = null;
switch (extensionString)
{
case ".jpg":
encoder = new JpegBitmapEncoder();
break;
case ".png":
encoder = new PngBitmapEncoder();
break;
case ".bmp":
encoder = new BmpBitmapEncoder();
break;
case ".gif":
encoder = new GifBitmapEncoder();
break;
case ".tif":
encoder = new TiffBitmapEncoder();
break;
default:
throw new InvalidOperationException();
}
encoder.Frames.Add(BitmapFrame.Create(bmp));
using (Stream stm = File.Create(imagFile))
{
encoder.Save(stm);
}
}
catch (Exception exp)
{
NLogger.Warn("Export widget into a image exception : " + exp.Message);
return(false);
}
return(true);
}
public void UnGroup(GroupViewModel groupVM)
{
GroupViewModel targetVM = groupVM;
List <WidgetViewModBase> WidgetChildren = targetVM.WidgetChildren;
foreach (WidgetViewModBase item in WidgetChildren)
{
item.ParentID = Guid.Empty;
}
IGroups ChildGroups = targetVM.GroupChildren;
//======================================================render the group
//Create the external Groups
List <WidgetViewModBase> GroupVMs = new List <WidgetViewModBase>();
foreach (IGroup it in ChildGroups)
{
WidgetViewModBase vmItem = WidgetFactory.CreateGroup(it);
if (vmItem == null)
{
return;
}
vmItem.IsGroup = true;
GroupVMs.Add(vmItem);
}
//Remove the parent group
targetVM.IsSelected = false;
_selectionService.RemoveWidget(targetVM);
Items.Remove(targetVM);
//Initialize the new Group
//if (GroupVMs.Count <= 0)
// return;
foreach (WidgetViewModBase wdg in Items)
{
foreach (GroupViewModel group in GroupVMs)
{
if (true == group.IsChild(wdg.widgetGID, false))
{
wdg.ParentID = group.widgetGID;
wdg.IsGroup = false;
wdg.IsSelected = false;
group.AddChild(wdg);
}
}
}
//UI Render the Groups
foreach (GroupViewModel group in GroupVMs)
{
group.Status = GroupStatus.Selected;
Items.Add(group);
group.Refresh();
}
//===========================================
//Select new childreb
foreach (WidgetViewModBase item in WidgetChildren)
{
if (item.ParentID == Guid.Empty)
{
item.IsSelected = true;
item.IsGroup = false;
}
}
//Last
_model.UnGroup(groupVM.WidgetID);
_ListEventAggregator.GetEvent <GroupChangedEvent>().Publish(false);
}
private void MoveThumb_DragDelta(object sender, DragDeltaEventArgs e)
{
//Initialize to avoid exception
if (this.designerItem == null || this.designerCanvas == null)
{
return;
}
//Initialize the selected widgets' context when first move
if (bIsMousePressMove == false)
{
designerItem.IsAfterDraged = true;
if (designerItem.IsSelected == false)
{
designerItem.SelectCurrentWidget();
}
if (Keyboard.IsKeyDown(Key.LeftCtrl) == true || Keyboard.IsKeyDown(Key.RightCtrl) == true)
{
IsCtrlPressed = true;
}
else
{
IsCtrlPressed = false;
}
if (IsCtrlPressed == true && Mouse.LeftButton == MouseButtonState.Pressed)
{
//Cursor = CopyCur;
//designerItem.IsStyleBrushModel = null;
if (designerItem == null)
{
return;
}
WidgetViewModBase wVM = designerItem.DataContext as WidgetViewModBase;
wVM.IsBrushModel = null;
}
AdornerLayer adornerLayer = AdornerLayer.GetAdornerLayer(designerCanvas);
if (adornerLayer != null)
{
adorner = new PreveiwMoveAdorner(designerCanvas);
if (adorner != null)
{
adornerLayer.Add(adorner);
}
}
IPagePropertyData Page = designerCanvas.DataContext as IPagePropertyData;
foreach (WidgetViewModBase item in Page.GetSelectedwidgets())
{
if (item.IsLocked == true)
{
continue;
}
if (item.IsGroup == true)
{
GroupViewModel group = item as GroupViewModel;
if (group == null)
{
continue;
}
// Create a property memento when drag start
foreach (WidgetViewModBase child in group.WidgetChildren)
{
child.CreateNewPropertyMementos();
child.PropertyMementos.AddPropertyMemento(new PropertyMemento("Left", child.Raw_Left, child.Raw_Left));
child.PropertyMementos.AddPropertyMemento(new PropertyMemento("Top", child.Raw_Top, child.Raw_Top));
_infoItems.Add(child);
}
_groups.Add(group);
}
else
{
item.CreateNewPropertyMementos();
item.PropertyMementos.AddPropertyMemento(new PropertyMemento("Left", item.Raw_Left, item.Raw_Left));
item.PropertyMementos.AddPropertyMemento(new PropertyMemento("Top", item.Raw_Top, item.Raw_Top));
if (item.WidgetType == WidgetType.Toast && item.Top == 0)
{
item.PropertyMementos.AddPropertyMemento(new PropertyMemento("DisplayPosition", ToastDisplayPosition.Top, ToastDisplayPosition.Top));
}
_infoItems.Add(item);
}
}
bIsMousePressMove = true;
}
SendFirePositionEvent(false);
//Move adorner to show drag process
MoveAdorner(sender, e);
//Move Widgets, the older solution, discarded
//if (_infoItems.Count > 0 || _groups.Count > 0)
//{
// MoveSelectedWidgets(sender,e);
//}
//set routed event is handled
e.Handled = true;
}
public void AddItems(WidgetViewModBase data)
{
_VMItems.Add(data);
OnItemsAdd();
}
private List <WidgetViewModBase> CreateVMObjects(IObjectContainer container)
{
List <WidgetViewModBase> all = new List <WidgetViewModBase>();
//common widget
foreach (IWidget newItem in container.WidgetList)
{
if (newItem != null && newItem.ParentGroup == null)
{
WidgetViewModBase vmItem = WidgetFactory.CreateWidget(newItem);
vmItem.ParentPageVM = this;
all.Add(vmItem);
}
}
//common master
foreach (IMaster newItem in container.MasterList)
{
if (newItem != null && newItem.ParentGroup == null)
{
WidgetViewModBase vmItem = WidgetFactory.CreateWidget(newItem);
vmItem.ParentPageVM = this;
all.Add(vmItem);
}
}
//master and it's all children
foreach (IGroup newGroup in container.GroupList)
{
GroupViewModel vmGroup = null;
if (newGroup != null && newGroup.ParentGroup == null)
{
vmGroup = WidgetFactory.CreateGroup(newGroup) as GroupViewModel;
vmGroup.IsGroup = true;
vmGroup.Status = GroupStatus.Selected;
}
List <IRegion> children = new List <IRegion>();
GetWidgetChildren(newGroup, children);
if (children.Count < 1 || vmGroup == null)
{
continue;
}
all.Add(vmGroup);
foreach (IRegion item in children)
{
WidgetViewModBase vmChild = WidgetFactory.CreateWidget(item);
if (vmChild == null)
{
continue;
}
vmChild.IsGroup = false;
vmChild.ParentID = newGroup.Guid;
vmChild.IsSelected = false;
vmGroup.AddChild(vmChild);
all.Add(vmChild);
}
}
return(all);
}
/// <summary>
/// load all widgets/groups which is not in a group in current page.
/// which means,only load top level widget/group.
/// </summary>
public void LoadPageWidgets()
{
if (_selectedWidget == null || _widgetShowHideAction == null)
{
DisableInteraction();
return;
}
WidgetList.Clear();
List <IWidgetPropertyData> allWidgets = SelectionService.GetCurrentPage().GetAllWidgets();
List <WidgetNode> TargetWidgets = new List <WidgetNode>();
foreach (IWidgetPropertyData it in allWidgets.Where(x => x.IsGroup == false))
{
WidgetViewModBase wdg = it as WidgetViewModBase;
if (wdg == null)
{
continue;
}
// load widget that is not in a group .
if ((wdg.ParentID == Guid.Empty))
{
bool bChecked = false;
IRegion targetObject = wdg.WidgetModel.WdgDom;
if (targetObject == null)
{
break;
}
//if the widget is already checked.
var selWidget = _widgetShowHideAction.TargetObjects.FirstOrDefault(x => x.Guid == targetObject.Guid);
if (selWidget != null)
{
bChecked = true;
}
TargetWidgets.Add(new WidgetNode(this, targetObject, wdg.Type, bChecked));
}
}
//load all groups.
foreach (IGroup group in _currentPage.Groups)
{
bool bChecked = false;
var selGroup = _widgetShowHideAction.TargetObjects.FirstOrDefault(x => x.Guid == group.Guid);
if (selGroup != null)
{
bChecked = true;
}
TargetWidgets.Add(new WidgetNode(this, group, ObjectType.Group, bChecked));
}
_isCheckAll = !TargetWidgets.Any(x => x.IsSelected == false);
WidgetList.AddRange(TargetWidgets);
FirePropertyChanged("IsCheckAll");
FirePropertyChanged("ShowHideType");
FirePropertyChanged("AnimateType");
FirePropertyChanged("AnimateTime");
FirePropertyChanged("IsShowHideEnabled");
}
private void RotateThumb_DragDelta(object sender, DragDeltaEventArgs e)
{
//Initialize the selected widgets' context when first rotate
if (_infoItems.Count <= 0)
{
WidgetViewModBase wdg = designerItem.DataContext as WidgetViewModBase;
if (wdg.IsGroup == false)
{
wdg.CreateNewPropertyMementos();
wdg.PropertyMementos.AddPropertyMemento(new PropertyMemento("RotateAngle", wdg.RotateAngle, wdg.RotateAngle));
_infoItems.Add(wdg);
}
else
{
foreach (WidgetViewModBase item in (wdg as GroupViewModel).WidgetChildren)
{
item.CreateNewPropertyMementos();
item.CreateNewPropertyMementos();
item.PropertyMementos.AddPropertyMemento(new PropertyMemento("RotateAngle", item.RotateAngle, item.RotateAngle));
item.PropertyMementos.AddPropertyMemento(new PropertyMemento("Left", item.Raw_Left, item.Raw_Left));
item.PropertyMementos.AddPropertyMemento(new PropertyMemento("Top", item.Raw_Top, item.Raw_Top));
_infoItems.Add(item);
}
}
}
//Rotate the current widget
if (this.designerItem != null && this.canvas != null)
{
ContentPresenter wrapper = VisualTreeHelper.GetParent(VisualTreeHelper.GetParent(designerItem)) as ContentPresenter;
Point currentPoint = Mouse.GetPosition(this.canvas);
Vector deltaVector = Point.Subtract(currentPoint, this.centerPoint);
double angle = Vector.AngleBetween(this.startVector, deltaVector);
RotateTransform rotateTransform = designerItem.RenderTransform as RotateTransform;
angle = this.initialAngle + Math.Round(angle, 0);
if (angle < 0)
{
angle += 360;
}
else if (angle >= 360)
{
angle -= 360;
}
wrapper.InvalidateMeasure();
if (this.designerItem.IsGroup == true)
{
GroupViewModel group = this.designerItem.DataContext as GroupViewModel;
DesignerCanvas dc = canvas as DesignerCanvas;
foreach (WidgetViewModBase item in group.WidgetChildren)
{
RotateTransform rt = new RotateTransform(); // bw.RenderTransform as RotateTransform;
rt.Angle = angle - groupIntialAngle;
rt.CenterX = groupCenterX;
rt.CenterY = groupCenterY;
double oldAngle = item.RotateAngle;
item.RotateAngle = Convert.ToInt16(angle - groupIntialAngle);
Rect rect1 = rt.TransformBounds(new Rect(item.Left, item.Top, item.ItemWidth, item.ItemHeight));
Rect rect2 = item.RevertBoundingRectangle(rect1);
//item.IsActual = true;
item.Raw_Left = rect2.Left;
item.Raw_Top = rect2.Top;
//only widget can rotate
if (item is WidgetRotateViewModBase)
{
int newAngle = Convert.ToInt16(oldAngle + (angle - groupIntialAngle)) % 360;
if (newAngle < 0)
{
newAngle += 360;
}
else if (angle >= 360)
{
newAngle -= 360;
}
item.RotateAngle = newAngle;
}
else
{
item.RotateAngle = 0;
}
}
group.Refresh();
groupIntialAngle = angle;
}
else
{
rotateTransform.Angle = angle;
}
if (this.designerItem.ParentID != Guid.Empty)
{
IGroupOperation pageVM = canvas.DataContext as IGroupOperation;
pageVM.UpdateGroup(this.designerItem.ParentID);
}
if (this.designerItem.IsGroup)
{
IGroupOperation pageVM = canvas.DataContext as IGroupOperation;
pageVM.UpdateGroup((this.designerItem.DataContext as GroupViewModel).WidgetID);
}
}
}
public void WdgMgrReZOrderSelection(int tarZorder, Guid tarWdgGuid)
{
if (_busyIndicator.IsShow == true)
{
return;
}
// tarWdgGuid = Guid.NewGuid();
WidgetViewModBase wdg = items.FirstOrDefault(c => c.WidgetID == tarWdgGuid);
if (wdg == null)
{
return;
}
int orgZorder = wdg.ZOrder;
int nOriCount = 1;
if (wdg.IsGroup == true)
{
nOriCount = (wdg as GroupViewModel).WidgetChildren.Count();
}
CompositeCommand cmds = new CompositeCommand();
bool bIsZOrderChanged = false;
//up drag to other widgets
List <WidgetViewModBase> allothers;
int nOtherNum = 0;
if (tarZorder > orgZorder)
{
allothers = items.Where(c => c.ZOrder <tarZorder && c.ZOrder> orgZorder && c.IsGroup == false).ToList <WidgetViewModBase>();
foreach (WidgetViewModBase it in allothers)
{
CreatePropertyChangeUndoCommand(cmds, it, "ZOrder", it.ZOrder, it.ZOrder - nOriCount);
it.ZOrder = it.ZOrder - nOriCount;
bIsZOrderChanged = true;
}
nOtherNum = allothers.Count();
}
else if (tarZorder < orgZorder)//down drag to other widgets
{
allothers = items.Where(c => c.ZOrder < (orgZorder - nOriCount + 1) && c.ZOrder >= tarZorder && c.IsGroup == false).ToList <WidgetViewModBase>();
foreach (WidgetViewModBase it in allothers)
{
CreatePropertyChangeUndoCommand(cmds, it, "ZOrder", it.ZOrder, it.ZOrder + nOriCount);
it.ZOrder = it.ZOrder + nOriCount;
bIsZOrderChanged = true;
}
nOtherNum = -allothers.Count();
}
//adjust the drag item's zorder
if (wdg.IsGroup == true)
{
foreach (WidgetViewModBase it in (wdg as GroupViewModel).WidgetChildren)
{
CreatePropertyChangeUndoCommand(cmds, it, "ZOrder", it.ZOrder, it.ZOrder + nOtherNum);
it.ZOrder = it.ZOrder + nOtherNum;
bIsZOrderChanged = true;
}
}
else
{
CreatePropertyChangeUndoCommand(cmds, wdg, "ZOrder", wdg.ZOrder, wdg.ZOrder + nOtherNum);
wdg.ZOrder = wdg.ZOrder + nOtherNum;
bIsZOrderChanged = true;
}
_ListEventAggregator.GetEvent <ZorderChangedEvent>().Publish(null);
//Push Command to Undo/Redo stack
if (bIsZOrderChanged == true)
{
NotifyEventCommand notifyCmd = new NotifyEventCommand(CompositeEventType.ZorderChange);
cmds.AddCommand(notifyCmd);
PushToUndoStack(cmds);
_ListEventAggregator.GetEvent <ZorderChangedEvent>().Publish(null);
}
//items.Where(c => c.IsSelected == true).ToList<WidgetViewModBase>();
//List<WidgetViewModBase> AllChildren = ParentGroup.WidgetChildren;
//List<WidgetViewModBase> targetWidgets = ParentGroup.WidgetChildren.Where(c => c.IsSelected == true).ToList<WidgetViewModBase>();
//if (targetWidgets.Count() == AllChildren.Count())
//{
// return;
//}
//targetWidgets = targetWidgets.OrderByDescending(s => s.ZOrder).ToList<WidgetViewModBase>();
//int maxZOrder = AllChildren.Max(a => a.ZOrder);
}
private void EditTextCommandHandler(object obj)
{
WidgetViewModBase widgetVM = _selectionService.GetSelectedWidgets()[0] as WidgetViewModBase;
widgetVM.CanEdit = true;
}
