Example #1
0
        /*static int Main(string[] args)
         * {
         *  using (var app = new QGuiApplication(args))
         *  {
         *      using (var engine = new QQmlApplicationEngine())
         *      {
         *          // TODO: Register your .NET types.
         *          // Qml.RegisterType<NetObject>("test");
         *
         *          engine.Load("Main.qml");
         *
         *          return app.Exec();
         *      }
         *  }
         * }*/
        static int Main(string[] args)
        {
            RuntimeManager.DiscoverOrDownloadSuitableQtRuntime();

            using (var app = new QGuiApplication(args))
            {
                using (var engine = new QQmlApplicationEngine())
                {
                    // TODO: Register your .NET types to be used in Qml
                    Qml.Net.Qml.RegisterType <QmlType>("TestApp", 1, 1);       // in QML file: import TestApp 1.1
                    Qml.Net.Qml.RegisterType <YourNetObject>("YourApp", 2, 1); // in QML file: import YourApp 2.1


                    var netObject = new YourNetObject();
                    // You can attach signal handlers from both .NET and QML:
                    netObject.AttachToSignal("signalName", new Action <string, int>((param1, param2) =>
                    {
                        Console.WriteLine("Signal raised from .NET! {0} {1}", param1, param2);
                    }));


                    engine.Load("Main.qml");


                    // You can raise signals from .NET:
                    netObject.ActivateSignal("signalName", "param", 3);


                    return(app.Exec());
                }
            }
        }
Example #2
0
        static void Main(string[] args)
        {
            // Init QT application
            int count = 0;

            // project-> properties -> allow unsafe code (must ce checked for now)
            try
            {
                // TODO : added try/catch block so we can log exception errors
                unsafe
                {
                    var qtApp = new QApplication(ref count, null);
                }

                // create MainWindow
                var mainWindow = new Widgets.MainWindow();

                // Run the QApplication Process
                QGuiApplication.Exec();

                //QApplication.Exec();
            }
            catch (Exception)
            {
                throw;
            }

            Console.WriteLine("All done");
            Console.ReadKey();
        }
Example #3
0
        static int Main(string[] args)
        {
            _CheckTimer = new Timer((e) =>
            {
                CheckAndPrint();
            });
            _CheckTimer.Change(TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(5));

            using (var app = new QGuiApplication(args))
            {
                _App = app;
                AppModel.UIDispatch += (a) => _App.Dispatch(a);
                QQmlApplicationEngine.ActivateMVVMBehavior();
                using (var engine = new QQmlApplicationEngine())
                {
                    QQmlApplicationEngine.RegisterType <AppModel>("app", 1, 1);

                    var assemblyDir = Path.GetDirectoryName(new Uri(Assembly.GetExecutingAssembly().Location).AbsolutePath);
                    var mainQmlPath = Path.Combine(assemblyDir, "UI", "QML", "main.qml");
                    engine.Load(mainQmlPath);
                    int result = app.Exec();
                    _App = null;
                    return(result);
                }
            }
        }
Example #4
0
        static int Main(string[] args)
        {
            RuntimeManager.DiscoverOrDownloadSuitableQtRuntime();

            using (var app = new QGuiApplication(args))
            {
                Qml.Net.Qml.RegisterType <Trans>("TaoQuickNet");
                var trans = new Trans();
                trans.loadFolder(Config.Config.transPath);
                using (var engine = new QQmlApplicationEngine())
                {
                    Console.WriteLine("importPath " + Config.Config.importPath);
                    Console.WriteLine("imgPath " + Config.Config.imgPath);

                    engine.AddImportPath(Config.Config.importPath);
                    engine.SetContextProperty("imgPath", Config.Config.imgPath);
                    engine.SetContextProperty("qmlPath", Config.Config.qmlPath);
                    engine.SetContextProperty("contentsPath", Config.Config.contentsPath);
                    engine.SetContextProperty("isDebug", true);

                    engine.SetContextProperty("taoQuickImagePath", Config.Config.importPath + "TaoQuick/Images/");

                    engine.SetContextProperty("trans", trans);

                    engine.Load(Config.Config.qmlPath + "main.qml");
                    return(app.Exec());
                }
            }
        }
