Archivi tag: Programming

Reports molto grandi con Jasper Reports

In caso di report molto grandi è buona norma utilizzare la caratteristica “VIRTUALIZER” che permette di serializzare l’output delle pagine del report su file system, evitando di occupare tutta la memoria disponibile.

Esistono vari tipi di Virualizer

– JRFileVirtualizer, che tiene in memoria solo il numeri di pagine desiderato e conserva le pagine in eccedenza in dei file. In questo caso lo svantaggio è legato all’overhead della gestione dei file. Durante il processo di elaborazione vengono prodotti molti file. Alla fine del processo questi file vengono utilizzati per produrre il file del report finale. Questo virtualizer può essere usato quando si non si hanno sorgenti di dati molto grandi.

– JRSwapFileVirtualizer, che supera lo svantaggio del JRFileVirtualizer utilizzando un unico file in cui memorizzare le pagine in eccedenza. Questo virtualizer è consigliato per sorgenti di dati molto grandi.

– JRGzipVirtualizer, è uno speciale virtualizer che invece di scrivere i dati in dei file, li comprime usando l’algoritmo gzip, riducendo l’uso di memoria.

Esempio:

JRSwapFile swapFile = null;
JRAbstractLRUVirtualizer vir = null;

if (getConfig().getVitualizerType().equalsIgnoreCase("swap")) {
  swapFile = new JRSwapFile(getOutputPath(), getConfig().getVitualizerMaxBlockSize(), getConfig().getVitualizerMinGrow());
  vir = new JRSwapFileVirtualizer(getConfig().getVitualizerMaxPage(), swapFile, true);
} else if (getConfig().getVitualizerType().equalsIgnoreCase("file")) {
  vir = new JRFileVirtualizer(getConfig().getVitualizerMaxPage(), getOutputPath());
}

if (vir != null) {
  params.put(JRParameter.REPORT_VIRTUALIZER, vir);
}

jp = JasperFillManager.fillReport(reportFilename, params, getDataSource());

Fletto i muscoli e sono nel vuoto.

powered by IMHO 1.3

Catturare lo stato del tasto SHIFT durante il click del mouse

E’ possibile conoscere lo stato del tasto shift (e non solo) utilizzando la funzione

[DllImport(“user32.dll”)]
static extern short GetKeyState(VirtualKeyStates nVirtKey);

Grazie a questa funzione possiamo conoscere lo stato di uno dei seguenti tasti:

