DCSIMG
Maxim

Many developers that want to develop apps for Windows Phone 8 are required to install Windows 8 on their PCs, because Visual Studio 2012 that allows developing projects for Windows Phone 8 require this. Also, phone emulator in VS12 requires Hyper-V option that isn’t included in Windows 7. In this post I’ll explain how to avoid installing Windows 8 in order to run VS12 with phone emulator.

1. Get Windows Setup: If you don’t have your own installation of Windows 8 you can download it for free from Microsoft’s website: http://msdn.microsoft.com/en-us/evalcenter/jj554510.aspx

image

(You can download one of two available versions: 32 or 64 bit)

2. Get Virtual Machine: The best VM that I found running Win8 with VS12 and phone-emulator is VMware Player that can be downloaded from here: http://www.vmware.com/products/player

image

(Install the downloaded VMware Player before proceeding with next steps)

3. Install Windows 8 in VM: Player > File > New virtual Machine

image

3.1) Pick 2nd option and select downloaded ISO file with Windows 8 setup:

image

3.2) Enter new VM’s name and installation folder (keep in mind that you need about 20-30GB space on HD):

image

3.3) Use these defaults:

image

3.4) Before finishing this stage, click on ‘Customize Hardware’:

image

3.5) Minimum recommended memory size should be 2GB:

image

3.6) Define processor with 2 cores and ‘Virtualize Intel VT-x/EPT or AMD-V/RVI’ in Virtualization Engine:

image

(Selected virtualization engine is required to run phone-emulator. We’ll define an additional option that is required for this later)

3.7) Close HW dialog and click ‘Finish’ in this dialog:

image

(The Win8 setup will start after this)

4. Install Windows 8 on VM:

4.1) Define your language, time and keyboard setting and click ‘Next’:

image

4.2) Click ‘Install’ and continue with remained steps:

image

4.3) Click on 2nd button ‘Custom: Install Windows only (advanced)’ and proceed with remained:

image

4.4) Enter PC name and click ‘Next’:

image

4.5) Use ‘Express Settings’ or customize:

image

4.6) You can sign in without MS account or use your Live-ID (I used the last option in this guide):

image

4.7) Now we’re ready with Windows 8 on our VM. Click ‘I Finished Installing’ on bottom bar of the VM Player:

image

4.7.1) Install VMware tools that will make your work with VM easier: Player > Manage > Install VMware Tools:

image

4.7.2) Click on popup that asks what to do with inserted disk:

image

4.7.3) Run setup file:

image

4.7.4) Proceed with setup:

image

4.7.5) Don’t restart the system after finishing the setup:

image

4.8) Shutdown the system. Hit [Win + Q] on keyboard to open ‘Settings’ and click Power > Shut down to power-off:

image

5) Edit VM Settings: Let’s add some small ‘hack’ to allow HW Virtualization in VM Smile

image

(Click on ‘Edit virtual machine settings)

5.1) Go to ‘Options’ tab and copy ‘Working directory’ path [Ctrl + C]:

image

(Open copied path in Windows Explorer)

5.2) Locate file with ‘vmx’ extension and open it in some file editor:

image

5.3) Add hypervisor.cpuid.v0 = "FALSE" to existing settings and save file:

image

(Ensure that “ symbols with correct format and close the editor)

6) Let’s install VS12: Play VM:

image

6.1) Open IE:

image

6.2) Go to this web-page: http://www.microsoft.com/visualstudio/eng/products/visual-studio-express-for-windows-phone

image

(Click ‘Download’)

6.3) Pick preferred setup file for download:

image

(I preferred 1st ver. for this guide)

6.4) Execute setup by clicking ‘Run’ on bottom bar:

image

6.5) Proceed with VS12 Setup:

image

image

(Allow setup to restart system at the end)

7) Let’s Rock & Roll: Open ‘VS for Windows Phone’:

image

7.1) We can ignore registration for this time:

image

7.2) Create new project:

image

7.3) Pick ‘Windows Phone Panorama App’ or any other phone app:

image

7.4) Select ‘Windows Phone OS 8.0’:

image

7.5) Now we run our App in Emulator:

image

7.6) Because we didn’t ran VS in Admin Mode it will ask us to allow to access to some Hyper-V stuff:

image

(Click ‘Retry’)

7.7) Allow making changes (be nice):

image

7.8) Almost done. Allow emulator to access the Internet:

image

7.9) Ta-Da SmileNow we see phone-emulator running over Hyper-V inside our VM:

image

You can use all phone features:

image

Enjoy ;-)

Remarks: Any comments/improvements will be accepted with pleasure. Of course, you must understand that this code is a contribution and I’m not responsible for any damage that may be caused by using it. All rights reserved ®.

PS
This post was inspired by Tamir’s post about VS12 Setup Hack for Win7:
http://khason.net/tech/installation-of-windows-phone-sdk-8-0-on-windows-7

Compatibility Rules!
Posted by Maxim | with no comments

Congrats!

The eMap website started using Silverlight Technology for Interactive Maps:

emap0

emap1

Posted by Maxim | with no comments
תגים:, , ,
Lagoa Multiphysics 1.0 - Teaser

(thanks to tummy for sharing)

Technorati Tags: ,,,

At last days many .Net developers upgraded their Visual Studio to RTM 2010. There are some “Known Issues” in this release.
After painful upgrade we discovered problem in our WPF project: Some Dynamic Resources from Merged Dictionaries that referenced in App.xaml stopped working (although this code worked without any problems in Beta-2).
We found some workaround: Add some style without specific key for unused element in Resource Dictionary and this will trigger WPF to load resources from Merged Dictionaries.

Example:

<Application x:Class="SomeNamespace.App"
             xmlns=http://schemas.microsoft.com/winfx/2006/xaml/presentation
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
      <Application.Resources>
            <ResourceDictionary>
                  <ResourceDictionary.MergedDictionaries>
                        <ResourceDictionary Source="/SomeNamespace;Component/Styles.xaml"/>
                        <ResourceDictionary Source="/SomeNamespace;Component/Brushes.xaml"/>
                  </ResourceDictionary.MergedDictionaries>              

                  <Style TargetType="{x:Type Line}"/>
            </ResourceDictionary>
      </Application.Resources>
</Application>

In yellow: Merged Dictionaries.
In green: Dummy Style as Trigger.


Enjoy ;-)