Example #5
0
        private static unsafe void Main()
        {
            QGuiApp = QGuiApp.CreateQGuiApp();

            LoadQml();

            // Run the QApplication Process
            QGuiApplication.Exec();
        }
Example #6
0
 static int Main(string[] args)
 {
     initResources();
     if (Init(ref args))
     {
         return(app.Exec());
     }
     clearResources();
     return(1);
 }
Example #7
0
 static void Main(string[] args)
 {
     using (var application = new QGuiApplication(args))
     {
         using (var engine = new QQmlApplicationEngine())
         {
             engine.Load("Tutorial01.qml");
             application.Exec();
         }
     }
 }
Example #8
0
 private static int Main(string[] args)
 {
     RuntimeManager.DiscoverOrDownloadSuitableQtRuntime();
     Qt.PutEnv("QT_QUICK_CONTROLS_CONF", System.IO.Directory.GetCurrentDirectory() + "/qml/qtquickcontrols2.conf");
     QmlNetConfig.ShouldEnsureUIThread  = false;            // remove this line when fixed in qml.net: temporary workaround for https://github.com/qmlnet/qmlnet/issues/112
     using QGuiApplication app          = new QGuiApplication(args);
     using QQmlApplicationEngine engine = new QQmlApplicationEngine();
     // Register our new type to be used in Qml
     QmlBridge.RegisterTypes();
     engine.Load(System.IO.Path.Combine(System.AppDomain.CurrentDomain.BaseDirectory, "qml", "main.qml"));
     return(app.Exec());
 }
Example #9
0
        static int Main(string[] args)
        {
            PrepareRuntime();

            using var app    = new QGuiApplication(args);
            using var engine = new QQmlApplicationEngine();

            Qml.Net.Qml.RegisterType <NetObject>("app");

            engine.Load("Main.qml");

            return(app.Exec());
        }
Example #10
0
 static int Main(string[] args)
 {
     RuntimeManager.DiscoverOrDownloadSuitableQtRuntime();
     QQuickStyle.SetStyle("Material");
     using (var application = new QGuiApplication(args))
     {
         using (var qmlEngine = new QQmlApplicationEngine())
         {
             Qml.Net.Qml.RegisterType <TrayModel>("app");
             qmlEngine.Load("TrayIcon.qml");
             return(application.Exec());
         }
     }
 }
Example #11
0
        override protected int RunHostOverride(string[] _)
        {
            using (var app = new QGuiApplication(_))
            {
                using (var engine = new QQmlApplicationEngine())
                {
                    RegisterTypes();

                    LoadViews(engine);

                    return(app.Exec());
                }
            }
        }
Example #12
0
        static int Main(string[] args)
        {
            RuntimeManager.DiscoverOrDownloadSuitableQtRuntime();

            using (var app = new QGuiApplication(args))
            {
                using (var engine = new QQmlApplicationEngine())
                {
                    Qml.Net.Qml.RegisterType <EditorModel>("Editor");
                    engine.Load("main.qml");
                    return(app.Exec());
                }
            }
        }
Example #13
0
 static int Main(string[] args)
 {
     using (var app = new QGuiApplication(args))
     {
         using (var engine = new QQmlApplicationEngine())
         {
             Qml.Net.Qml.RegisterType <QmlNetBridge>(uri: "app");
             var content = System.IO.File.ReadAllText(@"mainWindow.qml");
             content = "import app 1.0\n" + content;
             content = content.Replace(@"//<C#>", @"");
             engine.LoadData(content);
             return(app.Exec());
         }
     }
 }
Example #14
0
 static int Main(string[] args)
 {
     Qt.PutEnv("QT_OPENGL", "angle");
     Qt.PutEnv("QT_ANGLE_PLATFORM", "warp");
     Qt.PutEnv("QT_DISABLE_SHADER_DISK_CACHE", "1");
     using (var app = new QGuiApplication(args))
     {
         using (var engine = new QQmlApplicationEngine())
         {
             Qml.Net.Qml.RegisterType <EditorModel>("Editor");
             engine.Load("main.qml");
             return(app.Exec());
         }
     }
 }
