Stiler, Styles

Jeg har lagt ut et lite eksemplel på hvordan du kan laste opp en stil ved runtime. Egentlig hadde jeg tenkt å bruke en INI-fil, men vi får se om jeg får tid og lyst til å gjøre det (skuffelsen med Firemonkey grafikk bibliotek som jeg nevnte 🙂 )

Siden med innlegget ligger her:

Eksempler->RAD Code Samples->Stiler, Styles

Edit Undo

Jeg har lagt ut en ny side med info om min løsning på en edit-undo. Dette løste jeg ved å opprette en «Stack» i dokument-klassen og rett og slett «stacke» den originale bitmapen.

Den er foreløpig i testversjon, men prinsippet ser ut til å virke 🙂

Siden ligger her:

Nytt C++ Eksempel

Har nettopp lagt ut et nytt eksempel vedr. gråtone bilde eller monochrome som Firemonkey kaller det.

Det er mye likt det som er skrevet i bloggen, men jeg synes det blir litt bedre strukturert i meny-sidene.

En annen forskjell (jeg KAN ta feil her) er at i sideoppsettet er det intet oppsett for f.eks. stikkord. Tar jeg feil her? Derfor nevner jeg noen av de nye sidene i bloggpost slik som her 🙂

Den nye siden finnes her:

Eksempler->RAD CodeSamples->Gråskala(Monochrome)

Firemonkey Gråskala

Som en slags avslutning på klagen på Firemonkey ImageLibrary kan jeg jo vise hvordan vi gjør om et RGB til Gråskala i Firemonkey. Det begynner på vanlig måte i hoveddelen med å kaste om på en adresse:

void __fastcall TForm1::menu_IMAGE_GRAYSCALE_Click(TObject *Sender)
{
	if (TabControl1->TabCount < 1 ) {
		return;
	}
	 TTabItem   *myTabItemPtr;

	 // Get a pointer to active tab

	 myTabItemPtr = TabControl1->ActiveTab;

	 // Type cast to class DocPage and
	 // let DocPage do the job
	 ((DocPage *) myTabItemPtr)->Monochrome();

}

Ikke mye hokus pokus i funksjonen ovenfor, men så fortsetter det i dokumentklassen:

// --------------------------------------------------------------------------
//  				Monochrome
// --------------------------------------------------------------------------

void __fastcall DocPage::Monochrome()
{
	try
	{
		TForm14 *dlgMonochrome =  new TForm14(Application);

		dlgMonochrome->Image1->Bitmap = Image1->Bitmap;
		dlgMonochrome->Caption = _T("Monochrome");

		dlgMonochrome->myMonochrome->Input = dlgMonochrome->Image1->Bitmap;
		//dlgBoxBlur->myBoxBlur->BlurAmount = dlgBoxBlur->TrackBar1->Value / 100;
		dlgMonochrome->Image2->Bitmap = dlgMonochrome->myMonochrome->Output;


		dlgMonochrome->ShowModal();
		if( dlgMonochrome -> iretState == 1 ) {

			// Don't forget the undo-stack

			UndoItem = new TUndoItem();
			UndoItem->UndoName = new String("Monochrome");
			UndoItem->UndoBitmap = new TBitmap();

			// Have to use "Assign()" because everything are pointers!!!

			UndoItem->UndoBitmap->Assign(Image1->Bitmap);
			mystack.push(UndoItem);

			Image1->Bitmap->Assign(dlgMonochrome->Image2->Bitmap);
			//Image1->Bitmap->Monochrome = true;

		}

		dlgMonochrome->DisposeOf();
	}
	catch(...)
	{
		ShowMessage("Monochrome did not succeed");
	}

}

Koden ovenfor viser min måte å lage en dialogboks på, en TForm klasse og så kjøres det en «dlgMonochrome->ShowModal()».

I de fleste av mine filteroperasjoner bruker jeg en dialogboks med to «TImage»-klasser, en for originalen og en for sluttresultatet. Bildet nedenfor viser det ved designtidspunkt i RAD-Studio