Remarks: Any comments/improvements will be accepted with pleasure. Of course, you must understand that this code is a contribution and I’m not responsible for any damage that may be caused by using it. All rights reserved ®.

Some .Net applications are required to run as single instance process (at startup, each process “ensures” that he’s unique). This requirement may come from licensing issues, technical and/or other reasons. Quick search in Google will provide a variety of solutions, most of them are based on WindowsFormsApplicationBase object from VB.Net, usage of Mutex object and other techniques. I don’t like mixing VB with C#, and also Win-Forms solution isn’t “pure” enough for WPF applications. So I wrote my version of “Single Instance Manager”…

This post will provide short description about this small project and links to download the sources.

How to Create Single Instance Application for WPF, Win-Forms and Console Applications

The manager uses well-known ThreadPool object with WaitEventHandle object and IpcClientChannel to pass messages (objects) between processes (.Net Remoting).

Diagram: Pass object cross processes

[In Diagram: Instance A passes Console Arguments to Process B, before it closes it self]

Each application will use “ApplicationInstanceManager.CreateSingleInstance(…)” to register it self as single instance application.

image

[In Diagram: Description of “CreateSingleInstance(…)” Function]

The manager ensures that application has only one instance and also passes console arguments from new instances to running process, before “killing” them.

   1:  using System;
   2:  using System.Diagnostics;
   3:  using System.Runtime.Remoting;
   4:  using System.Runtime.Remoting.Channels;
   5:  using System.Runtime.Remoting.Channels.Ipc;
   6:  using System.Threading;
   7:   
   8:  namespace SingleInstanceApplication
   9:  {
  10:      /// <summary>
  11:      /// Application Instance Manager
  12:      /// </summary>
  13:      public static class ApplicationInstanceManager
  14:      {
  15:          /// <summary>
  16:          /// Creates the single instance.
  17:          /// </summary>
  18:          /// <param name="name">The name.</param>
  19:          /// <param name="callback">The callback.</param>
  20:          /// <returns></returns>
  21:          public static bool CreateSingleInstance(string name, EventHandler<InstanceCallbackEventArgs> callback)
  22:          {
  23:              EventWaitHandle eventWaitHandle = null;
  24:              string eventName = string.Format("{0}-{1}", Environment.MachineName, name);
  25:   
  26:              InstanceProxy.IsFirstInstance = false;
  27:              InstanceProxy.CommandLineArgs = Environment.GetCommandLineArgs();
  28:   
  29:              try
  30:              {
  31:                  // try opening existing wait handle
  32:                  eventWaitHandle = EventWaitHandle.OpenExisting(eventName);
  33:              }
  34:              catch
  35:              {
  36:                  // got exception = handle wasn't created yet
  37:                  InstanceProxy.IsFirstInstance = true;
  38:              }
  39:   
  40:              if (InstanceProxy.IsFirstInstance)
  41:              {
  42:                  // init handle
  43:                  eventWaitHandle = new EventWaitHandle(false, EventResetMode.AutoReset, eventName);
  44:   
  45:                  // register wait handle for this instance (process)
  46:                  ThreadPool.RegisterWaitForSingleObject(eventWaitHandle, WaitOrTimerCallback, callback, Timeout.Infinite, false);
  47:                  eventWaitHandle.Close();
  48:   
  49:                  // register shared type (used to pass data between processes)
  50:                  RegisterRemoteType(name);
  51:              }
  52:              else
  53:              {
  54:                  // pass console arguments to shared object
  55:                  UpdateRemoteObject(name);
  56:   
  57:                  // invoke (signal) wait handle on other process
  58:                  if (eventWaitHandle != null) eventWaitHandle.Set();
  59:   
  60:   
  61:                  // kill current process
  62:                  Environment.Exit(0);
  63:              }
  64:   
  65:              return InstanceProxy.IsFirstInstance;
  66:          }
  67:   
  68:          /// <summary>
  69:          /// Updates the remote object.
  70:          /// </summary>
  71:          /// <param name="uri">The remote URI.</param>
  72:          private static void UpdateRemoteObject(string uri)
  73:          {
  74:              // register net-pipe channel
  75:              var clientChannel = new IpcClientChannel();
  76:              ChannelServices.RegisterChannel(clientChannel, true);
  77:   
  78:              // get shared object from other process
  79:              var proxy =
  80:                  Activator.GetObject(typeof(InstanceProxy), 
  81:                  string.Format("ipc://{0}{1}/{1}", Environment.MachineName, uri)) as InstanceProxy;
  82:   
  83:              // pass current command line args to proxy
  84:              if (proxy != null)
  85:                  proxy.SetCommandLineArgs(InstanceProxy.IsFirstInstance, InstanceProxy.CommandLineArgs);
  86:   
  87:              // close current client channel
  88:              ChannelServices.UnregisterChannel(clientChannel);
  89:          }
  90:   
  91:          /// <summary>
  92:          /// Registers the remote type.
  93:          /// </summary>
  94:          /// <param name="uri">The URI.</param>
  95:          private static void RegisterRemoteType(string uri)
  96:          {
  97:              // register remote channel (net-pipes)
  98:              var serverChannel = new IpcServerChannel(Environment.MachineName + uri);
  99:              ChannelServices.RegisterChannel(serverChannel, true);
 100:   
 101:              // register shared type
 102:              RemotingConfiguration.RegisterWellKnownServiceType(
 103:                  typeof(InstanceProxy), uri, WellKnownObjectMode.Singleton);
 104:   
 105:              // close channel, on process exit
 106:              Process process = Process.GetCurrentProcess();
 107:              process.Exited += delegate { ChannelServices.UnregisterChannel(serverChannel); };
 108:          }
 109:   
 110:          /// <summary>
 111:          /// Wait Or Timer Callback Handler
 112:          /// </summary>
 113:          /// <param name="state">The state.</param>
 114:          /// <param name="timedOut">if set to <c>true</c> [timed out].</param>
 115:          private static void WaitOrTimerCallback(object state, bool timedOut)
 116:          {
 117:              // cast to event handler
 118:              var callback = state as EventHandler<InstanceCallbackEventArgs>;
 119:              if (callback == null) return;
 120:   
 121:              // invoke event handler on other process
 122:              callback(state,
 123:                       new InstanceCallbackEventArgs(InstanceProxy.IsFirstInstance,
 124:                                                     InstanceProxy.CommandLineArgs));
 125:          }
 126:      }
 127:  }
.csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; }

For testing purposes I added form with grid that allows starting processes with console arguments:

single instance manager

How can we use this manager (for example in WPF app):

   1:  using System;
   2:  using System.Reflection;
   3:  using System.Windows;
   4:   
   5:  namespace SingleInstanceApplication.WpfApp
   6:  {
   7:      /// <summary>
   8:      /// Interaction logic for App.xaml
   9:      /// </summary>
  10:      public partial class App
  11:      {
  12:          /// <summary>
  13:          /// Raises the <see cref="E:System.Windows.Application.Startup"/> event.
  14:          /// </summary>
  15:          /// <param name="e">A <see cref="T:System.Windows.StartupEventArgs"/> that contains the event data.</param>
  16:          protected override void OnStartup(StartupEventArgs e)
  17:          {
  18:              // register single instance app. and check for existence of other process
  19:              if (!ApplicationInstanceManager.CreateSingleInstance(
  20:                      Assembly.GetExecutingAssembly().GetName().Name,
  21:                      SingleInstanceCallback)) return; // exit, if same app. is running
  22:   
  23:              base.OnStartup(e);
  24:          }
  25:   
  26:          /// <summary>
  27:          /// Raises the <see cref="E:System.Windows.Application.Activated"/> event.
  28:          /// </summary>
  29:          /// <param name="e">An <see cref="T:System.EventArgs"/> that contains the event data.</param>
  30:          protected override void OnActivated(EventArgs e)
  31:          {
  32:              base.OnActivated(e);
  33:   
  34:              var win = MainWindow as MainWindow;
  35:              if (win == null) return;
  36:   
  37:              // add 1st args
  38:              win.ApendArgs(Environment.GetCommandLineArgs());
  39:          }
  40:   
  41:          /// <summary>
  42:          /// Single instance callback handler.
  43:          /// </summary>
  44:          /// <param name="sender">The sender.</param>
  45:          /// <param name="args">The <see cref="SingleInstanceApplication.InstanceCallbackEventArgs"/> instance containing the event data.</param>
  46:          private void SingleInstanceCallback(object sender, InstanceCallbackEventArgs args)
  47:          {
  48:              if (args == null || Dispatcher == null) return;
  49:              Action<bool> d = (bool x) => 
  50:              {
  51:                  var win = MainWindow as MainWindow;
  52:                  if (win == null) return;
  53:   
  54:                  win.ApendArgs(args.CommandLineArgs);
  55:                  win.Activate(x);
  56:              };
  57:              Dispatcher.Invoke(d, true);
  58:          }
  59:      }
  60:  }
.csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; }

[As you can see “App” has “SingleInstanceCallback” that is fired by manager, also you can see function overload for “Window.Actvate” (see this post about this extention)]

VS2010 Sources for this project can be downloaded from here (blog) or here (codeplex).
DLL + PDB Assembly with Library can be downloaded from here (blog) or here (codeplex).
image Project’s site at Codeplex: …

 Remarks: Any comments/improvements will be accepted with pleasure. Of course, you must understand that this code is a contribution and I’m not responsible for any damage that may be caused by using it. All rights reserved ®.

This solution can be used in WPF and in WinForms (with some improvements).

Many times UI programmer needs to activate window, the activation can be done by using “Activate()” function in window. The problem is that this function will not show window if it is minimized. In that case you can use this workaround:

using System;
using System.Windows; 

namespace Test
{
       public partial class MyWindow
       {
              /// <summary>
              /// Gets Previouse Window State
              /// </summary>
              public WindowState PreviouseWindowState { get; private set; }  

              /// <summary>
              /// Constructor
              /// </summary>
              public MyWindow()
              {
                     InitializeComponent();

 

                     // store 1st value
                     PreviouseWindowState = WindowState;

 

                     // attach to event (used to store prev. win. state)
                     LayoutUpdated += Window_LayoutUpdated;
              }  

              /// <summary>
              /// Occures on layout change
              /// </summary>
              /// <param name="sender"></param>
              /// <param name="e"></param>
              private void Window_LayoutUpdated(object sender, EventArgs e)
              {
                     PreviouseWindowState = WindowState;
              }  

              /// <summary>
              /// Activates Window
              /// </summary>
              /// <param name="restoreIfMinimized">if [true] restore prev. win. state</param>
              /// <returns></returns>
              public bool Activate(bool restoreIfMinimized)
              {
                     if (restoreIfMinimized && WindowState == WindowState.Minimized)
                     {
                           WindowState = PreviouseWindowState == WindowState.Normal
                                                                     ? WindowState.Normal : WindowState.Maximized;
                     }
                     return Activate();
              }
       }
} 

As you can see I added new overloaded function “Activate(bool)” that allows activation of minimized window, thanks to new property “PreviouseWindowState” that stores previous value of “WindowState” when “Window_LayoutUpdated” in called.

Source Code: Window.cs

Remarks: Any comments/improvements will be accepted with pleasure. Of course, you must understand that this code is a contribution and I’m not responsible for any damage that may be caused by using it. All rights reserved ®.

זהו פוסט המשך לפוסט הקודם, אשר שייך לסדרת הפוסטים בנושא UI . בפוסט זה אפרט שלבים וטיפים שיעזרו בבניה של מסמך סטנדרטים של ממשק משתמש.


GUI Standards Document

בפרויקטים גדולים של מערכות תוכנה עם ממשקי משתמש רבים קיים צורך בכתיבת מסמך סטנדרטים בתחילת הפרויקט. מסמך זה משמש את כל הגורמים המעורבים בעיצוב-פיתוח GUI: מנתחי מערכות (System Analysts), מעצבי מודולים (SW Designers) ומתכנתים (האנשים שבפועל בונים GUI ומקודדים לוגיקת קליינט).