Example #15
0
        static int Main(string[] args)
        {
            RuntimeManager.DiscoverOrDownloadSuitableQtRuntime();


            using (var application = new QGuiApplication(args))
            {
                using (var qmlEngine = new QQmlApplicationEngine())
                {
                    qmlEngine.Load("photoshopGUI.qml");

                    return(application.Exec());
                }
            }
        }
Example #16
0
        static int Main(string[] args)
        {
            using (var app = new QGuiApplication(args))
            {
                using (var engine = new QQmlApplicationEngine())
                {
                    // TODO: Register your .NET types.
                    // Qml.RegisterType<NetObject>("test");

                    engine.Load("Main.qml");

                    return(app.Exec());
                }
            }
        }
Example #17
0
        static int Main(string[] args)
        {
            //RuntimeManager.DiscoverOrDownloadSuitableQtRuntime();

            using (var app = new QGuiApplication(args))
            {
                using (var engine = new QQmlApplicationEngine())
                {
                    // Register our new type to be used in Qml
                    //Qml.Net.Qml.RegisterType<QmlType>("test", 1, 1);
                    engine.Load("qml/main.qml");
                    return(app.Exec());
                }
            }
        }
Example #18
0
        static int Main(string[] args)
        {
            using (var app = new QGuiApplication(args))
            {
                using (var engine = new QQmlApplicationEngine())
                {
                    engine.AddImportPath(Path.Combine(Directory.GetCurrentDirectory(), "Qml"));

                    Qml.RegisterType <TestQmlImport>("test");

                    engine.Load("main.qml");

                    return(app.Exec());
                }
            }
        }
Example #19
0
        private static int Main(string[] args)
        {
            GetResponse();

            RuntimeManager.DiscoverOrDownloadSuitableQtRuntime();
            QQuickStyle.SetStyle("Material");

            using (var application = new QGuiApplication())
            {
                using (var qmlEngine = new QQmlApplicationEngine())
                {
                    qmlEngine.Load("Main.qml");
                    return(application.Exec());
                }
            }
        }
Example #20
0
        static int Main(string[] args)
        {
            var coll = new ServiceCollection().AddHttpClient();

            RuntimeManager.DiscoverOrDownloadSuitableQtRuntime();
            using (var app = new QGuiApplication())
            {
                Console.WriteLine("entered 1st using");
                using (var engine = new QQmlApplicationEngine())
                {
                    Console.WriteLine("entered 2nd using");
                    Qml.Net.Qml.RegisterType <QmlType>("test", 1, 1);
                    engine.Load("qml/main.qml");
                    return(app.Exec());
                }
            }
        }
Example #21
0
        static int Main(string[] args)
        {
            RuntimeManager.DiscoverOrDownloadSuitableQtRuntime();

            Init();

            //QQuickStyle.SetStyle("Material");

            using (var application = new QGuiApplication(args))
            {
                using (var qmlEngine = new QQmlApplicationEngine())
                {
                    Qml.Net.Qml.RegisterType <LibraryList>("MIXManga.NET.VS");
                    qmlEngine.Load("Main.qml");
                    return(application.Exec());
                }
            }
        }
Example #22
0
        static int Main(string[] args)
        {
            RuntimeManager.DiscoverOrDownloadSuitableQtRuntime();

            QQuickStyle.SetStyle("Material");

            using (var application = new QGuiApplication(args))
            {
                using (var qmlEngine = new QQmlApplicationEngine())
                {
                    Qml.Net.Qml.RegisterType <MainController>("Controllers");
                    Qml.Net.Qml.RegisterType <SimpleList>("Lists");
                    qmlEngine.Load("Main.qml");

                    return(application.Exec());
                }
            }
        }
Example #23
0
        protected int ExecApplicationWithTimeout(int timeoutMs)
        {
            CancellationTokenSource cts = new CancellationTokenSource();
            CancellationToken       ct  = cts.Token;

            Task.Factory.StartNew(() =>
            {
                Thread.Sleep(timeoutMs);
                if (!ct.IsCancellationRequested)
                {
                    _coreApplication.Exit(-1);
                }
            }, ct);

            var result = _coreApplication.Exec();

            cts.Cancel();
            return(result);
        }