public enum VirtualKeyStates : int
{
VK_LBUTTON = 0x01,
VK_RBUTTON = 0x02,
VK_CANCEL = 0x03,
VK_MBUTTON = 0x04,
//
VK_XBUTTON1 = 0x05,
VK_XBUTTON2 = 0x06,
//
VK_BACK = 0x08,
VK_TAB = 0x09,
//
VK_CLEAR = 0x0C,
VK_RETURN = 0x0D,
//
VK_SHIFT = 0x10,
VK_CONTROL = 0x11,
VK_MENU = 0x12,
VK_PAUSE = 0x13,
VK_CAPITAL = 0x14,
//
VK_KANA = 0x15,
VK_HANGEUL = 0x15,
/* old name – should be here for compatibility */
VK_HANGUL = 0x15,
VK_JUNJA = 0x17,
VK_FINAL = 0x18,
VK_HANJA = 0x19,
VK_KANJI = 0x19,
//
VK_ESCAPE = 0x1B,
//
VK_CONVERT = 0x1C,
VK_NONCONVERT = 0x1D,
VK_ACCEPT = 0x1E,
VK_MODECHANGE = 0x1F,
//
VK_SPACE = 0x20,
VK_PRIOR = 0x21,
VK_NEXT = 0x22,
VK_END = 0x23,
VK_HOME = 0x24,
VK_LEFT = 0x25,
VK_UP = 0x26,
VK_RIGHT = 0x27,
VK_DOWN = 0x28,
VK_SELECT = 0x29,
VK_PRINT = 0x2A,
VK_EXECUTE = 0x2B,
VK_SNAPSHOT = 0x2C,
VK_INSERT = 0x2D,
VK_DELETE = 0x2E,
VK_HELP = 0x2F,
//
VK_LWIN = 0x5B,
VK_RWIN = 0x5C,
VK_APPS = 0x5D,
//
VK_SLEEP = 0x5F,
//
VK_NUMPAD0 = 0x60,
VK_NUMPAD1 = 0x61,
VK_NUMPAD2 = 0x62,
VK_NUMPAD3 = 0x63,
VK_NUMPAD4 = 0x64,
VK_NUMPAD5 = 0x65,
VK_NUMPAD6 = 0x66,
VK_NUMPAD7 = 0x67,
VK_NUMPAD8 = 0x68,
VK_NUMPAD9 = 0x69,
VK_MULTIPLY = 0x6A,
VK_ADD = 0x6B,
VK_SEPARATOR = 0x6C,
VK_SUBTRACT = 0x6D,
VK_DECIMAL = 0x6E,
VK_DIVIDE = 0x6F,
VK_F1 = 0x70,
VK_F2 = 0x71,
VK_F3 = 0x72,
VK_F4 = 0x73,
VK_F5 = 0x74,
VK_F6 = 0x75,
VK_F7 = 0x76,
VK_F8 = 0x77,
VK_F9 = 0x78,
VK_F10 = 0x79,
VK_F11 = 0x7A,
VK_F12 = 0x7B,
VK_F13 = 0x7C,
VK_F14 = 0x7D,
VK_F15 = 0x7E,
VK_F16 = 0x7F,
VK_F17 = 0x80,
VK_F18 = 0x81,
VK_F19 = 0x82,
VK_F20 = 0x83,
VK_F21 = 0x84,
VK_F22 = 0x85,
VK_F23 = 0x86,
VK_F24 = 0x87,
//
VK_NUMLOCK = 0x90,
VK_SCROLL = 0x91,
//
VK_OEM_NEC_EQUAL = 0x92, // ‘=’ key on numpad
//
VK_OEM_FJ_JISHO = 0x92, // ‘Dictionary’ key
VK_OEM_FJ_MASSHOU = 0x93, // ‘Unregister word’ key
VK_OEM_FJ_TOUROKU = 0x94, // ‘Register word’ key
VK_OEM_FJ_LOYA = 0x95, // ‘Left OYAYUBI’ key
VK_OEM_FJ_ROYA = 0x96, // ‘Right OYAYUBI’ key
//
VK_LSHIFT = 0xA0,
VK_RSHIFT = 0xA1,
VK_LCONTROL = 0xA2,
VK_RCONTROL = 0xA3,
VK_LMENU = 0xA4,
VK_RMENU = 0xA5,
//
VK_BROWSER_BACK = 0xA6,
VK_BROWSER_FORWARD = 0xA7,
VK_BROWSER_REFRESH = 0xA8,
VK_BROWSER_STOP = 0xA9,
VK_BROWSER_SEARCH = 0xAA,
VK_BROWSER_FAVORITES = 0xAB,
VK_BROWSER_HOME = 0xAC,
//
VK_VOLUME_MUTE = 0xAD,
VK_VOLUME_DOWN = 0xAE,
VK_VOLUME_UP = 0xAF,
VK_MEDIA_NEXT_TRACK = 0xB0,
VK_MEDIA_PREV_TRACK = 0xB1,
VK_MEDIA_STOP = 0xB2,
VK_MEDIA_PLAY_PAUSE = 0xB3,
VK_LAUNCH_MAIL = 0xB4,
VK_LAUNCH_MEDIA_SELECT = 0xB5,
VK_LAUNCH_APP1 = 0xB6,
VK_LAUNCH_APP2 = 0xB7,
//
VK_OEM_1 = 0xBA, // ‘;:’ for US
VK_OEM_PLUS = 0xBB, // ‘+’ any country
VK_OEM_COMMA = 0xBC, // ‘,’ any country
VK_OEM_MINUS = 0xBD, // ‘-‘ any country
VK_OEM_PERIOD = 0xBE, // ‘.’ any country
VK_OEM_2 = 0xBF, // ‘/?’ for US
VK_OEM_3 = 0xC0, // ‘`~’ for US
//
VK_OEM_4 = 0xDB, // ‘[{‘ for US
VK_OEM_5 = 0xDC, // ‘\|’ for US
VK_OEM_6 = 0xDD, // ‘]}’ for US
VK_OEM_7 = 0xDE, // ””‘ for US
VK_OEM_8 = 0xDF,
//
VK_OEM_AX = 0xE1, // ‘AX’ key on Japanese AX kbd
VK_OEM_102 = 0xE2, // “<>” or “\|” on RT 102-key kbd.
VK_ICO_HELP = 0xE3, // Help key on ICO
VK_ICO_00 = 0xE4, // 00 key on ICO
//
VK_PROCESSKEY = 0xE5,
//
VK_ICO_CLEAR = 0xE6,
//
VK_PACKET = 0xE7,
//
VK_OEM_RESET = 0xE9,
VK_OEM_JUMP = 0xEA,
VK_OEM_PA1 = 0xEB,
VK_OEM_PA2 = 0xEC,
VK_OEM_PA3 = 0xED,
VK_OEM_WSCTRL = 0xEE,
VK_OEM_CUSEL = 0xEF,
VK_OEM_ATTN = 0xF0,
VK_OEM_FINISH = 0xF1,
VK_OEM_COPY = 0xF2,
VK_OEM_AUTO = 0xF3,
VK_OEM_ENLW = 0xF4,
VK_OEM_BACKTAB = 0xF5,
//
VK_ATTN = 0xF6,
VK_CRSEL = 0xF7,
VK_EXSEL = 0xF8,
VK_EREOF = 0xF9,
VK_PLAY = 0xFA,
VK_ZOOM = 0xFB,
VK_NONAME = 0xFC,
VK_PA1 = 0xFD,
VK_OEM_CLEAR = 0xFE
}

