I cannot use Webstorm on my Citrix account because the screen isn't rendered properly. It is not easy to describe, it looks like a screen refresh would help. When I scroll through the source, the lines appear one by one, but some regions of the gui (icon, menues,...) are never shown.
Not likely the answer you would expect, but I can only suggest installing WebStorm on a local machine and working with source files located on local drives. All IDE functionality is based on the index of the project files which WebStorm builds when the project is loaded and updates on the fly as you edit your code. To provide efficient coding assistance, WebStorm needs to re-index code fast, which requires fast access to project files. The latter can be ensured only for local files, that is, files that are stored on you hard disk and are accessible through the file system.
Moreover, the fsnotifier tool IDE uses to synchronize its virtual file system with external changes doesn't support remote drives, so you might have problems synchronizing files generated by LESS/SASS compilers and other external tools...
See also https://community.oracle.com/thread/1353486
Related
Say I have Qt set up, with .qrcs pointing to an actual .png file located on disk. It shows up in my application, and everything is going well. Should I now expect that any changes I make to that .png should show up after building and running the project. Or should I only expect these changes to show up after a full rebuild?
At the moment I have the latter behaviour, but can't find any explicit mention of whether Qt has some magic mechanism for tracking file changes? Or is this up to me in the build system to explicitly resources as dependencies to be watched by a target?
Edit:
The build system I'm using is sharpmake, and the configuration is very similar to this: https://github.com/ubisoft/Sharpmake/blob/dev/samples/QTFileCustomBuild/QTFileCustomBuild.sharpmake.cs
I'm currently working on a GUI app that is supposed to decrypt some data and print it on the screen, on Windows and Qt (C++) based. The code works fine and I now have to distribute it.
However, the format of the data to decipher can (and will) evolve, and is described on headers (.h) and sources (.c). Therefore, when this happens, I just have to change these files to the last version, the compilation goes fine and the program runs smoothly. It's a simple drag&drop of the new files in my source folder, really.
I am aware of how to deploy a .exe (with the correct dll and so forth), but I don't think it would work in this case. I briefly looked at how to create installers but i'm not sure that this is the right way to handle the situation (http://doc.qt.io/qtinstallerframework/ifw-creating-installers.html).
How could I distribute this code so that people that want to use it can just change the sources, run a script, and the .exe is generated, even with a computer that does not have Qt ? (but probably mingw32 and only on Windows)
Thanks in advance for your help !
From my understanding, you should include dll's and if the format of the data changes, you can just update and maintain your dll's.
Build your project in release mode and then use QTWinDeploy to finalize the build of the project with all the dependencys the projects require for users without QT.
This is how I maintain and distribute a project similar to yours.
Otherwise, I would recommend looking at self-updating programs.
I do a fair amount of personal development on my computer and have used TortoiseSVN (I'm on windows) for web projects, but haven't used any version control for other languages. Anyways, soon I will be starting a decent sized C++ project and was going to try using SVN for it.
For web development, I normally just used notepad++ and it was really easy to manage it with SVN (just commit the whole source folder). However, for this project I will be using an IDE (most likely Eclipse CDT or Visual Studio) and was wondering what the best practice is to manage all of the IDE, project, and binary files. My guess was to make the IDE project outside of the version control, and just point to all of the source files into the SVN so all of the build and project files aren't committed. This way the only files in the SVN would be the .cpp and .h files.
However, if I wanted to switch to a new branch, then I would need to update the location of all of the source and headers to the new folder which seems like it would be a huge hassle.
Whats the best way to handle this?
Thanks
Ok, it seem I misgot the aim of the question in the first round. Now I'm assuming what is asked really to what to put under source control and what not.
Well, naturally everything but temporary/transient files.
If you install GitExtensions, it right away has a feature to populate the .gitignore file. Certainly depending on language you adjust it. Sure, solution, project, make files belong under control. .USER files storing some IDE preferences do not. As both IDEs and source control is ubiquitously used the content is fairly separated for many years, and should be pretty obvious as you do it.
External dependencies normally also shall be in a repo, though choice shall be made in which one. Some store everything together, others keep one dependency repo, others separate repos per component -- all depends on actual components and workflow. And you can replace physical storage of deps by an info file with stable links to the used version. It may also be covered later on the first change in dependencies.
For Visual Studio, there is a plugin that manages your files for you. As long as the files are part of the project, then they will be put into source control by the plugin. See ankhsvn for plugin info. Note that the express versions of Visual Studio are not supported.
I am sure eclipse has a plugin for SVN as well.
I'm developing a system which will have a PC (windows) component and an iPad component. I'd like to share some C++ code between the iPad and the PC. Is there a way to automatically sync the source files between the project? In other words, if I'm working on the PC and add a new .h/.cpp pair, can I somehone get the xcode project to recognize the new files and add them to the xcode project? Same goes for getting Visual Studio to recognize new files on the PC end.
If this isn't possible, would it make sense to use Eclipse on both the Mac and the PC for this shared library? Is there any other option I should look in to for maintaining a project on both Apple and Windows development environments?
First, you need one common build configuration for all your target platforms. Of course, this means that you can't use the build configurations tied to your IDEs (Visual Studio, XCode, etc.). You need a cross-platform build-system. The best candidate for that, IMO, is CMake. With that system, the CMakeLists.txt files are the primary configuration files for your project. Any new source files / headers will have to be added to that configuration file (or one of them). It might be a little bit less convenient than using the in-IDE facilities to add a header/source pair, but the advantage is that you only have to add the source file once to the build configuration (CMakeLists.txt) and it will apply to all operating systems and IDEs that you are using. CMake can be used to generate project files for most IDEs so that they can be used easily, and some of the better IDEs also support CMake build-configurations directly (which makes it even more convenient). Personally, I don't know of any serious cross-platform project that does not employ an independent cross-platform build-system (like CMake or others with similar capabilities), so this is not really much of a debate anymore.
Second, you need a means to synchronize your files between the two systems, which I presume are physically separated (i.e., not in a virtual box or whatever). There are simple programs like rsync and other more GUI-ish programs to synchronize folders and all its underlying files. However, for source code, it is much more convenient to use a version-control system. Personally, I recommend Git, especially for personal projects. There are many features to a version control system, but the basic thing is that it gives you a simple way to keep source folders synchronized and keep track of the changes that have been made to the code (e.g., allowing to back-track if a bug suddenly appears out of the latest changes). Even if you are working alone, it is still totally worth it to use such a system (and even if you don't really need it, it gives you experience working with one). Git is a decentralized system, meaning that you don't need a central server for the version control, it is all local to each copy of the repository. This allows you to have (as I do for some simple projects), a completely local set of repositories, for instance, I have two computers I work with, with a copy of the repository on each of them, plus a copy of the repository on an external hard-drive, so all the synchronization is done locally between the computers and external drive (with the added bonus of a constantly up-to-date triple backup of everything). You can also use a central server, such as github, which is even more convenient.
Is it possible to combine the following properties, and if so, how?
Store in our version control system some Visual Studio 2008 native C++ (VCPROJ) project files for the developers in our team that use this IDE.
Allow some of those developers to tweak their projects (e.g. using debug version of third-party libraries instead of the usual ones).
Make sure these modifications are done in files that are not versioned.
In other words, I would like to allow developers to tweak some settings in their projects without risking that these changes are committed.
An 'optional VSPROP' file approach seems doomed to fail, as VS2008 refuses to load projects that refer to non-existent VSPROP files...
Any other suggestion? Is this possible with VS2010?
You may not be able to do this but using a solution that generates the vcproj like CMake for example would let you do this. Scripts all your project with CMake and literally conditionally include a config file(if present for example) that developers can change on their setup.
Branches could solve this problem: you create a branch, play with different versions of third-party, merge changes to trunk if results are good.
Well, as a preliminary solution you could put the project file into something like .hgignore or .gitignore after its initial commit.
This way changes to it can't be done accidentally.
At least that's how I handle .hgignore itself.
We use a versionned "common_configuration" folder, and a script which copies project files from this "common_configuration" folder towards the "project" folder.
We have another script to copy the configuration backwards, so the developpers need to make a conscious action to commit their local changes to the global version control system.
It answers partly your needs :
The upside : we have a way to keep a common configuration for everyone, and no accidental committing of local configuration
The downside : blindly copying the files actually crushes local changes. We live with it. We could write some more clever merger tool (using diff, or xml specific manipulations), but don't want to spend to much time on supporting the deployment tools.