Example #24
0
        static int Main(string[] args)
        {
            RuntimeManager.DiscoverOrDownloadSuitableQtRuntime();

            // QQuickStyle.SetStyle("Material");

            using (var app = new QGuiApplication(args))
            {
                using (var engine = new QQmlApplicationEngine())
                {
                    // TODO: Register your .NET types.
                    // Qml.RegisterType<NetObject>("test");

                    engine.Load("Main.qml");

                    return(app.Exec());
                }
            }
        }
Example #25
0
        public static int Run()
        {
            RuntimeManager.DiscoverOrDownloadSuitableQtRuntime();

            QQuickStyle.SetStyle("Material");

            QCoreApplication.SetAttribute(ApplicationAttribute.EnableHighDpiScaling, true);

            using var app    = new QGuiApplication();
            using var engine = new QQmlApplicationEngine();


            Qml.Net.Qml.RegisterType <SettingsModel>("Aris.Moe.OverlayTranslate.Gui.Qt5", 1, 1);
            Qml.Net.Qml.RegisterType <ControlsModel>("Aris.Moe.OverlayTranslate.Gui.Qt5", 1, 1);

            engine.Load("Main.qml");

            return(app.Exec());
        }
Example #26
0
 public int Launch(string[] args)
 {
     Builder.ResolveQtRuntime();
     QQuickStyle.SetStyle(Builder.Style);
     RegisterServices();
     using (var application = new QGuiApplication(args))
     {
         using (var qmlEngine = new QQmlApplicationEngine())
         {
             QQmlApplicationEngine.ActivateMVVMBehavior();
             Builder.DoRegisterTypes?.Invoke();
             DoAutoRegisterTypes();
             AddImportPath(qmlEngine);
             qmlEngine.Load(Builder.MainQml);
             Application = application;
             return(application.Exec());
         }
     }
 }
Example #27
0
        static void Main(string[] args)
        {
            using (var application = new QGuiApplication(args))
            {
                using (var engine = new QQmlApplicationEngine())
                {
                    var listOfContacts = CreateDemoContactList();

                    Qml.Net.Qml.RegisterType <ContactList>("QmlNet.Tutorials.ContactList", 1, 0);

                    engine.SetContextProperty("contacts", listOfContacts);

                    engine.Load("Tutorial02.qml");

                    engine.SetContextProperty("contacts", listOfContacts);

                    application.Exec();
                }
            }
        }
Example #28
0
        static int Main(string[] args)
        {
            QQuickStyle.SetStyle("Material");

            using (var application = new QGuiApplication(args))
            {
                using (var qmlEngine = new QQmlApplicationEngine())
                {
                    QQmlApplicationEngine.RegisterType <SignalsModel>("Features");
                    QQmlApplicationEngine.RegisterType <NotifySignalsModel>("Features");
                    QQmlApplicationEngine.RegisterType <AsyncAwaitModel>("Features");
                    QQmlApplicationEngine.RegisterType <NetObjectsModel>("Features");
                    QQmlApplicationEngine.RegisterType <DynamicModel>("Features");

                    qmlEngine.Load("Main.qml");

                    return(application.Exec());
                }
            }
        }
Example #29
0
        static int Main(string[] args)
        {
            using (var app = new QGuiApplication(args))
            {
                QQmlApplicationEngine.ActivateMVVMBehavior();

                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
                {
                    QQuickStyle.SetStyle("Universal");
                }
                else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
                {
                    QQuickStyle.SetStyle("Material");
                }

                using (var engine = new QQmlApplicationEngine())
                {
                    engine.SetContextProperty("app", new MainViewModel());
                    engine.Load("Views/main.qml");
                    return(app.Exec());
                }
            }
        }
Example #30
0
        static int Main(string[] args)
        {
            RuntimeManager.DiscoverOrDownloadSuitableQtRuntime();

            foreach (DictionaryEntry item in Environment.GetEnvironmentVariables())
            {
                Console.WriteLine($"{ item.Key }:{ item.Value }");
            }

            using (var application = new QGuiApplication(args))
            {
                using (var qmlEngine = new QQmlApplicationEngine())
                {
                    #if DEBUG
                    qmlEngine.Load("qml/main.qml");
                    #else
                    qmlEngine.Load($"{Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly().Location)}/qml/main.qml");
                    #endif

                    return(application.Exec());
                }
            }
        }