Lo stato del tasto può essere: up, down oppure toggled. Infatti, la funzione ritorna:

– stato up, se il primo bit (high-bit) è uguale a 1, stato down altrimenti.

– stato toggled on, se l’ultimo bit (lower-bit) è uguale a 1, toggle off altrimenti. Questo stato è usato per i pulsanti come CAPS LOCK, ed indica se attivo o meno.

Il seguente esempio permette di conoscere lo stato SHIFT, lo stato del tasto R-SHIFT e lo stato del tasto L-SHIFT.

//
// Vero se L-SHIFT è premuto
//
bool lshift = ((GetKeyState(VirtualKeyStates.VK_LSHIFT) & 256)==256);
//
// Vero se R-SHIFT è premuto
//
bool rshift = ((GetKeyState(VirtualKeyStates.VK_RSHIFT) & 256)==256); short x = GetKeyState(VirtualKeyStates.VK_SHIFT); if ((x & 0x80) != 0)
{
// E’ stato premuto uno shift
}
else
{
// Non è stato premuto uno shift
}
//

Fletto i muscoli e sono nel vuoto.

Controllare gli eventi di sistema

Potrebbe capitavi di dover controllare gli eventi di sistema come (la disconnessione o la sospensione della sessione) per evitare perdite di dati.

Per C# qui trovate un ottimo articolo per la loro gestione

Fletto i muscoli e sono nel vuoto.

Reflector 5.0.1.0

Qui potete trovare la nuova release di Reflector.

Un utile strumento per lo studio di assembly scritti in C#, VB e IL

Mentre qui potete trovare una vasta serie di addins

powered by IMHO 1.3

StarUML

Un ottimo strumento open source per la modellazione UML/MDA

Fonte: CarlitoWaY

Download: staruml download page

Home page: staruml home page

