könnt ihr mir sagen wie ich eine Benutzerdefinierte Oberfläche mit Mono for Android erzeuge. Ich möchte einen Media Player schreiben. Gibt es da ähnliche möglichkeiten wie in WPF oder muss ich HTML mit Bildern benutzen ? Wenn jaa wie bind ich das ein ??
ich habe nur eine ganz kurze Frage:
"Wenn ich mit Mono for Android eine Anwendung erstelle, wie wird dan die Laufzeitumgebung auf den Android installiert ? Für eine kleine App ist schon eine seperate Installation ein hindernis für die Benutzer."
Das Argument ist vill doch aus einen anderen Grund leer. Die Methode AppDomain.Load sollte laut msdn nicht dafür verwendet werden um eine Assembly in eine AppDomain zu laden, die nicht die Ausführende ist. How to: Load Assemblies into an Application Domain
5-10 € kommt vill bei vWorker & co rum. Das ist für mich kein normaler Stundenlohn. Da kann man gleich nach Ghana ziehen oder im Lager arbeiten.
In vielen anderen Berufen wo ein Stundenlohn von 9 - 14 € normal ist hat man höchstens 3 Jahre gelernt und danach ist alles nur Routine. Als Entwickler lernst du dein ganzen Leben. Wer infomiert, verbessert sich leidenschaftlich, damit man finanziell mit Leuten die weniger machen gleichgestellt wird ?
Ich würde das nehmen was man rausbekommt. Ist für dich besser und für den Markt.
Wenn du eine assembly nicht über seinen pfad sondern direkt als byte array lädst, hat die assembly keinen vollständigen Namen (Fully Qualified assembly name). Deshalb ist in der AssemblyResolve methode ResolveEventArgs argument gleich null.
Load(AssemblyName.GetAssemblyName(path))
Im AssemblyResolve Event kanst du dan die Assembly so laden wie du
es bisher machst und diese dan zurückgeben.
Hallo herbivore,
viele Stühle lassen sich auch Winkel verstellen, das sogar Elektronisch.
Die Tastatur und der Bildschirm müsste an irgendeiner Konstruktion befestigt sein die sich relativ dynamisch verstellen läst. Das mit der Maus wird dann etwas schwierig, da gibt es aber auch Alternativen.
Hallo t2t,
werde auf jeden Fall meine Erfahrungen berichten, wenn ich alles habe.
Hallo Tefnut,
mache Sport der sogar besonders den Rücken beansprucht, 1h gleichen aber nicht den Rest des Tages aus. Und ein Ball ist mir zu unbequem ^^
Sieht nett aus. Bin Handwerklich nicht allzu begabt. Werd mich mal beim Saturn & co umschauen. Da gibt diese Massagestühle die teilweise in alle Richtungen verstellbar sind, vielleicht findet man da ja einen passenden.
Genial !!! Leider habe ich auch keine 40.000 € übrig :(
Für ein Bruchteil des Geldes könnte man sich was anfertigen lassen oder auch selber bauen. Irgendwas mach bestimmt den ich habe absolut keine Lust mehr auf Bürostühle. Vor-allem diese ergonomischen sind völlig unbequem und ich kann es auch nicht lassen mich nach vorn zu lehnen um 2cm vor den Bildschirm zu hängen.
ich bin auf der Suche nach einen Liegestuhl. Müsste gesünder für die Schultern, Rücken sein und bequemer dürfte es dadurch auch werden.
Am besten so einen wie der etwas beleibte in Stirb langsam 4.0 im Keller stehen hat. Leinwand wäre auch schön, dürfte aber die Augen zu stark beanspruchen.
Hab nur den hier "Surf Chair" gefunden ... Gibt es aber nicht zu kaufen.
Hab mir das so vorgestellt das das Keyboard und die Mouse auf einer Oberfläche mit Gelenkarm liegen die beim zurück fahren vor einen sind. Vorne am Stuhl sollte es die Möglichkeit geben den Bildschirm aufzustellen.
habe nur sehr oberflächliche Kenntnisse vom SQL Kontext. Ich möchte sehr ungerne wegen dieser Kleinigkeit mich lange mit TSQL befassen (das hat später noch Zeit). Hab mir schon paar links angeschaut. Irrelang !
danke für eure Antworten,
ich wollte eingleich auf nix genaues hinaus. Wollte einfach nur meine Meinung sagen :) und vill ist ja Mono wirklich eine alternative.
Hi,
ich bin grade dabei mich mit Unix zu beschäftigen. Was mich an einen kompletten umstieg auf eine Linux- Distribution hindert ist das .NET Framework.
Klar gibt es Mono, aber wenn ich auf Unix mit .NET arbeiten möchte muss ich bestimmt die Namensräume und Klassen von Mono kennenlernen. Außerdem bin ich mit Visual Studio sehr zufrieden und ich bin mir nicht sicher ob es in der Linux- Welt eine bessere oder gleichzusetzende IDE gibt.
Mono ist leider auch nicht auf dem aktuellsten Stand und ich bezweifle mal das es wirklich stabil läuft (Ich möchte keine vorurteile in die Welt setzten, wenn das nicht stimmt könnt ihr mich auch gerne berichtigen). Mono an sich ist einer super Projekt doch könnte mann das nicht einfacher umsetzten ? Microsoft könnte ein wenig dazu beisteuern.
Microsoft könnte auch ihre Quellcodes veröffentlichen, damit das portieren leichter fällt (Nervt auch wenn mann einfach mal reinschauen muss. Reflector zeigt mir auch nicht immer den Quellcode). Es kann doch nur in Microsofts Interesse sein .NET möglichst zugänglich zu machen, damit es irgendwann mal Java ablösen kann.
das Ziel ist über einen Dialog verschiedene Infomationen zu Fenstern
einzugeben. Danach soll ein Bild einer Fensteranlage erstellt werden.
Siehe Anhang...
Erstmal nur eckige Fenster, später auch Bogenfenster und weitere Exoten.
Bei den Bild sollen Abmessung automatisch für die ganze Anlage und pro Fenster erstellt werden.
Bei jedem Fenster sollen folgende Angaben zur verfügung stehen.
1. X Postion oder Column
2. Y Postion oder Row
3. Breite
4. Höhe
5. Auf welcher Seiten kann das Fenster geöffnet werden.
6. Auf welcher Seiten ist die Bedienung um das Fenster zu öffnen.
7. Ist überhaupt ein "Beschlag? auf den Rahmen". Ohne Öffnung wäre der nicht nötig.
8. Wie Breit ist der Beschlag (Ich bin mir nicht sicher wie das Ding heißt was auf den Rahmen sitzt.)
Beim zusammenführen der Fenster zu einer Fensteranlage müssen noch kleinigkeiten berücksichtigt werden. z.B Wenn 2 Fenster die selbe Höhe haben und genau nebeneinander sind, wird auf der Seite wo sich diese berühren nicht mit einen Rahmen abgeschlossen sondern durch eine Stelze getrennt.
Das Ziel meines Beitrags soll sein, herauszufinden ob mein Klassendesin sinn macht. Ob es da nicht schönere oder einfachere Umsetzung gibt. Vill findet mann ja Opensource oder jemand von euch hatte schon eine ähnliche Lösung die mir helfen kann. Vielleicht sollte mann eine ganz andere Technologie verwenden. Am besten alles was einen einfällt um mir die Sache zu erleichtern.
Die Lösung wirkt recht Simple, mann stößt aber stendig an irgenwelche Probleme. Damit meine ich die Sache mit den Linien.
Auserdem stört mich das ich mit jeder weiteren Drawing Klasse mehr zu rechnen habe, das weist auf eine Design Schwäche hin oder nicht. Hier mal ein Auschnitt von diesen Wirwar...
Hallo Chilic,
das mit "Pen.Width / 2 Pixel" den mache ich bereits.
//Int ungerade Pinselgröße
//Rectangle ist aussen...
Pen pen1rect = new Pen(Color.FromArgb(100, 34, 117, 76), 5);
Pen pen1line = new Pen(Color.FromArgb(100, 0, 0, 250), 5);
e.Graphics.FillRectangle(Brushes.Red, new Rectangle(box1.Location.X, box1.Location.Y, box1.Width, box1.Height));
e.Graphics.DrawRectangle(pen1rect, new Rectangle(box1.Location.X, box1.Location.Y, box1.Width, box1.Height));
e.Graphics.DrawLine(pen1line, new Point(box1.Location.X, box1.Location.Y),
new Point(box1.Location.X + box1.Width, box1.Location.Y + box1.Height));
//Float ungerade Pinselgröße
//Macht alles komplizierter
Pen pen2rect = new Pen(Color.FromArgb(100, 34, 117, 76), 5);
Pen pen2line = new Pen(Color.FromArgb(100, 0, 0, 250), 5);
e.Graphics.FillRectangle(Brushes.Red, new RectangleF(box3.Location.X + pen2rect.Width / 2, box3.Location.Y + pen2rect.Width / 2, box3.Width - pen2rect.Width / 2, box3.Height - pen2rect.Width / 2));
e.Graphics.DrawRectangle(pen2rect, (float)box3.Location.X + pen2rect.Width / 2, (float)box3.Location.Y + pen2rect.Width / 2, (float)box3.Width - pen2rect.Width / 2, (float)box3.Height - pen2rect.Width / 2);
e.Graphics.DrawLine(pen2line, new PointF(box3.Location.X, box3.Location.Y),
new PointF(box3.Location.X + box3.Width, box3.Location.Y + box3.Height));
Über sowas simples will mann sicht doch keine Gedanken machen. Wenn ich sage das ich ein Rectangle von 0 bis 100 Zeichnen will. Nicht von 0 - PenWidth / 2 bis 100 + PenWidth + PenWidth / 2. Das es mit int und 5 als PenWidth unsauber wird verstehe ich ja noch.
Ich habe die Aufgabe ein Modul zu erstellen, was Fenster CAD Zeichnung erstellen soll. Ich habe bereits 2 Lösungen erstellt die ich verwerfen musste.
[B]1 Versuch [/B]Alles in eine Klasse gestopft und direkt gezeichnet.
[FRAME]
[B][COLOR]Problem[/COLOR][/B]
Der Code war sehr unübersichtlich. Das Erweitern oder Verändern war kaum möglich. Ich poste hier mal nicht den Quellcode :D
[/frame]
[B]2 Versuch[/B]
Drawing Klasse => Fenster Klasse => FensterContext Klasse
Fenster Klasse zeichnet mehrere Drawing Objekte.
Fenster Context zeichnet mehrere Fenster Objekte
[FRAME]
[COLOR][B]Klassen Konstruktoren[/B][/COLOR]
Drawing Objekt
[csharp]DrawingRectangle rectangle = new DrawingRectangle(Points coordinates, Painting style);[/csharp]
Fenster Objekt
[csharp]Fenster fenster1 = new Fenster(float x, float y, float width, float height, BedienseitenFlag bedienungsSeiten, OeffnungsSeitenFlag oeffnungsSeiten, float rahmenBreite, float beschlagBreite, float stelzenBreite);[/csharp]
FensterContext Objekt
[csharp]FensterContext context = new FensterContext(Fenster[] fenster);[/csharp]
[COLOR][B]Basisklassen für den Überblick[/B][/COLOR]
Drawing
[csharp] public class DrawingBase
{
public DrawingBase() { IsVisible = false;}
public Image _Image { get { return DrawImage(); } }
public Points Coordinates { get; set; }
public Painting Style { get; set; }
public bool IsVisible { get; set; }
public string Description { get; set; }
public virtual void OnDraw(Graphics g) {}
private Image DrawImage()
{
Bitmap bitmap = new Bitmap(IsVisible ? (int)Coordinates.Width : 1, IsVisible ? (int)Coordinates.Height : 1);
if (IsVisible)
{
Graphics graphics = Graphics.FromImage(bitmap);
graphics.FillRectangle(Style.BackgroundBrush, new Rectangle(0, 0, (int)Coordinates.Width, (int)Coordinates.Height));
OnDraw(graphics);
graphics.Dispose();
bitmap.MakeTransparent(Color.Magenta);
}
return bitmap;
}
}[/csharp]
Fenster
[csharp] public abstract class FensterBase
{
public FensterBase()
{
DrawingItems = new List<Drawing>();
}
public Image WindowImage { get { return DrawImage(); } }
public Points Coordinates { get; set; }
public Painting Style { get; set; }
public List<Drawing> DrawingItems { get; private set; }
public virtual void InitializeImage() { }
public Image DrawImage()
{
Bitmap bitmap = new Bitmap((int)Coordinates.Width, (int)Coordinates.Height);
Graphics graphics = Graphics.FromImage(bitmap);
foreach (Drawing drawing in DrawingItems)
if (drawing != null && drawing.IsVisible)
graphics.DrawImage(drawing.DrawingImage, new PointF(drawing.Coordinates.X, drawing.Coordinates.Y));
graphics.Dispose();
return bitmap;
}
}[/csharp]
FensterContext
[csharp] public abstract class FensterContextBase
{
public Image ContextImage { get { return DrawImage(); } }
public Painting Style { get; set; }
public List<Fenster> FensterItems { get; set; }
public int Width { get; private set; }
public int Height { get; private set; }
public Image DrawImage()
{
float width = 0;
float height = 0;
foreach (Fenster fenster in FensterItems)
{
float fensterWidth = fenster.Coordinates.X + fenster.Coordinates.Width;
float fensterHeight = fenster.Coordinates.Y + fenster.Coordinates.Height;
if (fensterWidth > width)
width = fensterWidth;
if (fensterHeight > height)
height = fensterHeight;
}
Bitmap bitmap = new Bitmap((int)width, (int)height);
Graphics graphics = Graphics.FromImage(bitmap);
foreach (Window window in FensterItems)
graphics.DrawImage(window.WindowImage, new PointF(window.Coordinates.X, window.Coordinates.Y));
graphics.Dispose();
return bitmap;
}
}[/csharp]
[COLOR][B]Problem[/B][/COLOR]
Die Linien werden nicht immer gezeichnet oder sie haben einen Schatten.
Ich versuche ich immer die Linien in der Mitte zu zeichnen, weil es für mich keinen Sinn ergibt das sie immer nach unten Rechts gezeichnet werden. Deshalb Zeichne nur über Graphics.DrawLine oder Graphics.DrawPolygon und ziehe Linien Breite / 2 bei Width und Height ab und addiere sie bei X und Y. Das setzt voraus das ich float statt int benutze. Hier liegt wohl das Problem.
[csharp]
graphics.DrawLine(myPen, x + myPen.Width / 2, y + myPen.Width / 2, width - myPen.Width / 2, height - myPen.Width / 2);
[/csharp]
Durch das Zeichnen in der Mitte wird gibt es fälle wo die Zeichenlogik schwer zu durchschauen ist z.B simple Pfeile die nicht Width x Height sind werden völlig krunkelig. Linien nach innen wäre wohl auch eine möglichkeit. Was mach ich aber wenn ich kein Rectangle zeichne sondern eine Diagonale Linie.
[/frame]
Irgendwie hab ich das Gefühl das die 2 Lösung auch nicht das Gelbe vom Ei ist. WPF wäre wohl eine Alternative die sehr vieles erleichtern würde oder ? Sieht auch schöner aus da alles geglättet ist ohne zu verschwimmen.
Habt ihr schon Erfahrungen gemacht die mir weiterhelfen könnte, anderen Aufbau, die Lienen- Sache. unsw.. unsw...
Finde Mono.Cecil auch super, hatte auch schon einiges damit gemacht.
Wäre nur schon Reflection zu benutzen, da Cecil noch paar Kanten hat und
ich möchte nicht mit einen Flagschiff immer auf Spatzen schießen.
Ich möchte eine Assembly im AssemblyBuilder abbilden, um sie dort zu manipulieren und wieder zu speichern. Ich denke nicht das dies funktioniert oder ?
Mann könnte doch aber alle Typen eines Moduls durchlaufen und im Modulbuilder erstellen. Das ist sicher aufwendig. Hat sich jemand schon die Mühe gemacht ?
Das kann man auch schön erkennen, wenn man z.B. einen Button mit einem langen Prozess auf die GUI legt, bleibt der Button eingedrückt bis die Aktion abgeschlossen ist.
Das wäre wohl anderes auch nicht möglich. Der Button wird aber trotzdem neu gezeichnet, auch wenn er so lange verhaart bis die Aktion abgeschlossen ist.
Das sieht man am besten wenn man den GUI Thread arbeiten schickt und dann mit einen anderen Fenster drüber fährt. Bei Windows Forms hast mann dann ein buntes Fenster. Das wird dann aber wahrscheinlich irgendwo in der Milcore Bibliothek geregelt.
Das verhalten ist irgendwie eigenartig. Habe mal in der Main Methode folgendes versucht. Erst wenn die Application Klasse eine "MessageLoop?" erstellt, werden die Fenster aktualisiert. Das hat wohl eher nix wie in meiner vorherigen Vermutung mit den "Zeichenthread" zu tun.
[System.STAThreadAttribute()]
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public static void Main() {
MainWindow window = new MainWindow();
window.label1.Content = "Me";
Thread.Sleep(10000);
//WpfApplication1.App app = new WpfApplication1.App();
//app.Run();
}
WPF hat 2 Threads. Einen womit du arbeitest und einen der alles Zeichnet. Damit die Benutzeroberfläche nicht mehr einfriert beim Zeitaufwändigen unterfangen.
Du musst vermutlich die OnStartup Methode von der Application class aufrufen, damit der Zeichenthread startet.
DataContext musst du nicht angeben. Der gilt dann für alle Unterelemente der Textbox als Datenquelle, solange nix anderes bei den Unterelementen angegeben ist.
Du kannst Source verwenden um die Datenquelle anzugeben.
In Binding Path ist die Eigenschaft als Name hinterlegt. Bei DataContext und bei Source die Instanz.
ObservableEntityCollection für das Entity Framework
Nachdem mir aufgefallen ist, das ich mit den ObjectSet von Entity Framework
kein 2 Way Binding zu einen WPF Control machen kann, weil es nicht von ICollectionChanged erbt hab ich folgendes geschrieben.
public class ObservableEntityCollection<TEntity> : ObservableCollection<TEntity> where TEntity : class
{
private ObjectSet<TEntity> _objectSet = null;
public delegate int SaveChangesMethod();
private SaveChangesMethod SaveChanges = null;
public ObservableEntityCollection(ObjectSet<TEntity> entity)
{
Init(entity, null);
}
public ObservableEntityCollection(ObjectSet<TEntity> entity, SaveChangesMethod SaveChanges)
{
Init(entity, SaveChanges);
}
private void Init(ObjectSet<TEntity> entity, SaveChangesMethod SaveChanges)
{
this._objectSet = entity;
this.SaveChanges = SaveChanges;
foreach (var item in _objectSet)
{
if (item is INotifyPropertyChanged)
{
INotifyPropertyChanged notifyPropertyChanged = item as INotifyPropertyChanged;
notifyPropertyChanged.PropertyChanged += new PropertyChangedEventHandler(notifyPropertyChanged_PropertyChanged);
}
base.InsertItem(this.Count, (TEntity)item);
}
}
void notifyPropertyChanged_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
TEntity _objectSetItem = (TEntity)sender;
SetItem(this.IndexOf(_objectSetItem), _objectSetItem);
}
protected override void InsertItem(int index, TEntity item)
{
if (_objectSet == null)
return;
_objectSet.AddObject(item);
if (SaveChanges != null)
SaveChanges();
base.InsertItem(index, item);
}
protected override void SetItem(int index, TEntity item)
{
if (_objectSet != null)
return;
var _objectSetItem = _objectSet.ElementAt(index);
if (_objectSetItem != null)
_objectSetItem = item;
if (SaveChanges != null)
SaveChanges();
base.SetItem(index, item);
}
protected override void RemoveItem(int index)
{
if (_objectSet != null)
return;
var _objectSetItem = _objectSet.ElementAt(index);
if (_objectSetItem != null)
_objectSet.DeleteObject(_objectSetItem);
if (SaveChanges != null)
SaveChanges();
base.RemoveItem(index);
}
protected override void MoveItem(int oldIndex, int newIndex)
{
if (_objectSet != null)
return;
var _objectSetItemOld = _objectSet.ElementAt(oldIndex);
if (_objectSetItemOld != null)
{
var _objectSetItemNew = _objectSet.ElementAt(newIndex);
if (_objectSetItemNew != null)
_objectSetItemNew = _objectSetItemOld;
}
if (SaveChanges != null)
SaveChanges();
base.MoveItem(oldIndex, newIndex);
}
protected override void ClearItems()
{
foreach (var item in _objectSet)
{
_objectSet.DeleteObject(item);
}
if (SaveChanges != null)
SaveChanges();
base.ClearItems();
}
}
ObservableEntityCollection, ObservableCollection, Entity, Entity Framework, 2 Way Binding, WPF