I want to create widgets/gadgets and/or customize app themes like Plank themes, WingPanel themes, Files (File Manager) themes, etc for Elementary OS - a Linux distro. But I don't know where to begin. Basically, I want to create "tweaks" and make them available for others to download and use and share.
I know C, C++, C# and Vala (Vala = main programming language used to create software for Elementary OS).
How do we create widgets/gadgets/tweaks for Linux/Ubuntu/Elementary OS? Where do I begin?
Elementary OS has a developer site that you can use to understand their guidelines and touches on some basic topics and APIs. They should also have some links to other docs that go into further detail in certain areas. If you are looking specifically for a GUI application, then I sugggest researching GTK, QT, and Glade as you will be using one of those to help build the interface.
Related
Julia libraries like 'GLAbstraction' are too low level for me. I need something like the 'Canvas API' for JavaScript in browsers. Are there any?
This is not an exhaustive list. I put the first several links I was aware of. I would start with QML.jl if you can.
Related discussions:
https://discourse.julialang.org/t/julia-for-gui-app/416
https://discourse.julialang.org/c/domain/viz/17
Desktop Graphics Engines aka Desktop GUIs
If you search through the JuliaCon Videos from past years, you can find talks and walkthroughs for these packages.
I have a background in Qt and the Qt Libraries, and it is very general purpose. QML is very friendly if you have a javascript background. The KDE desktop in Linux is built around Qt. Many desktop apps in general include Qt dlls, and use it as its backbone.
https://github.com/barche/QML.jl
And here is a youtube link or two about it:
https://www.youtube.com/watch?v=AddbHe05yRg
https://github.com/barche/juliacon2020-qml - example code for the most recent talk on it
https://www.youtube.com/watch?v=4Bmp0I731Ak
Gtk has been around a long time and you can see it in use in GIMP and Gnome desktop in Linux.
https://github.com/JuliaGraphics/Gtk.jl
The examples for Redux are mentioned in the PackageCompiler.jl video done recently. These are more or less the React Native style apps, shipping a chromium browser and rendering a react environment as a desktop app.
https://github.com/Gnimuc/Redux.jl
Interactive Plotting Libraries
There is a list of them here in the Plots.jl interface. Plotting in Julia is a pretty big rabbit hole, and there are tons of options to look into. Jupyter notebooks and the like with interactivity layered on them blurs the line between what is a GUI and what is just a plot.
http://docs.juliaplots.org/latest/ecosystem/
https://juliaobserver.com/categories/Graphical%20Plotting
https://github.com/JuliaPlots/Makie.jl
https://github.com/JuliaGL/GLVisualize.jl
https://github.com/JuliaGizmos/Interact.jl
https://github.com/plotly/Dash.jl
Web Frameworks
https://genieframework.com/
https://github.com/JuliaGizmos/Interact.jl
https://github.com/plotly/Dash.jl
I’m contributing in an Enterprise Integration Infrastructure project. Like many other integration software, Apache-Camel is the core of our application. To enable users defining their EIPs graphically, I want to use Fuse IDE in the software. The only thing I need the Fuse do is generating xml file from the routes which are defined by the users.
On the other hand, I know that Fuse IDE is essentially an Eclipse plugin (I think it is an Eclipse RCP plugin). Since the UI of our application is based on javaFX I want to know that is there any way to manipulate the code of Fuse to adjust it to javaFX entities?
Your help will be more than appreciated, due to the high importance of this issue for me.
That would be a lot of hard work as that code is tightly coupled to Eclipse.
So I would say NO unless you are prepared to do a lot of work porting and migration the code.
We are starting with an embedded development using the Enlightenment Foundation Libraries. We are developing a "full" screen application, so a window manager is not required and our Linux system will eventually run Tizen OS.
The question is, EFL provides Elementary and Edje.
Should we use Elementary widgets or Edje scripts?
Can you use Elementary widgets in Edje scripts? I have heard mention of this but have not seen any documentation or examples.
EFL provides a no. of libraries for different GUI tasks. Generally based on requirements you need to opt for a particular lib. elementary provides set of widgets already created for user. So go for it if you can reuse. But do implement it with edje as edje is helpful for defining layouts and will help you when you need to scale up or down your graphics app. you can refer following link for detail api documentation:
http://web.enlightenment.org/p.php?p=docs&l=en
Use elementary first. You can do most of things and it supports a lot of features such as theme, focus, container, access, auto deletion, scale, mirror, translate, orientation set and etc.
If you really want to use edje(edc script) then use elm_layout and set edj file.
Thanks.
What would be the best practice to share busines logic c# code between MonoTouch and Mono For Android projects?
Edited:
Initially, my question was about the physical file sharing:
What do you propose to use: network file sharing or some code
version control (git, svn)? In my case I am using two workstations -
Mac (MonoDevelop with MonoTouch) and PC (Visual Studio with
MonoDroid).
What about Solution/Project folder structure? In
"Blog Post: Xamarin Mobile World Congress 2012 Unofficial
Conference App Released!" example structure is quite confusing:
several solutions in one folder and then different platform projects in one
subfolder with different folder and project names. It can not be accomplished nativly
with IDE. Are they editing content of solution files and folder names manualy
outside of IDE environment?
And for projects of common code what kind of profile (template) to
use? Monotouch has several: Empty Project, MonoTouch Library
Project and MonoTouch Binding Projects? In Android i supose -
Android class library?
This is a very general question, but here are a few resources that may help you get started:
Video: Cross-platform Mobile Development
Blog Post: Shared Libraries For Windows Phone 7, MonoDroid and Beyond
Book: Mobile Development with C#
Blog Post: Xamarin Mobile World Congress 2012 Unofficial Conference App Released!
Edit (to answer your new questions)
The idea behind linking files across projects is that there is only one actual copy of the file, rather than having to manage multiple copies and keep them in sync yourself. The file will actually exist in just one project and be linked into the others, but when the projects are compiled it treats the file as if it were actually there.
I can't speak to exactly how they created their folder structure, but I know there have been many cases where I would manually edit project or solution files to get the folder structure I want, because there was no way to get what I wanted through the IDE alone. This really boils down to personal preference on how you want your folders to be structured.
In the end, what you need is a class library project for every platform you want to target. When going with the linked file approach, it's totally up to you where you put the physical files. One approach I use often is to actually create a standard .NET 4.0 class library, put the files in there, and then link them into my Mono for Android and MonoTouch class libraries. If all you care about is targeting iOS and Android, that may be more trouble than it's worth, and you can just let the files live in one project and link them into the other.
Disclaimer: I've got a particular Mvvm methodology that I use for sharing code across multi-platform projects...
Despite this, I genuinely don't believe in "one size fits all" frameworks - I think you need to be careful to pick an approach that best suits your project, your developers and your organisation.
With that said, some of the tools you can use within the Mono development approach are:
using Portable Class Libraries to share exactly the same code between platforms
using platform specific Class Libraries to share code between platforms, linking these using the Project Linker tool from Microsoft
using #define code within your class libraries to provide platform specific implementations of the projects (I personally try to avoid this approach, but it does often provide the quickest route to market)
using DI/IoC techniques to provide components for those occasions when platform specific implementations really are required.
using a assembly linking to provide IoC - e.g. this is what the Xamarin MobileAPI does
using server-based logic for genuine shared functionality - e.g. using REST or SOAP-XML services to implement logic
sharing tests (e.g. NUnit) between platforms to assure the quality of your logic
using shared code techniques - MVC (MonoCross) or MVVM (MonoMobile.Views or MvvmCross) for UI "controller" logic; MonoTouch.Dialog and MonoDroid.Dialog for "View-level" abstractions; CrossGraphics for UI "drawing"; SQLite.Net for database; etc.
I'm finding the MonoTouch, MonoDroid and the Microsoft tools provide real and signigicant benefits in developing cross platform code - but you do have to work and think to achieve this.
I'm a Windows developer and I need to develop a Linux application.
The goal is to have a fullscreen application being able to display different media types (images, videos, flash). There might be multiple media files being displayed at the same time on the screen (if the screen is split in multiple zones).
Can someone point me in the right direction as to what is the most appropriate technology/tools/frameworks to use?
I have experience with C#, C++ and Objective C.
Thanks,
Pyt
You could look into MPlayer's libraries, that are extensively used by several Linux applications as a backend.
Best of all, its cross OS and of high quality.
Qt for the gui
Probably C++ for the code
You could look at FFMPEG libraries (http://ffmpeg.org/index.html)
QtMediaHub (http://qt-project.org/wiki/QtMediaHub) has some useful (and pretty stable) classes and sample implementations.