powered by IMHO 1.3 

java.util.zip – Compressing/Decompressing a Byte Array

Ecco un esempio di utilizzo di java.util.zip per la compressione di un array di byte.

byte[] input = "some some bytes to compress".getBytes(); // Configuriamo il livello di compressione
Deflater compressor = new Deflater();
compressor.setLevel(Deflater.BEST_COMPRESSION); // Inseriamo i dati da comprimere.
compressor.setInput(input);
compressor.finish(); // Creiamo un array espandibile per contenere i dati compressi.
// Non possiamo utilizzare un array delle stesse dimensioni dei dati in
// input perché non è garantito che la i dati compressi abbiano una
// dimensione inferiore all'originale.
ByteArrayOutputStream bos = new ByteArrayOutputStream(input.length); // Avvio compressione
byte[] buf = new byte[1024];
while (!compressor.finished()) {
int count = compressor.deflate(buf);
bos.write(buf, 0, count);
}
try {
bos.close();
} catch (IOException e) {
} // Prelievo dati compressi
byte[] compressedData = bos.toByteArray(); 

Decompressing a Byte Array

// Inseriamo i dati da decomprimere
Inflater decompressor = new Inflater();
decompressor.setInput(compressedData); // Creiamo un array espandibile per la decompressione dei dati.
ByteArrayOutputStream bos = new ByteArrayOutputStream(compressedData.length); // Avvio decompressione
byte[] buf = new byte[1024];

while (!decompressor.finished()) {
try {
int count = decompressor.inflate(buf);
bos.write(buf, 0, count);
} catch (DataFormatException e) {
}
}
try {
bos.close();
} catch (IOException e) {
} // Prelievo dati decompressi.

byte[] decompressedData = bos.toByteArray();

Fletto i muscoli e sono nel vuoto.

Fonte: The Java Developers Almanac 1.4

powered by IMHO 1.3

Internet Explorer Attachments Error

Ecco un altro errore di IE.

Quando inviate sulla response un allegato.

response.setHeader(“Content-disposition”,
“attachment; filename=” + outputFilename);

IE vi chiede se volete aprirlo o salvarlo. Se lo salvate non c’è problema. Tuttavia se provate ad aprirlo, molto probabilmente non riuscirete a farlo.

Per ovviare al problema bisogna aggiugere:

response.setHeader(“Expires”, “0”);
response.setHeader(“Pragma”, “cache”);
response.setHeader(“Cache-Control”, “private”);

Fletto i muscoli e sono nel vuoto.

powered by IMHO 1.3

select onclick con Explorer

Dopo i readonly e le popup ecco che ci risiamo! Explorer non esegue gli eventi onclick per gli item di una select.

<select>
<
option value=”a” onclick=”clikka(‘a’)”>A</option>
<
option value=”b” onclick=”clikka(‘b’)”>B</option>
<
/select>

Per ovviare al problema è possibile usare l’evento onchange sul tag select.

<select onchange=”clikka(value)”>
<
option value=”a”>A</option>
<
option value=”b”>B</option>
<
/select>

Fletto i muscoli e sono nel vuoto.

Javascript ReadOnly! con Explorer

Dopo il problema sulle pop up. Ecco che explorer si ripresenta sugli attributi readonly dei tag input. Il nome dell’attributo è case sensitive (per explorer), quindi bisogna scrivere “readOnly”.

< input readOnly=”true” >

Fletto i muscoli e sono nel vuoto.

Cross-windows scripting Tip & Tricks

In How to: Cross-windows scripting viene mostrato come sia semplice eseguire una popup che aggiorni i dati nella form chiamate. Tuttavia con explorer potrebbe capitavi dei malfunzionamenti nell’inserimento del secondo parametro:

.open(url,”name”,”height=200,width=150″);

Al momento l’unica soluzione proposta è quella di non inserire il secondo parametro:

.open(url,””,”height=200,width=150″);

Fletto i muscoli e sono nel vuoto.