מסמך סטנדרטים הנו מרכיב הכרחי בכל שלבי הפרויקט. לרוב עיצוב ראשוני (ובחלק מהמקרים סופי) של מסכי המערכת נעשה ע"י מנתחים. מכוון שהם נמצאים בחזית, ז"א מול לקוח. חלק מתהליך הניתוח והאפיון של הפרויקט הנו עיצוב UI שנעשה בשיתוף עם לקוח (ישנם מקרים חריגים שלקוח לא מעורב בתהליך הנ"ל). בפרויקטים גדולים מעורב מספר גדול של עובדים הקשורים לעיצוב ופיתוח UI. על מנת לקבוע סדר עבודה ותקנות ברורות שיעזרו לתהליך גם מבחינת צמצום זמני האפיון-פיתוח וגם מבחינת השמישות ה- GUI.

תרשים עם פעולות שיכולות לעזור בכתיבת המסמך והטמעתו:

  1. קבל את התחייבות הארגון לעבור דרך תהליך הסטנדרטיזציה: במילים אחרות קבל OK של הממונים שלך. חשוב שגם האנשים שיהיו צרכני המסמך יבינו את חשיבותו (אף אחד לא אוהב לבזבז זמן על משהו שלא ישמש אף אחד);
    -
  2. גייס תומכים לתהליך הסטנדרטיזציה: גייס את דעת הקהל. יתכן מצב שמספר עובדים לא יקבלו בהבנה את המסמך, יהיו אמירות כמו: "למה אנו צריכים את הדברים האלה?", "אנו יודעים לעבוד גם ללא המסמך!", "עד עכשיו הסתדרנו ללא המסמך!" וכו'. – לא אציג כאן את דרכי השכנוע, מאמין שמי שלוקח על עצמו את התפקיד של מהנדס UI/UX ומוכן לכתוב את המסמך יידע לשכנע בצורה טובה.
    -
  3. אסוף מידע: בצע איסוף מידע ממשתמשי הקצה (לקוח), על סביבת העבודה (באתר לקוח), תהליכים עסקיים, זרימת עבודה ומשימות, אסטרטגיה ארגונית וכו'. [זמנים: 2-3 ימים בממוצע]
  4. הגדר סוגי הסטנדרטים הנחוצים: בד"כ קובעם סטנדרטים עבור: מודל ארכיטקטוני של קליינט (MVC, MVP OR MVVM), סוגי הפקדים עבור סוגים שונים של מידע (Data Models, Data Sources), תקן של תבניות מידע קבועות בפרויקט (Data Templates), כללי נווט בין מסכים (מפת המסכים), מבנה של מסך ראשי, הכוונה למבנה כללי של טפסים, סוג ה- GUI (Tabular, Single Window, MDI Window, Multiple Window). לווה כל בדוגמאות. [זמנים: 5-10 ימים בממוצע]
    -
  5. הגדר מספר מסכים שיעוצבו בהתאם לסטנדרטים: בד"כ לא ניתן להחיל עיצוב לפי סטנדרטים על כל המסכים במערכות גדולות, השתדל לתכנן לפחות 85% מהמסכים בהתאם לסטנדרט שקבעת. הדבר יאפשר שמירה על "עקרון העקביות" שמאוד חשוב.
    -
  6. לווה מסמך בדוגמאות: השתדל לתת כמה שיותר דוגמאות לעיצוב המסכים, כסה מספר מקסימאלי של סוגי הפקדים נתמכים בהתאם למקרי השימוש. ספק דוגמאות מסוג "עיצוב מומלץ" ו"עיצוב לא מומלץ". אנשים שיעצבו מסכים בהתאם למסמך יפנו יותר לדוגמאות מאשר לטקסט יבש.
    -
  7. בנה תבניות כלליות: בנה מספר תבניות מוכנות של מסכים, טפסים, פאנלים, מסגרות, סטים של פקדים וכו'.ברוב מערכות מידע יש דמיון בין טפסי המידע (Win-Forms), השוני הוא בכמות, סוג ומיקום הפקדים (כמובן יש גם שוני בהתנהגות המסכים). תבנית מוכנה יכולה לצמצם זמני עבודה, מעצב המסך יוכל להשמיש תבנית לצרכיו (לרוב ייעשה Drag-and-Drop וישנה את הפקדים, סגנון וסטנדרט יישמרו).
    -
  8. שתף ועדה טכנולוגית בהחלטות עיצוביות והצג בפניה את המסמך: הצג מסמך בפני פורום מקצועי-טכנולוגי. שתף פורום בהחלטות עיצוביות שנתקבלו בעת כתיבת המסמך. במידע ויהיו הערות לשינוי/תיקון דברים במסמך – עדיף שיהיו בשלב זה ולא בשלב שלאחר ההפצה של המסמך. [זמנים: 3-4 ימים בממוצע כולל DR]
    -
  9. הפץ מסמך בין גורמים רלוונטיים ובצע הדרכות: לאחר אישור הגורמים הרלוונטיים (אחרי שמסמך אושר בוועדה טכנולוגית) הפץ מסמך בין אנשים שיעצבו ויפתחו מסכים. מכוון שאנשים לא אוהבים לקרוא מסמכים עדיף לבצע הדרכה במקביל להפצה. ההדרכה לא יכולה לכסות את כל הנושאים ולא יכולה לתת תשובות לכל הבעיות שיצוצו, היא תאפשר הכנסה של אנשים לעניין המסמך והם ייחשפו לדברים עיקריים במסמך. [זמנים: כתיבה של מסמך: 1-3 שבועות בממוצע, הדרכות: 2-7 ימים בממוצע]
    -
  10. יישם והטמע סטנדרטים: זוהי מהות המסמך, אחרת זה יהיה עוד נייר מיותם בסדרה אינסופית של מסמכים שאף אחד לא מתייחס אליהם. החל מרגע ההפצה של המסמך כל מי שמעורב בעיצוב-פיתוח המסכים "אמור" להיצמד אליו, ז"א להשתמש באותו סט פקדים, באותן טכניקות, באותו סגנון (Look-and-Feel), באותם כללים של שמישות וכו'. [זמנים: 2-4 שבועות בממוצע]
    -
  11. וודא הטמעה של סטנדרטים: בצע ביקורות תוצרים (Design and Code Review). וודא שמסכים מעוצבים בהתאם לסטנדרט שנקבע. זה מתקשר לסעיף הקודם – תן משמעות לתקנים שאליהם התחייבת. [זמנים: אין הגבלה, מתבצע לאורך כל הפרויקט]
    -
  12. עדכן מסמך בהתאם לשינויים המתבקשים: מסמך סטנדרטים הנו ייצור חי. מפעם לפעם יתכנו שינויים בעיצוב המסכים שיידרשו שינוי בסטנדרט מסוים. במקרים מסוימים נגלה שמשהו מהמסך לא מתאים או לא עומד במבחן הזמן. לאחר שינוי המסמך דאג להפיצו בין גורמים רלוונטיים ובצע הדרכות (חזרה לסעיף 9 ולרוב גם ל- 8).

 

קווים מנחים בכתיבת המסמך

  • זכור למי מיועד המסמך: רמת הפירוט הטכני וכלל התכנים צריכים להיות מותאמים לאנשים בעלי רמה טכנית שונה. במידה ומסמך מיועד למנתחי מערכות וגם למפתחים, התאם לרמה למנתחים אשר לא בקיעים בפרטים הטכניים ספציפיים של פיתוח. אם מסמך מיועד למפתחי התוכנה אפשר לספק פירוט טכנולוגי יותר מורחב.
    -
  • עקביות: אחד העקרונות החשובים בעיצוב UI. ממשק התוכנה חייב להיות עקבי. המשתמש המודרני מצפה "להיכנס לעניינים" תוך זמן קצר. אם נשמור על עקרון העקביות בכל מסכי המערכת המשתמש יוכל לבצע פעולות בצורה אינטואיטיבית, על סמך הניסיון מתוכנות קודמות ו/או על סמך מה שהוא למד לעשות במסכים ראשונים במערכת החדשה. למשל: המשתמש התרגל לפתוח חלון מודאלי (Dialog-Window) עם פרטים מורחבים של רשומה ע"י לחיצה כפולה על שורה בטבלה (Data-Grid), אם מסך מסוים יאפשר פתיחת טופס בלחיצה אחת – לרוב זה יעצבן את המשתמש ופעולה שלעצמה אינה בטיחותית. המסמך חייב לכלול הסבר כיצד לשמור על עקביות, עקביות בכמה רבדים: מיקום כפתורי פעולה, יישור שדות הזנה, סוגי פקדים (בהתאם לסוגי מידע שהם מקבלים), מתי עושים קליק-כפול ומתי קליק-אחד, כיצד להציג הודעות שגיאה, כיצד להתריע על שגיאות וולידציה וכו'. תאר עקביות בסגנון (Styling) או בעיצוב הטפסים: שימוש בצבעים לרקעים, צבעי אזהרה/שגיאה, צבעי הפונטים, גדלים של פונטים ואייקונים. תאר כיצד לקבוע את פריסת הפקדים בטופס, תן המלצות לגבי החלוקה (טאבולארית – Tabular GUI, דף נגלל, אזורים מתקפלים וכו'). במידה ושפת הממשק הנה עברית התייחס לזרימת הטקסט הנכונה (Right-to-Left Flow Direction) – מאוד חשוב שמפתחים ידעו לקבוע מראש את זרימת המסך מימין לשמאל בשלבים מוקדים של פיתוח, אם יתחילו פיתוח הטפסים עם כוון LTR יהיה מאוד קשה לשנות את הזרימה אח"כ. זכור לבצע שלב 11 (וודא הטמעה של סטנדרטים) מפרק קודם – בצע DR-ים (Design Review) לתוצרים של אנשים, וודא שעקרון העקביות נשמר.
    -
  • קבע סטנדרטים והצמד אליהם: בהמשך לסעיף הקודם, לרוב צריך לקבוע סטנדרט של סוגי הפקדים (ספק דוגמאות לשימוש בסט הפקדים של הפרויקט – Controls' Toolbox), סטנדרט של סגנון (פורט בסעיף הקודם). סטנדרט של איכות (מאוד חשוב) – כיצד לוודא עיצוב ופיתוח המסכים מתבצע בהתאם לסטנדרטים שקבענו, ספק To-do List לביצוע בדיקות הנ"ל. קבע מודל עבודה – מיהם האנשים שיהיו מעורבים בעיצוב ופיתוח מסכים, מי האנשים שיעשו ביקורת לתוצרים, מיהם אנשי הקשר שלך (אתה לא יכול להתפצל לכמה אנשים כדי לתמוך בכולם).
    -
  • על תמציא גלגל מחדש: למד מניסיונם של אחרים, השתמש בסטנדרטים המקובלים בשוק התוכנה או במערכות דומות. ראה דוגמאות של מסמכי סטנדרטים ברגונך (במידה וקיימים), השתמש בדוגמאות ממקורות אחרים. אם מפתחים יישום לשימוש בסביבת המשרד – ניתן לחכות יישומי אופיס או יישומים אחרים המוכרים למשתמש שלך (רבים מכירים ממשקים של MS Office, רבים משתמשים בקיצורי סטנדרטיים, זכור לא לדרוס קיצורי דרך של מערכת הפעלה).
    -
  • דוגמאות: לווה מסמך בכמה שיותר דוגמאות מוחשיות. השתמש בצילומי מסך, מבנה טפסים, תבניות, שימוש בסגנונות. ספק דוגמאות מסוג "תעשה" ו"אל תעשה". לפי ניסיוני, רוב האנשים פשוט לא קוראים מלל (מתכנתים אף שונאים מלל, לעומתם מנתחי מערכות יעדיפו משהו כתוב), לכן דוגמאות גראפיות תהיינה מאוד יעילות.
    -
  • כללי נווט: הגדר כללי נווט ברורים בתוך המסכים והחוצה. באילו מקרים ייפתח חלון מודאלי ובאילו מקרים נעדיף למקם תוכן הטופס בתוך המסך. כיצד מנווטים בתוך המסך, קיצורי דרך של מקלדת, זרימת העבודה בתוך המסך, שימוש ב- Wizards. ספק מפת מסכים לדוגמא, המפה תכלול דוגמאות של "הכלה" (Screen Composition) ודוגמאות של נווט (Screen Navigation).
  • שפת הממשק: הכוון משתמשים לשפה משותפת, בנה מילון עסקי עבור UI, עדכן מילון מפעם לפעם. חשוב שכל מי שמעורב בעיצוב ופיתוח המסכים ישמור על עקביות גם בתגיות (Labels), בהודעות (Error/Info/Warning Messages). הנחה משתמשים להשתמש באותו סגנון בהודעות, כפתורי פעולה אחידים (האם להשתמש במילים כמו "שמור" או "שמירה", "פתח" או "פתיחה", "חפש" או "חיפוש"). מילון עסקי זוהי שפה ייחודית של ארגון, אבל גם כאן אני לא ממליץ להמציא גלגל מחדש, מילות צווי ברוב התוכנות הנן זהות. דאג להדריך "עורכי דין" להשתמש במלל קצר, אפקטיבי ופרודוקטיבי ("עורכי דין" או "בלשנים" – אנשים שמכניסים טקסטים ארוכים ומסורבלים בממשקי משתמש, בד"כ מנסחים הודעות בשפה גבוהה שלא באה מעולם המחשבים).
    -
  • סט פקדים (UI Widgets): הכן רשימת פקדים ופרט מקרים בהם יש להשתמש בפקד מסוג מסוים. סט יכול להכיל פקדים מיוחדים (Customized Controls), ייחודיים לפרויקט, אשר נבנו לפונקציונאליות עסקית ספציפית (למשל: גרפים מיוחדים, שעוני דשבורד, פאנלים עם תבניות מוכנות, Grid Tables מיוחדים, סיירי מדיה וכו'). ספק דוגמאות ויזואליות (Screen Snapshots) למקרי שימוש ולאופני שימושי. אין צורך לפרט על פקדים סטנדרטיים כגון: תוויות, תיבות טקסט, תיבות בחירה (קומבו), רשימות תקניות (List Box) ועוד פקדים שלרוב ידוע כיצד להשתמש בהם.
    -
  • סגנון של טפסים (Look-and-Feel): כפי שהסברתי בסעיפים קודמים, חושב להנחות מהו הסגנון של הממשק, מהם צבעי אזהרה, ידיעה, שגיאות. אם יש תקציב לגרפיקאי שיעשה את עיצוב הממשק, חושב להראות לאנשים מהו העיצוב הסופי המצופה. במקרה שמודל העבודה על המסכים "מעצב UI" + "מתכנת קליינט" (לרוב מקובל בעבודה עם WPF), יש לקבוע תחומי אחראיות לתוצרים ותחומי החפיפה; לרוב גרפיקאי יעצב תבניות, סגנונות, אייקונים ולוגואים (בהתאם למבנה המסך הראשי), המתכנת חייב לדעת לא "לפלוש" לאזורים של מעצב (למודל הנ"ל אקדיש פוסט נפרד). לרוב אנשים שמעורבים בעיצוב-פיתוח UI ירצו לדעת כיצד התוצרים שלהם ייראו בעיצוב הסופי, במקרים אלה אפשר לספק להם תבנית גרפית שאותה "ילבישו" על המסכים שלהם. ללא קשר לתוצרים של גרפיקה, חושב להסביר לאנשים כיצד לשמור על אחידות עיצובית כדי לתת Look-and-Feel אחידים לאורך כל המסכים.
    -
  • נגישות ושמישות (Accessibility and Usability): קבע כללים עבור נגישות ה- GUI בטפסים של הפרויקט. הסתמך על סביבת העבודה אצל לקוח: קהל היעד (האם יש מוגבלות פיזיות כלשהן אצל משתמשי הקצה), תצורת המחשב (גודל המסך, סוג המסך, איכות המסך, מערכת הפעלה, כוננים וכו'). קבעי כללים עבור שמישות. ציין כיצד לוודא שטופס שמיש וחסכוני מבחינת הפעולות (כיום מושג "GUI ארגונומי" מאוד נפוץ).
  • הדרכה: (סעיף 9 בתרשים) במהלך ההדרכה של צרכני המסמך מומלץ להראות כיצד בונים מסך. הסבר כיצד לחסוך פעולות מיותרות, הראה כיצד להשתמש בתבניות מוכנות, הראה כיצד ייראו למקם פקדים בהתאם לזרימת המסך/שפה. ציין נקודות חשובות במסמך שעליהם לא ניתן לדלג.
    -
  • בצע DR (Design Review): חשוב לקבל חוות דעת מגורמים מוסמכים לגבי המסמך לפני ביצוע הדרכות והפצה. בצע DR לעיצוב של מסכים של צרכני המסמך (סעיף 11 בתרשים עליון).
    -
  • עקרונות וקווים מנחים לעיצוב: -
  1. מבנה: הצע מבנה היררכי, קבץ פקדים לתוך מסגרות בהתאם פונקציונאליות משותפת, הוצא פקדים משותפים למסגרות שחופפות למסגרות נושאים. אסור שלמשתמש תהיה צריכה להיות תחושה שממשק מאיים ועמוס.
    -
  2. פשטות: זהה תהליכים כללים וראשיים, הגדר אזורי הפעלה לתהליכים אלה, השתמש במודל מופשט, סדר פקדים והיררכיה בצורה נוחה, הגדר קיצורי דרך של מקלדת לפעולות נפוצות.
    -
  3. שקיפות: הצג את מירב האופציות הזמינות באותו המסך (ללא עומס חזותי), אם עמוס - חלק למספר חוצצים/אזורים. אל תציע מיליון דרכים לביצוע של אותה פעולה, תרגיל משתמש שפעולה כלשהי מתבצעת במקום מסוים (שים לב שב- MS Word 2007 כל הפעולות מתבצעות רק דרך Ribbon ולא כמו ב- MS Word 2003 ניתן היה לבצע פעולה גם דרך סרגל כלים וגם דרך תפריטים).
    -
  4. משוב: למשתמש צריכה להיות תחושה שבכל שלב הוא יודע מה אמור לקרות, הוא מצפה לתגובות מסוימות של הממשק. ספק משוב רלוונטי כתוצאה מפעולת המשתמש, אל תציג הודעה עם תוכל מבלבל או לא קשור לפעולה שבעקבותיה הוצגה ההודעה. ספק חיווי ברור למרחש, גם אם זה מוריד מ"סקסיות המסך".
    -
  5. גמישות: בנה ממשק גמיש וסלחני. אל תטריח משתמש בפעולות מיותרות. השתדל לספק לו שירות מודרני שיקל על עבודתו (כמו למשל השלמות אוטומטיות של טקסטים וגיבוי אוטומטי). תאפשר לבצע שגיאות בלי להציג הודעות אימה (כמה דוגמאות לכותרות של שגיאות מפחידות ומיותרות: Fatal Error, Unrecoverable Error, Unknown Error). למרות שזה לא תמיד קל מבחינה תכנותית, השתדל לתת אופציה של Undo-Redo (תבנית Memento).
    -
  6. שימוש חוזר: עשה שימוש חוזר ברכיבי ממשק (גם פנימיים וגם חיצוניים). הדבר יאפשר תחזוקה קלה ומשתמש יתרגל לאותו סגנון העבודה, יכיר מסכים חדשים ביתר קלות.

קבע קווים מנחים לעיצוב אינטואיטיבי, נקי, שתף אנשים בדוגמאות ובקש מהם לשתף פעולה ביניהם. הגדר מהו עיצוב אינטואיטיבי (כיצד לגרום למשתמש ללא הדרכה מעמיקה להפעיל מסך על סמך ניסיונו הקודם ועל סמך ניסיונות מהפעלת מסכים אחרים במערכת). הנחה לגבי עיצוב חסכוני, אסור לעצב מסכים עמוסים. קבע חלוקה לרמות ולחוצצים (Tabs) בהתאם לעומס של פקדים.

 

דוגמא למבנה של מסמך

  1. תוכן עניינים
  2. הסבר על מסמך (כולל מדריך לשימוש נכון במסמך - אופציונאלי)
  3. מילון מונחים (מושגים טכניים שנפגשים במסמך - אופציונאלי)
  4. מבנה של חלון ראשי (תשתית)
  5. שירותי תשתית UI (השירותים ברמת GUI שכל מודול יכול לצרוך מתשתית, כמו: שירותי הדפסה, איות, עזרה, חיפוש, סרגלי כלים, תפריטים וכו')
  6. מפת מסכים (לרוב בתחילת הפרויקט לא ידוע אילו מסכים יהיו, המפה תכלול מסכי תשתית וחלק מהמסכים הראשיים, עיקרה לתת הנחייה כיצד לבנות מפות פר מודול)
  7. רשימת סטנדרטים (פירוט מלא + דוגמאות)
  8. רשימת GUI Widgets (סט פקדים של הפרויקט + דוגמאות שימוש)
  9. סגנון גראפי (ראה הסבר למעלה לגבי Look-and-Feel)
  10. רשימת תבניות מוכנות (כמובן מלווה בדוגמאות)
  11. מילון עסקי עבור UI (רשימה עם טקסטים עבור כפתורים, תוויות והודעות)
  12. מדריך לבניה נכונה של מסך (עם דוגמא ממשית מתוך הפרויקט)
  13. משאבים משותפים (מקשי קיצורי דרך גלובאליים, טבלאות מערכת, גלריית אייקונים/תמונות, מילוני לוקליזציה, הודעות שגיאה, לוגרים ועוד)
  14. דוגמאות "עשה" ו"לא עשה" (צילומי מסך עם הסברים)
  15. רשימת טיפים ועקרונות מנחים
  16. רשימה של אנשי קשר ואחראים (לפני סגירת המסמך קבע מיהם האנשים שירכזו את נושא ה- UI ויהיה בקשר איתך)
  17. מקורות

מקווה שדברים אלה יעזרו לכם בתכנון וכתיבה של מסמך סטנדרטים ובכלל בתפיסה של UI נכון. המון אנשים חושבים שהם "יודעים" איך לעצב/לפתח מסכי GUI על מסך תחושה אישית ועל סמך ניסיונם בהפעלה של תוכנות אחרות, אין זה אומר שהם באמת יודעים כיצד לעשות זאת. מסמך זה ייתן להם קו מנחה ברור כיצד להתקדם בעיצוב המסכים בפרויקט תוכנה, הוא ישמש גם צוות אפיון וגם צוות פיתוח, יהווה הסכם כתוב לגבי תקן איכות (סטנדרט) בעיצוב UI.


בהצלחה ;-)


מקורות מידע נוספים:

http://www.ambysoft.com/essays/userInterfaceDesign.html

http://www.fltk.org/hig.php

http://www.humanfactors.com/downloads/aug04.asp

http://msdn.microsoft.com/en-us/library/aa217660(office.11).aspx

http://www.pbdr.com/guistd/index.htm

http://mip-site.lsec.dnd.ca/qsd_current_version/sw_eng/di/ui_guidance.htm

http://www.classicsys.com/css06/cfm/article.cfm?articleid=20


ראו בהמשך פוסט על "עיצוב ממשק משתמש מודרני", אשמח לקבל הערות/תיקונים לגבי הפוסט. לרשימת הפוסטים של הסדרה לחצו כאן.

“Class to Table” = “Entity to SQL”

Recently, I deal with UML design in EA, also I design DB Entities for DBML (Linq2Sql). In regular way, programmer creates DB table and imports it into VS solution as entity class for DBML. But, sometimes we need to create DB table from existing class. I’m pretty sure that there are some free tools that can do this job, but as many code freaks I prefer to develop my own tools (mostly without looking for existing solutions).

I want to share my community contribution at http://class2table.codeplex.com/ with small application that allows generation/creation of DB tables from any .Net type. User loads assembly file, selects reflected type in combo, picks desired properties, then he can generate SQL script or to create table directly in SQL DB.

Class2Table

Remarks: This is “Quick & Dirty” application, I’ve made it as temp. solution. Any comments/improvements will be accepted with pleasure. Of course, you should understand that it is a free-beta-version and I’m not responsible for any damage that may be caused by using this application. All rights reserved ®.

Application   EXE Files on Codeplex
Application   Sources on Codeplex


 

Intelligent Mass Production Robotics

AI & IP in Mass Production:

Technorati Tags: ,,,,
Posted by Maxim | 2 comment(s)
תגים:, , ,

Interesting video about “High-Speed Robot Hand”:

I got some spooky feeling that our (humans’) doom-day is getting closer.

Technorati Tags: ,,

image

הנכם מוזמנים להצביע בעד ההרצאות שלי באתר של כנס המפתחים שאמור להתקיים ב- 14/09/2009 במשרדי מיקרוסופט ברח’ שנקר 13 בהרצליה.

פרסמתי הצעה לשתי הרצאות מעניינות העוסקות בתחום פיתוח UI. שתיהן מאוד פרקטיות, ללא שווק, הכל תכלס, הכל מצד המפתח ועם כמה שיותר דוגמאות קוד.

---

ההרצאה הראשונה הנה בנושא: “3D in Silverlight” או “תלת מימד בסילברלייט”

בהרצאה זו אני הולך לדון בנושא של Rich Client Application for Internet עם שילוב של יכולות תלת ממד. נכון להיום, סילברלייט עדיין לא תומך באופן מלא בסצינות/אובייקטים תלת ממדים כמו WPF. בהרצאה אציג את הספריה Kit3D (קוד פתוח) כחלופה האפשרית לתצוגה של סצנות עם אובייקטים תלת ממדיים בשיטה הדומה ל- WPF. אציג מספר דוגמאות שממשות תלת ממד אמיתי בסילברלייט. כמו כן, אציג את היכולות של גרפיקה תלת ממדית בטכנולוגיה המתחרה של סילברלייט – Adobe Flash (גם פלאש עדיין לא תומך באופן מלא בתלת מימד). יכולות גרפיות לרידור אובקייטים תלת ממדיים פותחות אינסוף אפשרויות בפני המפתחים: משחקי תלת ממד מבוססי סילברלייט, סימולטורים, גראפים ועוד.

לחצו על תמונה הבאה על מנת לראות דוגמא למימוש של קוביה הונגרית תלת ממדית עם טקסטרות וידאו:

לחצו על התמונה על מנת לראות דוגמא ל- Mockup של סימולטור Netcasting של משחקים קבוצתיים כמו כדורגל, כדורסל, כדורעף ועוד (בתוך היישום לחצו על סמל עם מגרש - court):


(ניתן להתשמש ב- Sliders או עכבר לשינוי מיקום המצלמה, סיבוב המגרש ו- Zoom)

בהרצאה אציג דוגמא נוספת (יותר מתוכמת ועם אנימציות) של יישום תלת ממדי עם אובייקטים מיובאים מתוכנת 3ds Max 2009.

---

ההרצאה השניה הנה בנושא: “GUI Design for .Net Developers” או “עיצוב ממשק משתמש למפתחי דוט-נט”

הרצאה זו תעסוק בהיבטים הפרקטיים של עיצוב, פיתוח ותחזוקה של ממשקי משתמש – GUI מהצד של מפתחי הדוט-נט. כמו ההרצאה הראשונה, הרצאה זו הנה מקצועית ודנה במספר פתרונות לבעיות בפיתוח של ממשקי משתמש ע”י אנשים שלא קיבלו השכלה פורמאלית בתחום. יוזכרו כל ה- buzzwords כמו: WPF, Silverlight, CAB, WinForms מגרסאות 2.0, 3.0 ו- 3.5. יוצגו דוגמאות של תהליכי עבודה, דוגמאות קוד, ממשקים לדוגמא (טובים, גרועים וסקסיים). אדבר על הקשיים של עיצוב ממשקים ללא התערבות של גורמים כמו גראפיקאים, יועצים, מנגישים, ארגומומים ויתר האנשים שנושמים את UI על בסיס יומי. אדבר על המפתחים שעוסקים ב- GUI לפי דרישות התפקיד ועל הבעיות הנפוצות שהם נתקלים בהן, כמו כן אציע מספר פתרונות יצירתיים לבעיות אלו. אני מכיר המון פרויקטים בתחום התוכנה שבהם אחד המרכיבים בהצלחה או כישלון הפרויקט הנו UI.
בנוסף, אדבר על השיקולים בבחירת טכנולוגיה ל- GUI, אציג מספר דוגמאות לבחירה ומימוש מוצלחים (ופחות) של טכנולוגיה עם דגמאות. כמו למשל ההתלבטות בבחירה בין WPF ל- WinForms לאפליקציות בנקאיות/פיננסיות מרובות טפסים עם התממשקות למערכות חיצוניות שונות. אדבר על דרכים לחיסכון בבניה של פקדים ועל הספריות Open Source החנמיות ל- GUI. גם פה הרוב יהיה עם קוד, בלי שווק, הכל תכלס, הכל ממבט של מפתח דוט-נט.

ראו תצלום מסך של GUI מתוך אפליקציה “Media Manager” שפיתחתי ב- WPF עובר “שגב מערכות” (אציג כדוגמא בהרצאה):

Media Manager Search Results 
(לחצו על התמונה להגדלה)

---

לדעתי החומר המוצע מאוד מעניין. מקווה שתצביעו ותשפיעו ;-)

הערות: כל הזכויות שמורות, כל שימוש בחומר ההרצאה מותנה באישור שלי, כל התכנים ומשאבים שיהיו בשימוש בכנס יהיו בהסכמה של היוצרים. אינני אחראי לנזקים כלשהם שיכולים להגרם לגורמים המעורבים.

 

 

img_frm_back_top_logo

 


לחברה דינאמית וצעירה דרוש/ה מתכנת/ת לעבודה במשרה מלאה

דרישות התפקיד:
שליטה בסביבת פיתוח 2.0 .Net – חובה
שליטה בשפת תכנות #C – חובה
ניסיון מעשי ב- WinForms 2.0 – חובה

הערות:
היכרות עם שרת MS SQL 2005/8 – יתרון
הכרות עם שפת VB.Net – יתרון
הכרות עם סביבות פיתוח .Net 3.0/3.5 – יתרון
יכולת למידה/עבודה עצמאית – יתרון

נא לשלוח קו"ח לדוא"ל: avshi@segevsystems.tv



העבודה מעניינת, באווירה כפרית של קיבוץ “גליל ים” הנמצא במרכז הרצליה.
פרטים על החברה ניתן למצוא באתר:
http://www.segevsystems.tv.

 

Technorati Tags: ,,,,,

Design Sales (Banner)

Import 3D Model to WPF from any 3D Editor

Many 3D editors can export 3D scenes as OBJ files, these files can be easily imported into WPF project and being used to build complex 3D scenes.
See how easy to import 3D scene from 3D editors (for example Blender or 3ds Max):

Blender:
blender - file - export 
blender - file - export - save as

3ds Max:
3ds max - file - export 
3ds max - file - export - save as 
After the export we get two files “scene_objects.obj” (contains definition of scene objects) and “scene_objects.mtl” (contains definition of objects’ materials).

Now we can add these files to WPF project:

Blend:
Open/cerate WPF project and add OBJ and MTL files into objects’ tree.
blend - import obj 
blend - import obj - select files 
Open target window, drag and drop added OBJ file into it.
blend - window - import obj 
The Blend generates Viewport3D with all required objects automatically.
blend - window - viewport 3d 
Now we can “play” with 3D scene: change objects’ parameters, materials, transformations, lights, animations and etc.
blend - run project

The example project with code can be downloaded from here download .

PS
I’m not responsible for any damage that may be caused by using this post or its content. Any materials in this post were provided AS IS without any changes and other meanings.

See posts about 3rd party tools for XAML: Blender2Xaml and Max2Xaml.

More Posts Next page »