Koden for selve TForm-klassen er vist nedenfor.

//---------------------------------------------------------------------------

#ifndef MonochromeH
#define MonochromeH
//---------------------------------------------------------------------------
#include <System.Classes.hpp>
#include <FMX.Controls.hpp>
#include <FMX.Forms.hpp>
#include <FMX.Controls.Presentation.hpp>
#include <FMX.StdCtrls.hpp>
#include <FMX.Types.hpp>
#include <FMX.Effects.hpp>
#include <FMX.Filter.Effects.hpp>
#include <FMX.Objects.hpp>
//---------------------------------------------------------------------------
class TForm14 : public TForm
{
__published:	// IDE-managed Components
	TImage *Image1;
	TImage *Image2;
	TButton *Cancel;
	TButton *OK;
	void __fastcall OnCreate(TObject *Sender);
	void __fastcall CancelClick(TObject *Sender);
	void __fastcall OKClick(TObject *Sender);
private:	// User declarations
public:		// User declarations
	int iretState;
	TFilterMonochrome * myMonochrome;
	__fastcall TForm14(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm14 *Form14;
//---------------------------------------------------------------------------
#endif

De enkelte funksjonene i klassen ovenfor er det heller ikke mye å si om, de vises nedenfor:

//---------------------------------------------------------------------------

#include <fmx.h>
#pragma hdrstop

#include "Monochrome.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.fmx"
TForm14 *Form14;
//---------------------------------------------------------------------------
__fastcall TForm14::TForm14(TComponent* Owner)
	: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm14::OnCreate(TObject *Sender)
{
	myMonochrome = new TFilterMonochrome(this);

	 myMonochrome->Input = Image1->Bitmap;
	 //TrackBar1->Value = 25;
	 //myPixelate->BlockCount = TrackBar1->Value;
	 Image2->Bitmap = myMonochrome->Output;

}
//---------------------------------------------------------------------------
void __fastcall TForm14::CancelClick(TObject *Sender)
{
	iretState = 0;
	Close();

}
//---------------------------------------------------------------------------
void __fastcall TForm14::OKClick(TObject *Sender)
{
	iretState = 1;
	Close();

}
//---------------------------------------------------------------------------

Jeg konstruerer et monokrom filter ved inngangen, og så kan du se jeg kobler outputen fra filteret til inputen i Image2. til sist setter jeg en returstatus ved exit tidspunkt.

Kjøring av programmet ser slik ut:

Firemonkey Image Library 1

Jeg har klaget mye på Firemonkey og deres image library i C++ Builder, og jeg kan jo vise med et eksempel hva jeg mener. Jeg brukte et bilde (av meg selv 🙂 ) og gjorde det om til gråskalabilde i PhotoShop.

Deretter laget jeg en «properties» dialogboks i mitt eget program og listet ut de verdiene Firemonkeys bibliotek ga meg. Da kan jeg samtidig vise design av en dialogboks i C++ builder.

Design dialogboks
Dialogboks i C++ Builder
Gråskala fra Photoshop
Et Gråskala bilde fra Photoshop
Properties dialogboks i Firemonkey
«Gråskalabilde» i Firemonkey

I bildet ovenfor ser du hvilke verdier jeg får fra Firemonkeys bibliotek. Hvis du bare skal småfikse litt på bilder fra mobilen, er dette biblioteket mer enn godt nok.

Til profesjonelt bruk er det etter min mening ubrukelig!

Gamlisens Fotobox

Planen var først å lage et program for enkel bilderedigering, for så ved neste utgave å legge til et dokumentformat, dvs. tilsvarende et skrivebord, et A4 ark (dokument redigering).

Status Jan. 2020:
Fotobox 1 kan anses ferdig med bl.a. copy/paste, crop og filter funksjoner.

Fotobox 2 ikke påbegynt p.g.a misnøye med Firemonkeys grafikkbibliotek. Dette gjør om alle formater til 32 bits RGB internt. Det betyr at om du åpner ett eller annet bildeformat og så lagrer det tilbake, vil det lagres som 32 bits RGB uansett hva det var på forhånd.

Jeg begynner likevel å legge ut eksempler fra kodingen, så får tid og humør bestemme den videre utvikling.

Gråtoner og andre toner

Hvorfor «ødelegger» Firemonkey bildene? Hæææ? Ødelegger??? Yess Sir, de gjør om alle bildeformater internt til RGB!

Jeg tenkte ikke over det før jeg ønsket å få bildeinfo fra biblioteket. Uansett hvilket bilde jeg lastet opp («åpnet»), fikk jeg til svar at det var 32 bit RGB! Det betyr 3×8 bit + alpha.

Etter et par dager med hardkjøring av Google, var svaret gitt. Det bare var sånn!

Hva betydde det for meg? OK, Hvordan lages gråtoner f.eks. på skjermen? Jadajada, skjermen er RGB den! Oissann! Hva med printeren da? Den bruker CMYK, helsort farge og rasterteknikk, min venn! Gråtoner finnes ikke i vår daglige verden!

Finnes det egentlig et sort-hvitt kamera i dag? Jeg er ikke fotograf, så jeg vet egentlig ikke. Jeg tar sjansen og sier nei. Du må antagelig tilbake til de gamle analoge kameraene, med film. Det finnes digitale kamera som tar B&W 🙂

Det finnes en rekke andre spesialformater, jeg er klar over det, men til daglig bruk, ordne og fikse litt på bilder fra mobilen, så er Firemonkey grafikkbibliotek fullt ut brukbart, terningkast 6.

Til profesjonelt bruk, er det ubrukelig.

Et gråtone-bilde fra mitt program:

Gamlisen

RAD Studio

Jeg har lagt inn følgende nytt i menyen (om RAD Studio):

Den leveres med to programmerings språk: Delphi (Pascal) og C++ Builder, og det er C++ jeg programmerer i. Pascal? Som en hardcore C/C++ programmerer «hater» jeg Pascal 🙂 Nå trår jeg antagelig en del på tærne, men Pascal ses på som et skolespråk, C++ er for profene 🙂

Du så jeg avsluttet med et smilefjes, ikke sant?

Skal du skaffe deg en betalt versjon, koster den skjorta og mer til. Heldigvis finnes det en «Community» versjon, og den er gratis. Du må imidlertid velge ett av språkene, C++ eller Delphi (Pascal). Delphi er Borlands object versjon av Pascal. Da må du finne deg i at alt nytt kommer først til Delphi. Delphi er Borland guttas «førstefødte» baby, og slik vil det alltid være.

Som et lite eksempel: Google forlanger nå 64-bits kompilerte programmer. Det har du for Delphi, men ikke (foreløpig?) for C++, kun 32 bits. Noe av det samme har du for linux. Du får Delphi for linux, men ikke C++.

Jeg avslutter den negative vinklingen med: Grafikkbiblioteket for multi-device løsningen, Firemonkey, jobber kun med 32 bits RGB. Kan du leve med at Firemonkey gjør om alle formater til 32-bits RGB internt, er RAD Studio et fantastisk verktøy, etter min mening.

 32-bits RGB problemet gjelder her i Januar 2020. 

Bildeformater

Jeg har nå fått til bruken av de fleste av filterene som følger med RAD Studio. Jeg skal vise koden for noen av eksemplene, men først:
Vær klar over at RAD Sdudio, Firemonkey versjonen, gjør om alle grafiske bilder til 32 Bit RGB fargecode. Dvs. 3 x 8 Bit pluss Alpha. Kan du leve med det, så er RAD Studio en fantastisk løsning.

Du trenger kanskje ikke andre løsninger om du skal lage et program for å ta vare på mobil-bildene dine. En profesjonell utgave av det samme programmet er imidlertid helt ubrukelig fordi den gjør om alle formater til 32 Bit RGB.