I have been studying about Intel XDK about how to program for cross platforms, for now I'm that much clear that we can program the interface using HtML,css and Js but don't know How to implement the backend code!!! (whether using js or php) ?
Intel xdk stops their support, we can only work with the last release.
For the above question, you can add HTML file for the UI design and add its backend file as javascript file and add the javascript file in HTML.
Related
i made a gui recently where the goal was to view the results of some actions there , so mostly it was like a simulation game that has no connection with any hardware , i proposed this for my school that uses moodle and i want to know if there is a way to integrate it there , the gui i used has controlP5 library and videos and gif libraries as well, i would appreciate the help
from my researches so far i found that we can integrate processing code with html after some modifications , but didn't find anything for moodle yet
My understanding is that Processing in java mode, using controlP5, etc. will work on a client machine, not on a server (like moodle) (not easily at least).
Regarding embedding a processing sketch a web page:
java applet support is deprecated (can no longer embed a .jar applet)
processing.js is deprecated (and controlP5 wouldn't be compatible anyway)
you can however port your code to p5.js
I don't know enough moodle, but perhaps you can embed a JS snippet/iframe/etc on a moodle page.
Regarding controlP5, in p5.js, you can look at p5.dom.js functionalities such as createSlider(), createButton(), etc. or use libraries like p5.gui or p5.touchgui.
Is there a way to sign a JSON UTF8String with JOSE.JWS before sending via https to a (government) server using Lazarus / FPC ?
The specification is heavy and writing everything from scratch seems to be an impossible big job before (government's) deadline.
(Although I've found a Delphi XE7+ code here... , sadly it is using outdated Indy components, so would be hard to rewrite to FPC + Synapse)
So the best would be to do that with latest (trunc) Ararat Synapse component, because it can handle OpenSSL3+ too.
(And the REST communication is working with that already.)
OR
Maybe possible to use a freely available, compiled binary (Win7 compatible 32-bit .DLL file) from somewhere and write a wrapper around it?
I currently have a Firefox extension/plugin combo that works well, and was written with a combination of NPAPI (Firebreath) C++ code and Javascript. The extension works by defining a browser overlay (overlay.xul/overlay.js) that is loaded on every webpage via a script src="overlay.js" tag.
I need to adapt it for the upcoming changes for Firefox Webextensions and deprecation of XPCOM/XUL.
From what I understand, Webextensions will be primarily Javascript based. How would I be able to continue using the C++ portion of my extension? Note that porting the C++ NPAPI library to Javascript would be a non-starter for various reasons.
You have to use Native messaging to keep some part of your code in C++.
Be aware only the background script can directly communicate with your native/C++ code. But these messages can later be dispatched to your content scripts.
The communication between your C++ code and the background script is through the stdin/stdout.
There is a nice example between python script and web-extension on github: https://github.com/mdn/webextensions-examples/tree/master/native-messaging
I would like to ask the SO community for the following information:
- Is it possible to compile WebKit for Windows8-Metro Environment, either in the form of a WinRT component or just as a linked library in a C++/XAML application?
- Which are the main steps to achieve this goal?
- Which are the possible things that would make this not possible or very difficult?
- Is it an endeavour someone is working on just now?
- Is it possible to gather interested people so they work on this?
I think you will not be able to just "compile" Webkit for WinRT/Metro Style. Metro Style applications are restricted in the kind of API calls they can make, for example there is no GDI/GDI+/MFC for WinRT. WebKit has several building modes that you can use, you can either build it using QT as rendering engine, or using GTK, or plain GDI, but on all those cases, when you create new builds for Windows OSes you will be using GDI at the very end.
Nevertheless, you could modify Webkit source code and add a new rendering engine that uses WinRT new APIs. You could probably become famous if you do.
As a side note, even when there is a "Windows Store" version of Chrome, by looking at the source code of Chromium it seems to me that this version is just a simple app launcher that communicates with the "normal" desktop version using an IPC channel. It does not appear to be a real Windows Store build of the whole source code.
I am not sure if the WinRT environment will allow this, but there is a project called Awesomium that is a wrapper around Google Chrome and Google Chrome is based on WebKit I think. It also has a .NET wrapper, so you can embedd it onto your .NET app.
I never tried using it, neither I know about if this library is applicable with WinRT, but at least it is a start.
Awesomium
Awesomium .NET samples
DownMakerWPF, an application embedding it to display markdown.
WinRT is a combination of managed and native code, so, you have a chance to port WebKit, but remember - native code have some sandbox restrictions.
Also you can choose XNA instead.
We currently have a shared DirectX code base that renders our UI and is used in our PC side application and via an ActiveX in web pages.
I have written some WebGL demos and they perform great, no plugin mess and get rid of ancient ActiveX!
This obviously raises the problem of having a split code base for the PC application and the Web UI.
As WebGL is based on the OpenGL ES 2.0 specification would it be possible to have a standard code base and write a interpreter so that either:
-The WebGL code can be modified to compile as OpenGL
-OpenGL can be modified to work in a web page
The khronos specifications are new to me, so this is sort of speculative as I am peforming research at the moment.
Does anyone with more knowledge of 3D graphics and a better understanding of the coding syntax help me out?
One way is to have a PC app to enclose a WebGL-capable browser inside (together with a simple http server) to run the same rendering technique as the web App.
This will reduce the maintenance and development costs for both platforms.