I am using iText version 5.5.2 and trying to implement passwords to stop users from editing our generated static XFA pdf reports. I don't think I am able to flatten a static XFA PDF Form (so correct me if I am wrong). My only option at this point, would be to use iText's ability to password protect the form in a way where users will not have to worry about putting in a password to edit the form, but still be able to view it.
Anyway here is the problem. According to the Lowagie's book, implementing a password requires the use of the bouncastle APIs. To do this right, I implemented the iText-5.5.2. Searching through this iText dependencies, I found that the maven POM for iText-5.5.2 shows that I have a need a couple of bouncycastle jars:
<dependency>
<groupId>org.bouncycastle</groupId>
<artifactId>bcprov-jdk15on</artifactId>
<version>1.49</version>
<type>jar</type>
<scope>compile</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.bouncycastle</groupId>
<artifactId>bcpkix-jdk15on</artifactId>
<version>1.49</version>
<type>jar</type>
<scope>compile</scope>
<optional>true</optional>
</dependency>
When I add these to my project within eclipse of (IBM's CICS Explorer), eclipse complains as follows:
Description Resource Path Location Type Archive for required library: 'C:/Users/nuo3545/jars/bcprov-jdk15on-1.49.jar' in project 'jCicsPdfUtility' cannot be read or is not a valid ZIP file jCicsPdfUtility Build path Build Path Problem
So this indicates that the jar being added (bcprov-jdk15on-1.49.jar) to my project properties libraries or class path is bad, or not being recognized. Is there a solution for this?
Q. Are bouncycastle jars still an issue or broken for usage within iText? What is my recourse of fix to this problem?
Any help or direction with this regard is much appreciated.
I am trying to use the charts in a Maven project for zk but get this error
Library property, org.zkoss.zul.chart.engine.class, required
On the outline the chart icon is there.
any ideas what maven dependency I need to add?
You did not mentioned which ZK version you are talking about here or its a CE or EE or any other product of ZK.
<dependency>
<groupId>org.zkoss.zkforge</groupId>
<artifactId>flashchart</artifactId>
<version>${version.zk}</version>
</dependency>
For your reference you can check ZK Chart Exception
EDIT
For further details about feature in differnt version of ZK you can check Features Comparison between CE,EE,PE version
I have been racking my brain all morning with this. I am using Eclipse and trying to import this 'org.lwjgl.opengl.glu.Sphere;' to my class. but Eclipse can't find this class.
I have been informed in my research that this class resides in lwjgl_util.jar which I have included in the java build path for this project in eclipse. everything else imports except the .glu classes. what am I missing?
First , to setup Eclipse with LWJGL go to LWJGL Wiki page and there you can find nice and detailed tutorial.For the OpenGL modern pipeline tutorials.One nice guy ported examples from "OpenGL SuperBible 5" to LWJGL.Here you will find them.The tutorials use OpenGL 3.3 which means all the old (fixed) functionality ,that you have probably seen in tutorials of NEHE ,is ignored.Hope it helps.
I just resolved this for my project using lwjgl 2.8.5
the classpath is org.lwjgl.util.glu.Sphere it is located in lwjgl_util-2.8.5.jar maven dependency is
<dependency>
<groupId>org.lwjgl.lwjgl</groupId>
<artifactId>lwjgl</artifactId>
<version>${org.lwjgl.version}</version>
</dependency>
<dependency>
<groupId>org.lwjgl.lwjgl</groupId>
<artifactId>lwjgl_util</artifactId>
<version>${org.lwjgl.version}</version>
</dependency>
I am developing application based on the NetBeans platform. I use Maven to build it and I need to provide IDE features in my app (text editing, syntax highliting for XML files and so on).
Which libraries do I need to declare as dependencies to be able to provide the editor support? And what about XML syntax highliting (or full XML files support)? I am kinda lost in those dozens of JARs. Is there any way to include whole NB cluster? (To make sure everyone gets it, once again, I use Maven.)
Thanks for any help.
Have a look at the NetBeans API index in the content section there is a short description about what each API provides. At a guess I think you're wanting to use the Editor Module and maybe the XML API
I think that if you include the following dependency you will get the entire NetBeans (This is not something that I've tried) IDE as a dependecy
<dependency>
<groupId>org.netbeans.cluster</groupId>
<artifactId>ide</artifactId>
<version>RELEASE70</version>
<type>pom</type>
</dependency>
Scenario: The system has number of components, each with its own POM. There are some long dependency chains (A depends on B depends on C, etc.). I want each "non-developer-desktop" build to be a potential release candidate -- if it passes QA, we will deploy it without rebuilding. In other words, I never want to build SNAPSHOT versions as part of my regularly scheduled builds, only versions like 1.3.0.5, 1.3.0.6, etc. I also want to enable the developers to work on multiple components at once.
To forestall some expected suggestions: the Maven Release Plugin doesn't help me ... unless there's some magic way I can have my dependency versions not be SNAPSHOTs in the POMs but still let the developers work on more than one component at once?
How should we manage the project and dependency versions in all of our our POMs? Right now it's just SNAPSHOTs everywhere, which makes things simple for the developers (they started with SNAPSHOTs and never concerned themselves with anything else). But it's worrying at deployment time (builds with SNAPSHOT dependencies are not well-defined, and not reproducible).
I'd like to avoid excessive juggling at build time, but right now I don't see any way around it.
Let's say I have components util, libj, libk, APP, and UI, with dependencies as follows:
libj -> util (libj depends on util)
libk -> util
APP -> libj
UI -> libj, libk
I have development teams working on APP and UI, and they will sometimes need to make changes/additions to some of the dependencies (even util) in order to enable their current work. How should the checked-in POM and dependency versions for each component look?
Edit: I updated the title to refer to Maven 2 instead of 2.0, since it became apparent that I would need to work with 2.1 or better in order to best resolve this.
Try to layout your builds such that modules that need to be developed together are released together. This will let the maven release plugin do most of the work for you.
For dependencies that really should have a separate lifecyle...because they change infrequently or are shared by multiple projects, you want to handle those differently. They way I do it is to keep the dependencies at the last release version until a change actually requires an upgrade to the next snapshot. In this way when you go to release the product, you will find all the things that may also be released simply by following the snapshot trails.
I find it also helpful to keep the external dependency versions specified as properties in the top pom of my project. This makes it easy to see at a glance what needs to be released. Look for an example of the Nexus pom.
This is something I find very difficult with maven and internal projects; you have two version control systems (maven's, which, quite frankly, isn't very good) and your source code control's (which, assuming it's CVS or better, supports real workflow).
Here's how we do it:
report --depends on--> core
web --depends on--> core
We use the maven release plug:
report's pom, during development, would have a SNAPSHOT version matching what's in core's pom. I do a mvn clean install in core, then I can see those changes in report in my local environment.
When I do a release of report, I must first release core via the maven release plug. When I I use it on core, it asks me to set the version of core to release (i.e. remove the -SNAPSHOT), to which I say yes, and the resulting released artifact doesn't depend on a SNAPSHOT release. When the release plugin is done, the report pom now depends on the next SNAPSHOT release of core (though you can override this during mvn release:prepare if you want).
The devs on web then get an email that a new version of core is available and they can choose to use it if they wish. Our policy is that they should update before releasing.
This is really the same problem as someone needing to branch code they are working on. You need some form of identifier to be able to get at the specific version until you merge back to the mainline development of that component.
The dependency classifier may be something worth looking into. You'll still need to have developers that will properly identify their modified code.
we work with a "Super Parent".pom-project, in it the versions are defined as properties and in every child.project, the versions are set with those properties
in addition the real projects have no version set, instead they inherit it from their parent pom-project (incl. groupId etc.)
with this set up the versions are only defined in some parent pom-projects, thus the needed setup is minimized
e.g. this structure
super parent pom-project (all 3rd party versions as properties defined, e.g. 2.5.6 spring-framework)
---- persistence-parent pom-project, inherits all from super parent
------ persistence-foobar jar project, inherits all from persistence-parent
---- util-parent
etc.
only versions you see are the ones inside the parent relations
example:
<modelVersion>4.0.0</modelVersion>
<artifactId>foo-bar-foo</artifactId>
<packaging>jar</packaging>
<name>whatever</name>
<description>...</description>
<parent>
<groupId>org.foo.bar</groupId>
<artifactId>persistence-parent</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>
<dependencies>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>foo-bar</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>foo-bar</artifactId>
<version>${project.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>org.springframework.jdbc</artifactId>
<version>${parent.spring.version}</version>
</dependency>
it works this way, because inside the pom you can use already defined values like version, even if the version is set via inheritance
we combine this with module setups inside the parent projects to make the builds easier