internal Widget(Instance inst, FString name, Layout parent, WidgetType type)
{
mInstance = inst;
mType = type;
mName = name;
mParentLayout = parent;
}
public DoubleTile(WidgetType wt)
{
InitializeComponent();
//c_Canvas.Height = 70;
a_Shift.Duration = new Duration(TimeSpan.Parse("0:0:0.2"));
wb_Chrome.Ready += new EventHandler(wb_Chrome_Ready);
}
public frmRefine()
{
InitializeComponent();
_type = WidgetType.TextField;
_fileToLoad += _type.ToString() + ".json";
_fileToSave += _type.ToString() + ".json";
if (File.Exists(_fileToLoad))
{
string file = File.ReadAllText(_fileToLoad);
_images = JsonConvert.DeserializeObject<List<ImageTestData>>(file);
}
}
public static string AddBitmap(string activityName, Bitmap image, WidgetType type)
{
RandomNumberGenerator rng = new RNGCryptoServiceProvider();
byte[] tokenData = new byte[4];
rng.GetBytes(tokenData);
string randomChars = Convert.ToBase64String(tokenData);
string id = "";
id = activityName + "_" + type.ToString() + "_" + randomChars;
id = id.ToLower();
while (_knownIDs.Contains(id))
{
tokenData = new byte[4];
rng.GetBytes(tokenData);
randomChars = Convert.ToBase64String(tokenData);
id += "_" + randomChars;
id = id.ToLower();
}
var sb = new StringBuilder();
foreach (char c in id)
{
if (char.IsLetterOrDigit(c))
sb.Append(c);
else if (c == '_')
sb.Append(c);
}
id = sb.ToString();
id = id.ToLower();
_knownImages.Add(image);
_knownIDs.Add(id);
_IDToBitmap.Add(id, image);
return id;
}
public frmTest(WidgetType type)
{
_type = type;
InitializeComponent();
_fileToLoad += type.ToString() + ".json";
_fileToSave += type.ToString() + ".json";
if (File.Exists(_fileToLoad))
{
string file = File.ReadAllText(_fileToLoad);
_images = JsonConvert.DeserializeObject<List<ImageTestData>>(file);
foreach (ImageTestData item in _images)
{
_widgetCount += item.WidgetAreaList.Count;
}
_loadedFromJSON = true;
}
lblFile.Text = _fileToLoad;
}
public frmSelection(WidgetType type)
{
InitializeComponent();
(selectionPanel as Control).KeyDown += new KeyEventHandler(this.onKeyDown);
(selectionPanel as Control).Select();
(selectionPanel as Control).MouseWheel += new MouseEventHandler(this.onMouseWheel);
(zoomedImageBox as Control).MouseWheel += new MouseEventHandler(this.onMouseWheel);
_fileToLoad += type.ToString() + ".json";
if (File.Exists(_fileToLoad))
{
string file = File.ReadAllText(_fileToLoad);
_images = JsonConvert.DeserializeObject<List<ImageTestData>>(file);
foreach (ImageTestData item in _images)
{
_widgetCount += item.WidgetAreaList.Count;
}
_index = _images.Count - 1;
_currentImage = _images[_images.Count - 1];
_images.RemoveAt(_images.Count - 1);
_loadedFromJSON = true;
}
else
{
_images = new List<ImageTestData>();
}
_imagePaths = Directory.GetFiles("testimages\\").ToList<string>();
lblType.Text = type.ToString();
}
private static Widget createWrapper(IntPtr widget, object[] args)
{
if (MyGUIInterface.TrackMemoryLeaks)
{
allocationStackTraces.Add(widget, new StackTrace(true));
}
WidgetType widgetType = WidgetManager_getType(widget);
Widget_setDestructorCallback(widget, widgetDestructorFunc);
switch (widgetType)
{
case WidgetType.Widget:
return(new Widget(widget));
case WidgetType.Canvas:
return(new Widget(widget));
case WidgetType.DDContainer:
return(new Widget(widget));
case WidgetType.ItemBox:
return(new Widget(widget));
case WidgetType.ListBox:
return(new Widget(widget));
case WidgetType.MenuControl:
return(new MenuControl(widget));
case WidgetType.MenuBar:
return(new MenuBar(widget));
case WidgetType.PopupMenu:
return(new PopupMenu(widget));
case WidgetType.MultiListBox:
return(new MultiListBox(widget));
case WidgetType.ProgressBar:
return(new ProgressBar(widget));
case WidgetType.ScrollView:
return(new ScrollView(widget));
case WidgetType.ImageBox:
return(new ImageBox(widget));
case WidgetType.TextBox:
return(new TextBox(widget));
case WidgetType.Button:
return(new Button(widget));
case WidgetType.MenuItem:
return(new MenuItem(widget));
case WidgetType.EditBox:
return(new EditBox(widget));
case WidgetType.ComboBox:
return(new ComboBox(widget));
case WidgetType.Window:
return(new Window(widget));
case WidgetType.TabItem:
return(new TabItem(widget));
case WidgetType.TabControl:
return(new TabControl(widget));
case WidgetType.ScrollBar:
return(new ScrollBar(widget));
}
Log.Warning("Could not identify widget type for widget {0}. Type given was {1}. Will return a Widget in its place.", widget.ToString(), widgetType);
return(new Widget(widget));
}
public Widget(WidgetType type, string definition)
{
Type = type;
Definition = definition;
}
/// <summary>
/// Get sitemap by name.
/// </summary>
/// <param name="sitemapName"></param>
/// <param name="type"></param>
/// <returns></returns>
public Sitemap GetSitemap(string sitemapName, WidgetType type)
{
return(GetSitemapAsync(sitemapName, type.ToString()).Result);
}
public override void AttachStyle (WidgetType widgetType, IntPtr drawable, GtkPlus gtkPlus)
{
gtkPlus.combo_box_drop_down_toggle_button_style = gtk_style_attach (gtkPlus.combo_box_drop_down_toggle_button_style, drawable);
gtkPlus.combo_box_drop_down_arrow_style = gtk_style_attach (gtkPlus.combo_box_drop_down_arrow_style, drawable);
}
void PaintExcludingArea (WidgetType widgetType, Rectangle bounds, IDeviceContext dc, Rectangle excludedArea, Painter painter)
{
Paint (widgetType, bounds, dc, TransparencyType.Alpha, Color.Black, DeviceContextType.Native, bounds, painter, excludedArea);
}
protected override void AfterConstruction()
{
base.AfterConstruction();
_widgetType = DefaultWidgetType;
}
private void Initialize()
{
Type widgetType = null;
try
{
assembly = Assembly.LoadFrom(Path);
widgetType = assembly.GetTypes().FirstOrDefault(type => typeof(WidgetDerived).IsAssignableFrom(type));
}
catch (ReflectionTypeLoadException ex)
{
// logger.Error("Failed to load provider from " + Path + ".\n" + ex);
HasErrors = true;
return;
}
if (widgetType == null)
{
//logger.Error("Failed to find IWeatherProvider in " + Path);
HasErrors = true;
return;
}
WidgetComponent = Activator.CreateInstance(widgetType) as WidgetDerived;
if (WidgetComponent == null)
{
HasErrors = true;
return;
}
Name = WidgetComponent.Name;
WidgetType = WidgetType.Native;
}
internal static List <string> GetKeys(WidgetType type)
{
var creater = GetCreater(type);
return(creater.Keys);
}
public static GameObject CreateInstence(WidgetType type, WidgetItem info)
{
var creater = GetCreater(type);
return(creater.CreateInstence(info));
}
public WidgetItemStock()
{
_type = WidgetType.None;
_productUnits = 0;
}
internal Canvas(Instance inst, FString name, Layout parent, WidgetType type)
: base(inst, name, parent, type)
{
}
public void ChangeType(WidgetType type)
{
this.type = type;
InitSpriteDic();
}
public WidgetItem(WidgetType type)
{
ChangeType(type);
}
/// <summary>
/// Removes all widgets of a type.
/// </summary>
/// <param name="type">The type to remove.</param>
public void RemoveWidgetType(WidgetType type)
{
int i = 0;
widgets.ForEach(x =>
{
if (x.id.Item1 == type)
{
widgets.RemoveAt(i);
}
++i;
});
}
internal TextBox(Instance inst, FString name, Layout parent, WidgetType type)
: base(inst, name, parent, type)
{
}
public Widget(WidgetType type)
{
Type = type;
Arg = "";
}
public Widget(WidgetType type)
{
this.type = type;
}
public override Widget Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
Widget widget = null;
int startDepth = reader.CurrentDepth;
while (reader.Read())
{
// Return the widget when we are at the end of the object
if (reader.TokenType == JsonTokenType.EndObject && reader.CurrentDepth == startDepth)
{
return(widget);
}
// If we are reading a property name
if (reader.TokenType == JsonTokenType.PropertyName)
{
string property = reader.GetString();
// If the property name is widget type
if (property == "widgetType")
{
reader.Read();
WidgetType widgetType = (WidgetType)reader.GetInt32();
// Get the widget
switch (widgetType)
{
case WidgetType.Button:
widget = new ButtonWidget();
break;
case WidgetType.Text:
widget = new TextWidget();
break;
case WidgetType.Image:
widget = new ImageWidget();
break;
case WidgetType.Container:
widget = new ContainerWidget();
break;
case WidgetType.Line:
widget = new LineWidget();
break;
case WidgetType.Video:
widget = new VideoWidget();
break;
case WidgetType.ProductGroup:
widget = new ProductGroupWidget();
break;
case WidgetType.Shop:
widget = new ShopWidget();
break;
case WidgetType.Carousel:
widget = new CarouselWidget();
break;
case WidgetType.Grid:
widget = new GridWidget();
break;
}
widget.WidgetType = widgetType;
}
else
{
// Set each property for the widget
widget.SetProperty(property, ref reader, options);
}
}
}
throw new JsonException();
}
public async Task <IActionResult> Create(Websites websites)
{
//([Bind("Id,CreatedBy,DomainUrl,WebsiteName")] Websites websites)
if (ModelState.IsValid)
{
// var userData = _context.AspNetUsers.SingleOrDefault(x => x.UserName == User.Identity.Name);
var websitesData = _context.Websites.Where(x => x.CreatedBy == User.Identity.Name).ToList();
for (int i = 0; i < websitesData.Count; i++)
{
if (websitesData[i].WebsiteName == websites.WebsiteName)
{
if (websitesData[i].IsDeleted == false)
{
ModelState.AddModelError(string.Empty, "This website name already exists . Please choose another name .. ");
return(View());
}
}
}
_context.Add(websites);
_context.SaveChanges();
var websiteID = websites.Id;
Widget widget = new Widget();
widget.CreatedDate = DateTime.Now;
widget.CreatedBy = User.Identity.Name;
widget.Title = websites.WebsiteName + "-Document";
widget.WidgetOrdinal = 0;
try
{
int widgettypeid = _context.WidgetType.SingleOrDefault(x => x.Name == "Document").Id;
widget.WidgetTypeId = widgettypeid;
}
catch
{
WidgetType widgetType = new WidgetType();
widgetType.Name = "Document";
widgetType.Description = "Base Page for any website";
widgetType.Section = "Body";
_context.Add(widgetType);
await _context.SaveChangesAsync();
int widgettypeid = _context.WidgetType.SingleOrDefault(x => x.Name == "Document").Id;
widget.WidgetTypeId = widgettypeid;
}
widget.HtmlBody = "<!DOCTYPE html>" +
"< html lang = 'en' >" +
"< head >" +
"< meta charset = 'UTF-8' >" +
"< meta name = 'viewport' content = 'width=device-width, initial-scale=1.0' >" +
"< meta http - equiv = 'X-UA-Compatible' content = 'ie=edge' > " +
"< title > ${websiteName} </ title >" +
"</ head >" +
"< body >" +
"</ body >" +
"</ html >";
_context.Add(widget);
await _context.SaveChangesAsync();
UserWebsites userWebsites = new UserWebsites();
userWebsites.WebsiteId = websiteID;
userWebsites.UserEmail = User.Identity.Name;
_context.Add(userWebsites);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(websites));
}
internal static Widget CreateWidget(Instance inst, FString name, Layout parent_layout)
{
WidgetType type = ICall_getType(inst.Ptr);
Widget widget = null;
switch (type)
{
case WidgetType.Widget:
widget = new Widget(inst, name, parent_layout, WidgetType.Widget);
break;
case WidgetType.ImageBox:
widget = new ImageBox(inst, name, parent_layout);
break;
case WidgetType.Window:
widget = new Window(inst, name, parent_layout);
break;
case WidgetType.TextBox:
widget = new TextBox(inst, name, parent_layout);
break;
case WidgetType.ListBox:
widget = new ListBox(inst, name, parent_layout);
break;
case WidgetType.Button:
widget = new Button(inst, name, parent_layout);
break;
case WidgetType.EditBox:
widget = new EditBox(inst, name, parent_layout);
break;
case WidgetType.ComboBox:
widget = new ComboBox(inst, name, parent_layout);
break;
case WidgetType.ScrollBar:
widget = new ScrollBar(inst, name, parent_layout);
break;
case WidgetType.DDContainer:
widget = new DDContainer(inst, name, parent_layout);
break;
case WidgetType.ItemBox:
widget = new ItemBox(inst, name, parent_layout);
break;
case WidgetType.Canvas:
widget = new Canvas(inst, name, parent_layout);
break;
default:
widget = new Widget(inst, name, parent_layout, WidgetType.Unknown);
break;
}
return(widget);
}
void Paint (GdkDrawablePointer drawable, GdkGCPointer gc, Rectangle rectangle, WidgetType widgetType, out GdkPixbufPointer pixbuf, out IntPtr pixelData, out int rowstride, Rectangle clippingArea, Painter painter, Rectangle excludedArea)
{
gdk_draw_rectangle (drawable, gc, true, clippingArea.X, clippingArea.Y, clippingArea.Width, clippingArea.Height);
painter.Paint (styles [(int)widgetType], drawable, new GdkRectangle(clippingArea), widgets [(int)widgetType], 0, 0, rectangle.Width, rectangle.Height, this);
if (excludedArea.Width != 0)
gdk_draw_rectangle (drawable, gc, true, excludedArea.X, excludedArea.Y, excludedArea.Width, excludedArea.Height);
if (
(pixbuf = gdk_pixbuf_new (GdkColorspace.GDK_COLORSPACE_RGB, true, 8, clippingArea.Width, clippingArea.Height)) == IntPtr.Zero ||
gdk_pixbuf_get_from_drawable (pixbuf, drawable, IntPtr.Zero, clippingArea.X, clippingArea.Y, 0, 0, clippingArea.Width, clippingArea.Height) == IntPtr.Zero)
throw new OutOfMemoryException ();
pixelData = gdk_pixbuf_get_pixels (pixbuf);
rowstride = gdk_pixbuf_get_rowstride (pixbuf);
}
extern private static bool ICall_isType(IntPtr widget_ptr, WidgetType type);
private static JsonResult _CreateJsonResult(WidgetType widgetType, object data)
{
var request = new HttpRequestBaseMock(FixtureConstants.Authorization_Test123, "json", ((int)widgetType).ToString());
var t = new GeckoboardService(request,
(a, b) => data,
a => a == FixtureConstants.Authorization_Test123_Source
);
var res = t.Result() as JsonResult;
Assert.IsNotNull(res);
return res;
}
public void WidgetAction(WidgetType type, string name, string args, int widgetArgNum)
{
Widget widget = Field.GetWidget(type);
if (widget == null)
{
return;
}
switch (type)
{
case WidgetType.SceneMovie:
if (name == "Clear")
{
// TODO
}
break;
case WidgetType.OxQuiz:
switch (name)
{
case "DevMode":
// TODO: Unknown
break;
case "PickQuiz":
// TODO: Use args to find a tier of a question
widget.OXQuizQuestion = DatabaseManager.OxQuizQuestion.GetRandomQuestion();
break;
case "ShowQuiz":
Field.BroadcastPacket(QuizEventPacket.Question(widget.OXQuizQuestion.Category, widget.OXQuizQuestion.QuestionText, int.Parse(args)));
break;
case "PreJudge":
if (widget.OXQuizQuestion.Answer)
{
widget.State = "Correct";
}
else
{
widget.State = "Incorrect";
}
break;
case "ShowAnswer":
Field.BroadcastPacket(QuizEventPacket.Answer(widget.OXQuizQuestion.Answer, widget.OXQuizQuestion.AnswerText, int.Parse(args)));
break;
case "Judge":
break;
}
break;
default:
Logger.Warning("Non implemented Widget Action. WidgetType: {type}", type);
break;
}
}
/// <summary>
/// Draw the custom wizard.
/// </summary>
void OnGUI()
{
// Load the saved preferences
if (!mLoaded)
{
mLoaded = true; Load();
}
EditorGUIUtility.LookLikeControls(80f);
GameObject go = NGUIEditorTools.SelectedRoot();
if (go == null)
{
GUILayout.Label("You must create a UI first.");
if (GUILayout.Button("Open the New UI Wizard"))
{
EditorWindow.GetWindow <UICreateNewUIWizard>(false, "New UI", true);
}
}
else
{
GUILayout.Space(4f);
GUILayout.BeginHorizontal();
ComponentSelector.Draw <UIAtlas>(NGUISettings.atlas, OnSelectAtlas, GUILayout.Width(140f));
GUILayout.Label("Texture atlas used by widgets", GUILayout.MinWidth(10000f));
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
ComponentSelector.Draw <UIFont>(NGUISettings.font, OnSelectFont, GUILayout.Width(140f));
GUILayout.Label("Font used by labels", GUILayout.MinWidth(10000f));
GUILayout.EndHorizontal();
GUILayout.Space(-2f);
NGUIEditorTools.DrawSeparator();
GUILayout.BeginHorizontal();
WidgetType wt = (WidgetType)EditorGUILayout.EnumPopup("Template", mType, GUILayout.Width(200f));
GUILayout.Space(20f);
GUILayout.Label("Select a widget template to use");
GUILayout.EndHorizontal();
if (mType != wt)
{
mType = wt; Save();
}
switch (mType)
{
case WidgetType.Label: CreateLabel(go); break;
case WidgetType.Sprite: CreateSprite(go, mSprite); break;
case WidgetType.Texture: CreateSimpleTexture(go); break;
case WidgetType.Button: CreateButton(go); break;
case WidgetType.ImageButton: CreateImageButton(go); break;
case WidgetType.Checkbox: CreateCheckbox(go); break;
case WidgetType.ProgressBar: CreateSlider(go, false); break;
case WidgetType.Slider: CreateSlider(go, true); break;
case WidgetType.Input: CreateInput(go); break;
case WidgetType.PopupList: CreatePopup(go, true); break;
case WidgetType.PopupMenu: CreatePopup(go, false); break;
case WidgetType.ScrollBar: CreateScrollBar(go); break;
}
}
}
public ActionResult <IEnumerable <WidgetSubType> > GetByType(string incomingType)
{
WidgetType type = db.WidgetTypes.First(w => w.Type == incomingType);
return(db.WidgetSubTypes.Where(h => h.WidgetTypeId == type.Id).ToList());
}
private static extern bool ICall_isType(IntPtr widget_ptr, WidgetType type);
private Dictionary <string, List <ReportDataModel> > GetDataFromDB_Year(List <string> widgetItemIds, WidgetType type)
{
var startYear = DateTime.Now.Year - 24;
var endYear = DateTime.Now.Year;
//var churchId = _currentUser.ChurchId;
var churchId = 15;
var startDate = DateTime.Parse(string.Format("{0}-01-01", startYear));
var endDate = DateTime.Now.Date.AddDays(1).AddSeconds(-1);
var originalData = GetDataList(widgetItemIds, type, churchId, startDate, endDate);
var groupList = originalData.GroupBy(x => string.Format("{0}-Years", x.Date.Year))
.OrderBy(g => g.Key).Select(g => new ReportDataModel
{
Key = g.Key.ToString(),
Value = g.Sum(i => i.Value),
Count = g.Sum(i => i.Count)
}).ToList();
var dbDataList = new List <ReportDataModel>(25);
for (var iYear = startYear; iYear <= endYear; iYear++)
{
var tempData = new ReportDataModel {
Key = string.Format("{0}-Years", iYear), Value = 0.00m, Count = 0
};
var data = groupList.FirstOrDefault(x => x.Key == string.Format("{0}-Years", iYear));
if (data != null)
{
tempData.Value = data.Value;
tempData.Count = data.Count;
}
dbDataList.Add(tempData);
}
var dicData = new Dictionary <string, List <ReportDataModel> >();
dicData.Add("Years", dbDataList);
return(dicData);
}
public Widget(WidgetType type)
{
WidgetType = type;
}
private Dictionary <string, List <ReportDataModel> > GetDataFromDB_Month(List <string> widgetItemIds, WidgetType type)
{
var startYear = DateTime.Now.Year - 1;
var endYear = DateTime.Now.Year;
//var churchId = _currentUser.ChurchId;
var churchId = 15;
var startDate = DateTime.Parse(string.Format("{0}-01-01", startYear));
var endDate = DateTime.Now.Date.AddDays(1).AddSeconds(-1);
var originalData = GetDataList(widgetItemIds, type, churchId, startDate, endDate);
var groupList = originalData.GroupBy(x => string.Format("{0}-{1}", x.Date.ToString("MMM"), x.Date.Year))
.OrderBy(g => g.Key).Select(g => new ReportDataModel
{
Key = g.Key,
Value = g.Sum(i => i.Value),
Count = g.Sum(i => i.Count)
}).ToList();
var dicData = new Dictionary <string, List <ReportDataModel> >();
var monthArray = new string[] { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
for (var iYear = startYear; iYear <= endYear; iYear++)
{
var yearDataList = groupList.FindAll(x => x.Year == iYear.ToString());
var dbDataList = new List <ReportDataModel>(12);
foreach (var strMonth in monthArray)
{
var tempData = new ReportDataModel {
Key = string.Format("{0}-{1}", strMonth, iYear), Value = 0.00m, Count = 0
};
var data = yearDataList.FirstOrDefault(x => x.X_Axis == strMonth);
if (data != null)
{
tempData.Value = data.Value;
tempData.Count = data.Count;
}
dbDataList.Add(tempData);
}
dicData.Add(iYear.ToString(), dbDataList);
}
return(dicData);
}
private Dictionary <string, List <ReportDataModel> > GetDataFromDB_Quarter(List <string> widgetItemIds, WidgetType type)
{
var startYear = DateTime.Now.Year - 1;
var endYear = DateTime.Now.Year;
//var churchId = _currentUser.ChurchId;
var churchId = 15;
var startDate = DateTime.Parse(string.Format("{0}-01-01", startYear));
var endDate = DateTime.Now.Date.AddDays(1).AddSeconds(-1);
var originalData = GetDataList(widgetItemIds, type, churchId, startDate, endDate);
var groupList = originalData.GroupBy(x => string.Format("Q{0}-{1}", ((x.Date.Month - 1) / 3 + 1), x.Date.Year))
.OrderBy(g => g.Key).Select(g => new ReportDataModel
{
Key = g.Key,
Value = g.Sum(i => i.Value),
Count = g.Sum(i => i.Count)
}).ToList();
var dicData = new Dictionary <string, List <ReportDataModel> >();
var quarterArray = new string[] { "Q1", "Q2", "Q3", "Q4" };
for (var iYear = startYear; iYear <= endYear; iYear++)
{
var yearDataList = groupList.FindAll(x => x.Year == iYear.ToString());
var dbDataList = new List <ReportDataModel>(4);
foreach (var strQuarter in quarterArray)
{
var tempData = new ReportDataModel {
Key = string.Format("{0}-{1}", strQuarter, iYear), Value = 0.00m, Count = 0
};
var data = yearDataList.FirstOrDefault(x => x.X_Axis == strQuarter);
if (data != null)
{
tempData.Value = data.Value;
tempData.Count = data.Count;
}
dbDataList.Add(tempData);
}
dicData.Add(iYear.ToString(), dbDataList);
}
return(dicData);
}
public void VerifiedChartViewData_Year(int index, WidgetType type, ChartView view, string title)
{
//#01. Get data from UI.
_driverManager.NavigateTo(PageAlias.Dashboard_Home);
var homePage = GatekeeperFactory.CreatePageManager <HomePage>(_driverManager.Driver);
var toolBar = homePage.ToolBar;
//toolBar.Action_SelectView(ChartView.Year);
toolBar.Action_SelectView(view);
homePage.ChartSections.ForEach(x => x.Expand = false);
var chartSection = homePage.ChartSections[index];
chartSection.Expand = true;
if (!string.IsNullOrEmpty(title))
{
Assert.Equal(title, chartSection.DetailBar.Name);
}
var widgetItems = chartSection.MetricItems.Where(x => x.Selected);
var widgetItemIds = new List <string>();
foreach (var item in widgetItems)
{
widgetItemIds.Add(item.Id);
}
var chartView = chartSection.ChartView;
//#02. Get data from DB.
var dbDataDic = new Dictionary <string, List <ReportDataModel> >();
switch (view)
{
case ChartView.Year:
dbDataDic = GetDataFromDB_Year(widgetItemIds, type);
break;
case ChartView.Quarter:
dbDataDic = GetDataFromDB_Quarter(widgetItemIds, type);
break;
case ChartView.Month:
dbDataDic = GetDataFromDB_Month(widgetItemIds, type);
break;
case ChartView.Week:
break;
}
//#03. Compare data.
foreach (var dbData in dbDataDic)
{
var year = dbData.Key;
foreach (var item in dbData.Value)
{
Assert.Equal(item.Value, chartView[item.X_Axis, item.Year] ?? 0);
}
}
//foreach (var dbData in dbDataList)
//{
// Assert.Equal(dbData.Value, chartView[dbData.Key]);
//}
}
private void InitializeGenerated()
{
//WidgetComponent = Path.StartsWith("http://") ? new MosaicWebPreviewWidget() : new AppWidget();
WidgetComponent = new AppWidget();
WidgetType = WidgetType.Generated;
Name = string.Empty;
}
protected WidgetSetting ( WidgetType widgetType, int ajaxCount )
: base ( )
{
this.widgetType = widgetType;
this.ajaxs = new AjaxSetting[ajaxCount < 0 ? 0 : ajaxCount];
for ( int index = 0; index < ajaxCount; index++ )
this.ajaxs[index] = new AjaxSetting ( );
}
public void setValueOfWidgetWithType(double value, WidgetType widgetType)
{
Widget widget = null;
int xbeePin = -1;
foreach (int pin in pinToWidgetMapping.Keys)
{
widget = (Widget)pinToWidgetMapping[pin];
if (widget.Type == widgetType)
{
xbeePin = pin;
break;
}
}
if (xbeePin > -1)
{
string command;
byte[] commandData;
switch (widgetType)
{
case WidgetType.Switch:
command = "D" + xbeePin;
commandData = new byte[] { value > 0 ? (byte)0x05 : (byte)0x04};
break;
default:
return;
}
RemoteATCommandRequestFrame frame = FrameBuilder.RemoteATCommandRequest
.setATCommandName(command)
.setATCommandData(commandData)
.setDestinationAddress64Bit(this.SourceAddress64Bit)
.setDestinationAddress16Bit(this.SourceAddress16Bit)
.Build() as RemoteATCommandRequestFrame;
coordinator.EnqueueFrame(frame, null);
}
}
/// <summary>
/// Draw the custom wizard.
/// </summary>
void OnGUI ()
{
// Load the saved preferences
if (!mLoaded) { mLoaded = true; Load(); }
NGUIEditorTools.SetLabelWidth(80f);
GameObject go = NGUIEditorTools.SelectedRoot();
if (go == null)
{
GUILayout.Label("You must create a UI first.");
if (GUILayout.Button("Open the New UI Wizard"))
{
EditorWindow.GetWindow<UICreateNewUIWizard>(false, "New UI", true);
}
}
else
{
GUILayout.Space(4f);
GUILayout.BeginHorizontal();
ComponentSelector.Draw<UIAtlas>(NGUISettings.atlas, OnSelectAtlas, GUILayout.Width(140f));
GUILayout.Label("Texture atlas used by widgets", GUILayout.MinWidth(10000f));
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
ComponentSelector.Draw<UIFont>(NGUISettings.font, OnSelectFont, GUILayout.Width(140f));
GUILayout.Label("Font used by labels", GUILayout.MinWidth(10000f));
GUILayout.EndHorizontal();
GUILayout.Space(-2f);
NGUIEditorTools.DrawSeparator();
GUILayout.BeginHorizontal();
WidgetType wt = (WidgetType)EditorGUILayout.EnumPopup("Template", mType, GUILayout.Width(200f));
GUILayout.Space(20f);
GUILayout.Label("Select a widget template to use");
GUILayout.EndHorizontal();
if (mType != wt) { mType = wt; Save(); }
switch (mType)
{
case WidgetType.Label: CreateLabel(go); break;
case WidgetType.Sprite: CreateSprite(go, mSprite); break;
case WidgetType.Texture: CreateSimpleTexture(go); break;
case WidgetType.Button: CreateButton(go); break;
case WidgetType.ImageButton: CreateImageButton(go); break;
case WidgetType.Toggle: CreateToggle(go); break;
case WidgetType.ProgressBar: CreateSlider(go, false); break;
case WidgetType.Slider: CreateSlider(go, true); break;
case WidgetType.Input: CreateInput(go); break;
case WidgetType.PopupList: CreatePopup(go, true); break;
case WidgetType.PopupMenu: CreatePopup(go, false); break;
case WidgetType.ScrollBar: CreateScrollBar(go); break;
}
}
}
public static string AddColour(Color colour, WidgetType type, string widgetText)
{
RandomNumberGenerator rng = new RNGCryptoServiceProvider();
byte[] tokenData = new byte[4];
rng.GetBytes(tokenData);
string randomChars = Convert.ToBase64String(tokenData);
string newWidgetText = widgetText;
string colourName = "";
// If we have already stored a colour like that...
bool foundKnownColour = false;
Color storedColour = Color.Empty;
foreach (Color c in _knownColours)
{
if (IsColourSimilar(colour, c))
{
foundKnownColour = true;
storedColour = c;
break;
}
}
// ... return its name
if (foundKnownColour)
{
return _colorToString[storedColour];
}
// If we haven't stored a colour like that, try and find its name
string knownColourName = "Unknown";
foreach (KnownColor kc in Enum.GetValues(typeof(KnownColor)))
{
Color known = Color.FromKnownColor(kc);
if (IsColourSimilar(colour, known))
{
knownColourName = known.Name;
break;
}
}
// If it has a system designated name, create a new name
if (knownColourName != "Unknown")
{
colourName = knownColourName.ToLower() + "_" + type.ToString().ToLower();
while (_knownColourDesignations.Contains(colourName))
{
rng.GetBytes(tokenData);
randomChars = Convert.ToBase64String(tokenData);
colourName += "_" + randomChars.ToLower();
StringBuilder sb = new StringBuilder();
foreach (char c in colourName)
{
if (char.IsLetterOrDigit(c))
sb.Append(c);
else if (c == '_')
sb.Append(c);
}
colourName = sb.ToString();
colourName = colourName.ToLower();
}
_knownColours.Add(colour);
_knownColourDesignations.Add(colourName);
_colorToString.Add(colour, colourName);
_stringToColor.Add(colourName, colour);
return colourName;
}
// Colour doesnt have a system defined name, create a different name
if (newWidgetText != null && newWidgetText != "")
{
var sb = new StringBuilder();
foreach (char c in newWidgetText)
{
if (char.IsLetterOrDigit(c))
sb.Append(c);
else if (c == '_')
sb.Append(c);
}
newWidgetText = sb.ToString();
newWidgetText = newWidgetText.ToLower();
colourName = type.ToString().ToLower() + "_" + newWidgetText.ToLower().Replace(" ", "");
while (_knownColourDesignations.Contains(colourName))
{
rng.GetBytes(tokenData);
randomChars = Convert.ToBase64String(tokenData);
colourName += "_" + randomChars.ToLower();
sb = new StringBuilder();
foreach (char c in newWidgetText)
{
if (char.IsLetterOrDigit(c))
sb.Append(c);
else if (c == '_')
sb.Append(c);
}
colourName = sb.ToString();
}
_knownColours.Add(colour);
_knownColourDesignations.Add(colourName);
_colorToString.Add(colour, colourName);
_stringToColor.Add(colourName, colour);
return colourName;
}
// And if all else fails
colourName = type.ToString().ToLower() + "_" + randomChars.ToLower();
while (_knownColourDesignations.Contains(colourName))
{
rng.GetBytes(tokenData);
randomChars = Convert.ToBase64String(tokenData);
colourName += "_" + randomChars.ToLower();
var sb = new StringBuilder();
foreach (char c in newWidgetText)
{
if (char.IsLetterOrDigit(c))
sb.Append(c);
else if (c == '_')
sb.Append(c);
}
colourName = sb.ToString();
}
_knownColours.Add(colour);
_knownColourDesignations.Add(colourName);
_colorToString.Add(colour, colourName);
_stringToColor.Add(colourName, colour);
return colourName;
}
Size GetGtkCheckButtonIndicatorSize (WidgetType widgetType)
{
int indicator_size = GetWidgetStyleInteger (widgets [(int)widgetType], "indicator-size");
return new Size (indicator_size, indicator_size);
}
public WidgetConfigModelBase Transform(WidgetType type, JObject config)
{
Type targetType = DefaultWidgetConfigTypes[type];
return(config.ToObject(targetType) as WidgetConfigModelBase);
}
/// <summary>
/// Draw the options for a Widget, depending on its type
/// </summary>
/// <param name="widgetType"></param>
/// <param name="widgetProperty"></param>
/// <param name="index"></param>
protected void DrawWidgetOptions(WidgetType widgetType, SerializedProperty widgetProperty, int index)
{
switch (widgetType)
{
case WidgetType.BATTERY: //Batteries
BatteryType batteryType = DrawBatteryTypePicker(index);
EditorGUI.indentLevel++;
if (batteryType == BatteryType.CUSTOM)
{
widgetProperty.FindPropertyRelative("BatteryCount").intValue = Math.Max(EditorGUILayout.IntField("Custom Count", widgetProperty.FindPropertyRelative("BatteryCount").intValue), 0);
}
else if (batteryType == BatteryType.RANDOM)
{
widgetProperty.FindPropertyRelative("MinBatteries").intValue = Math.Max(EditorGUILayout.IntField("Minimum Batteries", widgetProperty.FindPropertyRelative("MinBatteries").intValue), 0);
widgetProperty.FindPropertyRelative("MaxBatteries").intValue = Math.Max(EditorGUILayout.IntField("Maximum Batteries", widgetProperty.FindPropertyRelative("MaxBatteries").intValue), widgetProperty.FindPropertyRelative("MinBatteries").intValue);
}
break;
case WidgetType.INDICATOR: //Indicators
IndicatorLabel indicatorLabel = DrawIndicatorLabelPicker(index);
EditorGUI.indentLevel++;
if (indicatorLabel == IndicatorLabel.CUSTOM)
{
widgetProperty.FindPropertyRelative("CustomLabel").stringValue = EditorGUILayout.DelayedTextField("Custom Label", widgetProperty.FindPropertyRelative("CustomLabel").stringValue);
}
DrawIndicatorStatePicker(index);
break;
case WidgetType.PORT_PLATE: //Port Plates
PortPlateType type = DrawPortPlateTypePicker(index);
if (type == PortPlateType.CUSTOM)
{
EditorGUI.indentLevel++;
EditorGUILayout.BeginHorizontal();
EditorGUILayout.BeginVertical();
EditorGUILayout.PropertyField(widgetProperty.FindPropertyRelative("DVIPort"));
EditorGUILayout.PropertyField(widgetProperty.FindPropertyRelative("PS2Port"));
EditorGUILayout.PropertyField(widgetProperty.FindPropertyRelative("RJ45Port"));
EditorGUILayout.PropertyField(widgetProperty.FindPropertyRelative("StereoRCAPort"));
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical();
EditorGUILayout.PropertyField(widgetProperty.FindPropertyRelative("ParallelPort"));
EditorGUILayout.PropertyField(widgetProperty.FindPropertyRelative("SerialPort"));
EditorGUILayout.EndVertical();
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.BeginVertical();
EditorGUILayout.PropertyField(widgetProperty.FindPropertyRelative("ComponentVideoPort"));
EditorGUILayout.PropertyField(widgetProperty.FindPropertyRelative("CompositeVideoPort"));
EditorGUILayout.PropertyField(widgetProperty.FindPropertyRelative("HDMIPort"));
EditorGUILayout.PropertyField(widgetProperty.FindPropertyRelative("VGAPort"));
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical();
EditorGUILayout.PropertyField(widgetProperty.FindPropertyRelative("USBPort"));
EditorGUILayout.PropertyField(widgetProperty.FindPropertyRelative("ACPort"));
EditorGUILayout.PropertyField(widgetProperty.FindPropertyRelative("PCMCIAPort"));
EditorGUILayout.EndVertical();
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.PropertyField(widgetProperty.FindPropertyRelative("CustomPorts"), true);
break;
case WidgetType.TWOFACTOR:
EditorGUI.indentLevel++;
break;
case WidgetType.RANDOM: //Random Widget
EditorGUI.indentLevel++;
break;
case WidgetType.CUSTOM: //Custom Widget
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(widgetProperty.FindPropertyRelative("CustomQueryKey"));
EditorGUILayout.PropertyField(widgetProperty.FindPropertyRelative("CustomData"));
break;
}
EditorGUI.indentLevel--;
}
/// <summary>
/// Load all serialized values from editor prefs.
/// This is necessary because static values get wiped out as soon as scripts get recompiled.
/// </summary>
static void Load ()
{
mType = (WidgetType)EditorPrefs.GetInt("NGUI Widget Type", 0);
mScrollDir = (UIScrollBar.Direction)EditorPrefs.GetInt("NGUI Scroll Dir", 0);
int color = EditorPrefs.GetInt("NGUI Color", -1);
if (color != -1) mColor = NGUIMath.IntToColor(color);
mSprite = LoadString("NGUI Sprite");
mButton = LoadString("NGUI Button");
mImage0 = LoadString("NGUI Image 0");
mImage1 = LoadString("NGUI Image 1");
mImage2 = LoadString("NGUI Image 2");
mImage3 = LoadString("NGUI Image 3");
mCheckBG = LoadString("NGUI CheckBG");
mCheck = LoadString("NGUI Check");
mSliderBG = LoadString("NGUI SliderBG");
mSliderFG = LoadString("NGUI SliderFG");
mSliderTB = LoadString("NGUI SliderTB");
mInputBG = LoadString("NGUI InputBG");
mListFG = LoadString("NGUI ListFG");
mListBG = LoadString("NGUI ListBG");
mListHL = LoadString("NGUI ListHL");
mScrollBG = LoadString("NGUI ScrollBG");
mScrollFG = LoadString("NGUI ScrollFG");
mScrollCL = EditorPrefs.GetBool("NGUI ScrollCL", true);
}
//----------------------------------------------------------
//--------------------- CONSTRUCTEURS ----------------------
//----------------------------------------------------------
public CoronaWidget(string name, WidgetType type, CoronaLayer layerParent)
{
this.Name = name;
this.Type = type;
this.LayerParent = layerParent;
}
public override void AttachStyle (WidgetType widgetType, IntPtr drawable, GtkPlus gtkPlus)
{
gtkPlus.tool_bar_toggle_button_style = gtk_style_attach (gtkPlus.tool_bar_toggle_button_style, drawable);
}
/// <summary>
/// Draw the custom wizard.
/// </summary>
void OnGUI()
{
// Load the saved preferences
if (!mLoaded)
{
mLoaded = true;
Load();
#if DYNAMIC_FONT
Object font = NGUISettings.ambigiousFont;
mType = ((font != null) && (font is UIFont)) ? UILabelInspector.FontType.NGUI : UILabelInspector.FontType.Unity;
#else
mType = UILabelInspector.FontType.NGUI;
#endif
}
NGUIEditorTools.SetLabelWidth(80f);
GameObject go = NGUIEditorTools.SelectedRoot();
if (go == null)
{
GUILayout.Label("You must create a UI first.");
if (GUILayout.Button("Open the New UI Wizard"))
{
EditorWindow.GetWindow <UICreateNewUIWizard>(false, "New UI", true);
}
}
else
{
GUILayout.Space(4f);
GUILayout.BeginHorizontal();
ComponentSelector.Draw <UIAtlas>(NGUISettings.atlas, OnSelectAtlas, false, GUILayout.Width(140f));
GUILayout.Label("Texture atlas used by widgets", GUILayout.Width(10000f));
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
if (NGUIEditorTools.DrawPrefixButton("Font"))
{
if (mType == UILabelInspector.FontType.NGUI)
{
ComponentSelector.Show <UIFont>(OnFont);
}
else
{
ComponentSelector.Show <Font>(OnFont, new string[] { ".ttf", ".otf" });
}
}
#if DYNAMIC_FONT
GUI.changed = false;
if (mType == UILabelInspector.FontType.Unity)
{
NGUISettings.ambigiousFont = EditorGUILayout.ObjectField(NGUISettings.ambigiousFont, typeof(Font), false, GUILayout.Width(140f));
}
else
{
NGUISettings.ambigiousFont = EditorGUILayout.ObjectField(NGUISettings.ambigiousFont, typeof(UIFont), false, GUILayout.Width(140f));
}
mType = (UILabelInspector.FontType)EditorGUILayout.EnumPopup(mType, GUILayout.Width(62f));
#else
NGUISettings.ambigiousFont = EditorGUILayout.ObjectField(NGUISettings.ambigiousFont, typeof(UIFont), false, GUILayout.Width(140f));
#endif
GUILayout.Label("size", GUILayout.Width(30f));
EditorGUI.BeginDisabledGroup(mType == UILabelInspector.FontType.NGUI);
NGUISettings.fontSize = EditorGUILayout.IntField(NGUISettings.fontSize, GUILayout.Width(30f));
EditorGUI.EndDisabledGroup();
GUILayout.Label("font used by the labels");
GUILayout.EndHorizontal();
NGUIEditorTools.DrawSeparator();
GUILayout.BeginHorizontal();
WidgetType wt = (WidgetType)EditorGUILayout.EnumPopup("Template", mWidgetType, GUILayout.Width(200f));
GUILayout.Space(20f);
GUILayout.Label("Select a widget template to use");
GUILayout.EndHorizontal();
if (mWidgetType != wt)
{
mWidgetType = wt; Save();
}
switch (mWidgetType)
{
case WidgetType.Label: CreateLabel(go); break;
case WidgetType.Sprite: CreateSprite(go); break;
case WidgetType.Texture: CreateSimpleTexture(go); break;
case WidgetType.Button: CreateButton(go); break;
case WidgetType.ImageButton: CreateImageButton(go); break;
case WidgetType.Toggle: CreateToggle(go); break;
case WidgetType.ProgressBar: CreateSlider(go, false); break;
case WidgetType.Slider: CreateSlider(go, true); break;
case WidgetType.Input: CreateInput(go); break;
case WidgetType.PopupList: CreatePopup(go, true); break;
case WidgetType.PopupMenu: CreatePopup(go, false); break;
case WidgetType.ScrollBar: CreateScrollBar(go); break;
}
EditorGUILayout.HelpBox("Widget Tool has become far less useful with NGUI 3.0.6. Search the Project view for 'Control', then simply drag & drop one of them into your Scene View.", MessageType.Warning);
}
}
void Paint (WidgetType widgetType, Rectangle bounds, IDeviceContext dc, Rectangle clippingArea, Painter painter)
{
Paint (widgetType, bounds, dc, TransparencyType.Alpha, Color.Black, DeviceContextType.Native, clippingArea, painter, Rectangle.Empty);
}
internal DDContainer(Instance inst, FString name, Layout parent, WidgetType type)
: base(inst, name, parent, type)
{
}
void Paint (WidgetType widgetType, Rectangle bounds, IDeviceContext dc, TransparencyType transparencyType, Color background, DeviceContextType deviceContextType, Rectangle clippingArea, Painter painter, Rectangle excludedArea)
{
Rectangle painted_area = Rectangle.Intersect (bounds, clippingArea);
if (painted_area.Width == 0 || painted_area.Height == 0)
return;
painted_area.Offset (-bounds.X, -bounds.Y);
excludedArea.Offset (-bounds.X, -bounds.Y);
GdkDrawablePointer drawable = gdk_pixmap_new (IntPtr.Zero, bounds.Width, bounds.Height, 24);
painter.AttachStyle (widgetType, drawable, this);
GdkPixbufPointer pixbuf;
IntPtr pixel_data;
int rowstride;
GdkGCPointer gc = gdk_gc_new (drawable);
GdkColor color = new GdkColor (background);
gdk_gc_set_rgb_fg_color (gc, ref color);
Paint (drawable, gc, bounds, widgetType, out pixbuf, out pixel_data, out rowstride, painted_area, painter, excludedArea);
GdkPixbufPointer white_pixbuf = IntPtr.Zero;
IntPtr white_pixel_data = IntPtr.Zero;
int white_rowstride = 0;
GdkColor white_color = new GdkColor();
if (transparencyType == TransparencyType.Alpha) {
white_color.red = guint16.MaxValue;
white_color.green = guint16.MaxValue;
white_color.blue = guint16.MaxValue;
gdk_gc_set_rgb_fg_color (gc, ref white_color);
Paint (drawable, gc, bounds, widgetType, out white_pixbuf, out white_pixel_data, out white_rowstride, painted_area, painter, excludedArea);
}
g_object_unref (gc);
unsafe {
byte* row = (byte*)pixel_data;
byte* pixel;
byte* white_row = (byte*)white_pixel_data;
byte* white_pixel;
for (int row_index = 0; row_index < painted_area.Height; row_index++) {
pixel = row;
white_pixel = white_row;
for (int pixel_index = 0; pixel_index < painted_area.Width; pixel_index++) {
const int GdkRedOffset = 0;
const int GdkGreenOffset = 1;
const int GdkBlueOffset = 2;
const int BitmapAlphaOffset = 3;
const int BitmapRedOffset = 2;
const int BitmapBlueOffset = 0;
switch (transparencyType) {
case TransparencyType.Alpha:
pixel [BitmapAlphaOffset] = (byte)(pixel [GdkRedOffset] - white_pixel [GdkRedOffset] + byte.MaxValue);
break;
case TransparencyType.Color:
if (
pixel [GdkRedOffset] == background.R &&
pixel [GdkGreenOffset] == background.G &&
pixel [GdkBlueOffset] == background.B) {
const int AlphaFullyTransparent = 0;
pixel [BitmapAlphaOffset] = AlphaFullyTransparent;
}
break;
}
byte temporary = pixel [GdkRedOffset];
pixel [BitmapBlueOffset] = pixel [GdkBlueOffset];
pixel [BitmapRedOffset] = temporary;
const int PixelSize = 4;
pixel += PixelSize;
white_pixel += PixelSize;
}
row += rowstride;
white_row += white_rowstride;
}
}
if (transparencyType == TransparencyType.Alpha)
g_object_unref (white_pixbuf);
g_object_unref (drawable);
Bitmap bitmap = new Bitmap (painted_area.Width, painted_area.Height, rowstride, PixelFormat.Format32bppPArgb, pixel_data);
Graphics g;
bool graphics_is_from_hdc = false;
switch (deviceContextType) {
case DeviceContextType.Graphics:
g = (Graphics)dc;
break;
case DeviceContextType.Native:
g = Graphics.FromHdc (dc.GetHdc ());
break;
default:
g = dc as Graphics;
if (g == null) {
graphics_is_from_hdc = true;
g = Graphics.FromHdc (dc.GetHdc ());
} else
graphics_is_from_hdc = false;
break;
}
painted_area.Offset (bounds.X, bounds.Y);
g.DrawImage (bitmap, painted_area.Location);
switch (deviceContextType) {
case DeviceContextType.Graphics:
break;
case DeviceContextType.Native:
g.Dispose ();
dc.ReleaseHdc ();
break;
default:
if (graphics_is_from_hdc) {
g.Dispose ();
dc.ReleaseHdc ();
}
break;
}
bitmap.Dispose ();
g_object_unref (pixbuf);
}
public void CreateWidget(WidgetType type)
{
Widget widget = new Widget(type);
Field.AddWidget(widget);
}
public virtual void AttachStyle (WidgetType widgetType, GdkDrawablePointer drawable, GtkPlus gtkPlus)
{
gtkPlus.styles [(int)widgetType] = gtk_style_attach (gtkPlus.styles [(int)widgetType], drawable);
}
public WidgetItemStock()
{
_type = WidgetType.None;
_numberOfUnits = 0;
}
public override void AttachStyle (WidgetType widgetType, IntPtr drawable, GtkPlus gtkPlus)
{
gtkPlus.tree_view_column_button_style = gtk_style_attach (gtkPlus.tree_view_column_button_style, drawable);
}
public WidgetItemStock(WidgetType type, int numberOfUnits)
{
_type = type;
_numberOfUnits = numberOfUnits;
}
//----------------------------------------------------------
//--------------------- CONSTRUCTEURS ----------------------
//----------------------------------------------------------
public CoronaWidget(string name, WidgetType type, CoronaLayer layerParent)
{
this.Name = name;
this.Type = type;
this.LayerParent = layerParent;
}
public SmallWidgetOptions SetType(WidgetType t)
{
Type = t;
return(this);
}
