As you may know, ImageGlass 9 has been built from the ground up. In any photo-viewing app, the viewer component is the heart of the experience. The design might not be perfect, and button sizes may vary, but the main viewer — where users view and interact with their photos — needs to be smooth, responsive, and fast. I began developing version 9 by experimenting with various approaches to find the one that best matched my needs and skills.

From the experiments…

In Dec 2017, I started the “ImageGlass-Photos” project, hoping to create a cross-platform version of ImageGlass. It featured a sleek UI inspired by the Windows 10 Fluent Design language, but the project didn’t get far due to poor performance and high memory usage.

In mid-2020, the “ImageGlass Preview” project was born, trying the latest technology of Windows: UWP. Eventually, it ended up being abandoned due to the limitations and restrictions of UWP framework. A simple task such as opening a file picker dialog also required way more effort than with WinForms. I was lost — what happened to Windows native app development? Should I stick with the outdated WinForms or WPF, or struggle through the limitations of UWP?

Around the same time in mid-2020, I decided to experiment with the WPF framework for the “ImageGlass α” project, using Ashley Davis’s “ZoomAndPanControl” code as a foundation. The app looked smooth and beautiful, but the control lacked UI virtualization, making it sluggish when opening large photos. Additionally, the WPF app was slow to launch and consumed a lot of memory. Once again, the experiment ended in disappointment.

In July 2021, with .NET 5 supporting WinForms and WebView2 gaining popularity, I kicked off a new project called “HapplaBox” — a hybrid application combining C# WinForms with web technology. This app utilized C# libraries from the “ImageGlass α” project, the Thumbnail component from “ImageGlass-Photos”, and a new JavaScript viewer component. It worked well initially until a communication issue arose between WebView2 and the C# backend code, leading to yet another abandonment of the project.

Not giving up, I continued researching zoom and pan algorithms for the viewer component, determined to develop my own native solution. I came across Mohammed Abd Alla’s article, “A Picture Viewer Class that can Scroll and Zoom using API”, which offered a basic implementation of zoom and pan that worked surprisingly well. I successfully created a quick native GDI-based viewer component. However, when I tried to add support for transparency and animation, I ran into significant challenges due to the outdated GDI APIs. As a result, the viewer component remained just a proof of concept.

… to the release of ImageGlass 9 Beta 1

While exploring the DirectX domain, I discovered that Direct2D offered the native hardware acceleration I needed but using it with C# wasn’t straightforward. I found the “d2dlib” project, a .NET library for Direct2D rendering, and quickly ported my GDI code to work with it. I then developed more advanced features, including smooth zoom and pan, text rendering, and custom controls. I incorporated the image backend library from the “HapplaBox” project and created a new toolbar and menu component. It all worked wonderfully — until I started adding more image features: the limitations of the Direct2D APIs provided through “d2dlib” meant that I couldn’t implement transparency and animation effectively. Despite these setbacks, I remained optimistic about this approach and decided to publish it, leading to the birth of ImageGlass 9 Beta 1 in May 2022.

… and the stable foundation of ImageGlass 9 — ImageGlass 9 Beta 2!

Unhappy with the limitations of the “d2dlib” library, I delved into its C++ source code to try to expose more features from Direct2D. However, my limited knowledge of C++ made it challenging. I continued searching for alternatives and came across the “WicNet” and “DirectN” projects. These were exactly what I needed! They provided direct interop APIs for Direct2D without the need to create new ones. This meant I could seamlessly port the Direct2D C++ APIs to C#. Additionally, they supported the latest features of Direct2D, allowing me to easily develop and take ownership of the technology.

I created the “D2Phap.DXControl” library — a WinForms hybrid control that supports both Direct2D and GDI+ drawing, serving as the foundation for the Direct2D component used in ImageGlass. I replaced the viewer component based on “d2dlib” with a new one built on “D2Phap.DXControl”, successfully resolving all outstanding issues.

In Sep 2022 — 4 months after the Beta 1, ImageGlass 9 Beta 2 was released!

… to the final ImageGlass 9

Building on the success of the viewer component, more features were added.

• Beta 3 was a significant release, introducing a new Crop tool and focusing on modernizing the app’s appearance. Implementing support for Windows 10 and 11 backdrop styles, such as Acrylic, Mica, and Mica Alt within the WinForms framework proved to be quite a challenge. I plan to write another blog post to share more details about this process.
• Beta 4 brought more features from ImageGlass 8, including support for layout customization and external tools. This release introduced the “ImageGlass.Tools” library for developers looking to integrate their applications with ImageGlass, which led to the creation of the “ExifGlass” app — an EXIF metadata viewing tool.
• Beta 5 marked a significant milestone with the integration of the web viewer component from the “HapplaBox” project, enabling seamless SVG viewing. Its core JavaScript library was split off into a separate project called “happlajs”.
• RC (Release Candidate) helped bridge the gap between ImageGlass 8 and the new features introduced in ImageGlass 9.

From the initial experiment to the GA release of ImageGlass, it took five years — a long journey for any indie open-source developer. Without the encouragement and support from ImageGlass users, especially those who donated, I might not have completed the revamp. ImageGlass 9 opens up a new path for its future development.

Stay tuned for more posts to come!

The next version of ImageGlass is v8.0, and one of the most exciting features is Exif tool. This new tool helps you view Exif metadata of the viewing image, copy selected value, and export all data to text file. Currently, Exif tool is now available for testing in ImageGlass Moon.

Exif tool of ImageGlass is actually an external application, https://exiftool.org/, developed by Phil Harvey. To use it, you need ImageGlass 7.7, or the latest build of ImageGlass Moon. Even though the Exif tool by Phil Harvey supports reading, writing and editing meta information, but ImageGlass 7.7 only supports reading at the moment. I will consider to extend it according to user’s requests.

Configure Exif tool

You can download the Windows executable version at https://exiftool.org/, unzip and rename exiftool(-k).exe to exiftool.exe , place this file in a folder. It’s recommended to keep this file in Configuration folder of ImageGlass.

Then, you need to tell ImageGlass where the exiftool.exe is by locating this file in Settings > Tools > Exif tool, click on Select Exif tool file link button as the below screenshot.

An error message will come up if ImageGlass cannot access to the file, or it is not a valid Exif tool file.

View and export Exif metadata

You can open this tool by Main menu > Tools > Exif tool, or shortcut X. ImageGlass will execute exiftool.exe file, read the output, and display it into a list with nice groups.

• To copy a row, you firstly need to select it, and either click on Copy value button or press Ctrl+C.
• To export all data to text file, you can click on Export… button, and select where to save it. The below screenshot is how the exported Exif metadata looks like:

• Exif tool automatically refreshes the Exif metadata list when you reload or navigate to next image.

ImageGlass is continuing to get improved and added new useful tools / features. You can provide feedback, or report an issue at https://github.com/d2phap/ImageGlass/issues.

Happy Mid-Autumn festival!

First,

ImageGlass and ImageGlass Preview are two different apps.

Don’t let the naming confuses you, they are actually two different apps for different purposes, different users, and not to replace each other.

• ImageGlass is a lightweight, versatile image viewer, written in C# WinForms using .NET Framework, supports Windows 7 SP1 or later. The latest version is 7.6.
• ImageGlass Preview is a modern, versatile image viewer, written in C#, using Universal Windows Platform (UWP), only supports Windows 10. It is still under development, and there is no public release yet.

To get updates about ImageGlass projects, you can follow:

👨‍💻 Github: https://github.com/d2phap/ImageGlass-Preview
💰 Patreon: https://patreon.com/d2phap
🐦 Twitter: @duongdieuphap
📸 Instagram: @ImageGlassApp

Second,

The limitations of ImageGlass

If you follow ImageGlass’s Github, you can see some issues about performance which cannot (or is very hard to) resolve. It’s about hardware acceleration, and slowness of startup time.

ImageGlass uses WinForms UI framework which born in 2002, 18 years ago. WinForms’ controls are rendered using GDI+, and GDI+ itself is not hardware acceleration.

Another common topic about ImageGlass is its startup time slowness. This is typical of .NET Framework applications; even though, there are some tricks to optimize it. The slowness often happens in the first time you run .NET app after starting PC because .NET Runtime will compile the codes and load into memory. However, it’s much faster when you run from the second time.

Due to these two limitations, lots of awesome ideas about a fancy, beautiful UI were rejected.

Third,

Goals of ImageGlass Preview

ImageGlass Preview uses UWP platform which is the latest cutting-edge technology of Microsoft. The apps built with UWP has the beautiful Fluent design system, flexible layout, transition, and great performance.

ImageGlass Preview is designed for high DPI devices, works great on touch screens and trackpad gestures. It focuses on viewing functions with a beautiful, modern UI, and convenient UX. It loads image fast, responsive, and able to display big image files.

Roadmap

ImageGlass continues to receive updates and new features, version 8.0 will be releases in 2021 and use .NET 5.0 runtime, while ImageGlass Preview is progressively developed with the basic features of ImageGlass.

For ImageGlass:

• v7.x will be small updates; mostly contains bug fixes, improvements, and some small features.
• v8.0 will contain breaking changes as it will use .NET 5. New features are also expected to introduce.
• v8.x will be small updates, bug fixes.

For ImageGlass Preview:

• v0.1 will be the first public alpha release, for those who want to try it. There will be probably 5 alpha versions from v0.1 to v0.5 to collect feedback from the early adopters.
  Basic features could be: Zoom modes, Thumbnail viewing, Full screen, Slideshow, Window fit, Frameless,…
• v0.6 will be the first public beta release. More features will be added: File manipulations (Copy, cut, delete,…), Color picker, Cropping, External editing app, Theming, Localization, Image frames/pages extraction…
• v1.0 is expected to have most of features of ImageGlass v4.0.

FAQs

1. Is ImageGlass WinForms dead?
   No, I will still maintain, fix bugs, add new features as usual. But the release may take longer, or with smaller updates.
2. What features will ImageGlass Preview focus on?
   It will progressively have basic features of ImageGlass: Zoom modes, Windows modes,… and more customizable layout, keyboard shortcuts…
3. Is ImageGlass Preview to replace the current ImageGlass?
   No, both two apps will live together, for different purposes, different users.
4. Is ImageGlass Preview being planned for a commercial product in the future?
   No, it will be free (literally, no need to pay, no in-app ad) and open source as same as the current ImageGlass.
5. Can I install and run both two apps in a same PC?
   Yes, you can. It has different name, and uses different protocol,… ImageGlass Preview should be installed from Store. For more details, I will talk about it in a separated post.

If you have any questions or suggestions, please don’t hesitate to reach me out

👨‍💻 Github: https://github.com/d2phap/ImageGlass-Preview
💰 Patreon: https://patreon.com/d2phap
🐦 Twitter: @duongdieuphap
📸 Instagram: @ImageGlassApp

Thanks!

I was researching a way how to test our new supported blockchain protocol — Corda on Chainstack platform. Also, this is my first-ever blockchain blogpost. I will share how I carried out end-to-end continuous Corda integration with Nightwatch.js and CircleCI.

🍄 Originally published on January 7, 2020 at https://chainstack.com/corda-automation-testing-with-nightwatch-js-and-circleci/

The code in Corda is written using Kotlin, a programming language from JetBrains, and Nightwatch.js is a Node.js powered end-to-end testing framework. My challenges are to connect to a node, initiate a flow, and have it signed by relevant parties using JavaScript.

I have a few ideas to do this:

• Run a Corda web server in my Docker image, and write JavaScript to interact to the CorDapp.
• Set up GraalVM (a high-performance polyglot VM) in my Docker image, write a Java function in Nightwatch.js.
• Interact with Corda Standalone Shell client by executing shell script in Node.js, then verify the output of shell script.

The first two ideas seem possible, but I need to include CorDapp source code in the test, which is non-optimal and inconvenient. Eventually, the last one is better and simpler.

I use No ticket scalping CorDapp for my test. You may want to explore it before moving to details.

Technology stack

These are the details of programming languages, tools, and frameworks I used in the test:

• Nightwatch.js 1.3.2 / Node.js 11 / shell script;
• Docker;
• CircleCI 2.0;
• OpenJDK-8;
• Corda Standalone Shell client 4.3;
• No ticket scalping CorDapp installed on two Corda nodes, running on Chainstack.

I assume that you are familiar with the Nightwatch.js framework, so I won’t focus on the structure as well as the test case code.

Besides the Corda Standalone Shell client, Chainstack also provides Chainstack standalone shell, which is a containerized version of Corda Standalone Shell, and which helps you interact with the CorDapps. You can learn more about it in our official documentation.

Install OpenJDK-8 in Docker image

You need to install OpenJDK-8 to run Corda Standalone Shell client; add these lines into your Docker file.

# Install OpenJDK-8
RUN apt-get update && \
    apt-get install -y openjdk-8-jdk && \
    apt-get install -y ant && \
    apt-get clean;

# Fix certificate issues
RUN apt-get update && \
    apt-get install ca-certificates-java && \
    apt-get clean && \
    update-ca-certificates -f;

# Setup JAVA_HOME -- useful for docker commandline
ENV JAVA_HOME /usr/lib/jvm/java-8-openjdk-amd64/
RUN export JAVA_HOME

You may need to build your Docker image again.

docker build .

Write shell script to interact with No ticket scalping CorDapp

You can learn the prerequisites to run Corda Standalone Shell client at: https://docs.chainstack.com/operations/corda/tools#corda-standalone-shell

The below script will do the following things:

• Connect to Corda Node 1.
• Print out all flows in Node 1.
• Start noScalpFlow flow to distribute 99 tickets of event Chainstack live concert from Node 1 to Node 2.
• Verify the transaction by executing vaultQuery command.
• Exit the Corda Standalone Shell client.

# location of binary files
CORDA_CLI="corda-tools-shell-cli-4.3-all.jar"
CORDAPP_DIR="../my-cordapps/"

# node 1 credentials
NODE1_HOST="nd-255-728-694.rg-837-380.int.chainstack.com"
NODE1_PORT="10201"
NODE1_USER="vibrant_ptolemy"
NODE1_PASS="*****"

# node 2 legal name
NODE2_LEGALNAME="OU=Chainstack-ND-026-270-261, O=Chainstack, L=Singapore, C=SG"

# command to connect to Corda node 1
START_CORDAPP="java -jar $CORDA_CLI --host=$NODE1_HOST --port=$NODE1_PORT --user=$NODE1_USER --password=$NODE1_PASS --cordapp-directory=$CORDAPP_DIR"

# launch the Corda Standalone Shell client and run flow commands
{
  echo "flow list"
  echo "start noScalpFlow eventName: 'Chainstack live concert', ticketQuantity: 99, toDistributor: '$NODE2_LEGALNAME'"
  echo "run vaultQuery contractStateType: com.noScalpDapp.states.noScalpState"
  echo "bye"
} | $START_CORDAPP

Save as start_cordapp.sh file, and run it in terminal.

Checking the output, there should be a transaction. You can use this information to verify whether the test passed or not.

Flow completed with result: SignedTransaction(id=C98A2B49358B9FC6C1C8EEBAA99DF36238E9E4F97CF492905C2A1EF25B1B9639)

Execute the shell script by Node.js and verify the output

In the below code, I write a function to start the noScalpFlow flow, print out, and verify its result. In Node.js, thechild_process module provides the ability to spawn child processes.

Then, I combine child_process.exe() and util.promisify() to create an async function which returns a boolean Promise.

// Nodejs utils to execute shell script asynchronously
const { promisify } = require('util');
const exec = promisify(require('child_process').exec);

/**
 * Run noScalpFlow flow and verify the result
 * @param {Object} node1 First node
 * @param {Object} node2 Second node
 */
async function verifyFlow(node1, node2) {
  const CORDA_CLI = 'corda-tools-shell-cli-4.3-all.jar';
  const CORDAPP_DIR = '../my-cordapps/';
  const START_CORDAPP = `java -jar ${CORDA_CLI} --host=${node1.host} --port=${node1.port} --user=${node1.user} --password=${node1.pass} --cordapp-directory=${CORDAPP_DIR}`;

  // launch the Corda Shell client and run flow commands
  const { stdout } = await exec(`
    START_CORDAPP="${START_CORDAPP}"
    {
      echo "flow list"
      echo "start noScalpFlow eventName: 'Chainstack live concert', ticketQuantity: 99, toDistributor: '${node2.legalName}'"
      echo "run vaultQuery contractStateType: com.noScalpDapp.states.noScalpState"
      echo "bye"
    } | $START_CORDAPP
  `);

  // Print out the output
  console.log(stdout);

  // Verify the output
  return stdout.includes('Flow completed with result: SignedTransaction');
}

After that, you need a test scenario using the Nightwatch.js framework.

// Node 1 credentials
const node1 = {
  host: 'nd-255-728-694.rg-837-380.int.chainstack.com',
  port: '10201',
  user: 'vibrant_ptolemy',
  pass: 'frisk-lapdog-uneasy-amid-slate-flaky',
};

// Node 2 legal name
const node2 = {
  legalName: 'OU=Chainstack-ND-026-270-261, O=Chainstack, L=Singapore, C=SG',
};

module.exports = {
  '@tags': ['runCorDappFlow'],

  'Run CorDapp flow'(browser) {
    const { page } = browser;
    const corda = page.nodes.corda();

    // Run flow and verify result
    browser.perform(async () => {
      await corda.verifyFlow(node1, node2);
    });

    browser.end();
  },
};

Commit your code and run the workflow in CircleCI; it will take a few minutes to complete. In my scenario, I get the credentials of Node 1 and Node 2, run noScalpFlow flow, and verify the output. You can see results in the below screenshot.

Before writing this post, I have done a lot of researching works to find the best solution for Corda automation testing as most of the resources from the Internet focus on building CorDapps. I believe this post will help your team to test, speed up, and secure your Corda applications like what the Chainstack team is doing.

You can try Chainstack for free at: https://console.chainstack.com.

Config files

As you know, there are 3 different config files, which are loaded in the order:

• igconfig.default.xml, located in Startup dir, specifies the defaults which are used if no other settings are available at first start.
• igconfig.xml, located in Config dir, contains all user settings, written by ImageGlass after closing. This overrules the settings in the igconfig.default.xml file.
• igconfig.admin.xml, located in Startup dir, contains the settings which will overrule all settings in the files above.

ImageGlass will look for every mentioned file, in the described order, and the locations. The configuration is built from zero, setting for setting, by using the following 4 steps:

1. Take the default set by the developer.
2. If a igconfig.default.xml was found, and the settings can be found in there, it will override the values from step 1.
3. If a igconfig.xml was found, and the setting can be found in there, it will override the values from step 2.
4. If a igconfig.admin.xml was found, and the setting can be found in there, it will override the values from step 3.

ImageGlass will use the resulting setting, and when every single setting in the complete configuration is processed, it will write the complete configuration to it’s igconfig.xml file (and only there).

Admin user

If you are admin of a network, and want to install ImageGlass with some default settings, and disable some as well, you can now do it easily with this new Settings engine.

• Set your default configs in igconfig.default.xml file, and the configs that you don’t want the user to change it in igconfig.admin.xml file,
• Deploy both files to startup folder of ImageGlass where the ImageGlass.exe is located.

End user

To end user, it’s easy for you to lock a setting using admin config file. Some examples:

• If you always want to open ImageGlass in maximized window, you can set it in igconfig.admin.xml file:
  <Item key="FrmMainWindowState" value="Maximized" />

You can find all the setting keys in igconfig.xml file.

I have started developing the next version of ImageGlass. One of the most-requested features is Cropping tool will be available soon.

Follow me @duongdieuphap, and stay tuned!

Dương Diệu Pháp on Twitter

Lots of requests about Cropping tool for ImageGlass. Here is the first preview after a sleepless week. https://t.co/G5y1xeZrnU

If you are following this topic, you may see my updates recently. For those who are not, this article talks about the development version of ImageGlass (called ImageGlass Moon), so if you are using stable version v7.0.7.26, you cannot experiment it.

❤

By the way, I have got my Github Sponsor profile:
https://github.com/sponsors/d2phap

You can become a sponsor with only $1/month. It will be a great encouragement to me that I can spend more time in developing ImageGlass (and other open source projects).

Page navigation tool

The idea was to provide user to navigate the pages of the viewing image file through buttons and shortcuts. The buttons are handy if the user is using mouse or touch screen while the shortcuts are helpful for keyboard users.

In the latest version of ImageGlass Moon, you can see a new tool called Page navigation tool in Tools menu. The UI is pretty simple with 4 buttons (from left to right):

• View the first page (Ctrl+Home)
• View the previous page (Ctrl+Left arrow)
• View the next page (Ctrl+Right arrow)
• View the last page (Ctrl+End)

I guess it’s quite easy to understand what the buttons do when you see their names. It’s similar to image file navigation, I try to provide the functions that help people quickly view image pages. You can combine Ctrl key with the current navigation keys: Left arrow, Right arrow, Home, End as its shortcuts.

This tool window behavior is same as Color picker, it means you can toggle, move it, it will follow the main window position. ImageGlass also remember your last choice: if you don’t close this tool window before exiting the app, ImageGlass will open it again in the next time.

Pages extraction

I did not create a new function but extended the Extract image frames menu of GIF format to support other multi-page formats. Moreover, this feature was upgraded and used Magick.NET library to extract all the pages gracefully.

You can access it via Main menu > Image > Extract image pages or context menu.

View single GIF frame

GIF is also a multi-page image format, with this implementation, you can view a frame separately.

Open a GIF file, and use navigation functions to manually move to next / previous frame. To resume the animation, you can click on the Start / Stop animating image context menu.

As this feature is still in ImageGlass Moon, I would like to hear your feedback. If you want to see the development progress, you can follow it at https://github.com/d2phap/ImageGlass/issues/238.

Thanks for reading!

How it works

The Settings dialog has been enhanced with new capabilities under Image loading order group:

In addition to the original loading order options, you can now sort in ascending or descending order, or allow the Windows File Explorer order to take precedence. To enable it, you can select the “User Windows File Explorer sort order if possible” checkbox in Settings > Image tab.

Being able to sort in descending order allows you to view images from oldest to newest, or smallest to largest, which you could not do in ImageGlass 6.

The Windows File Explorer order takes effect when you double-click an image to view in ImageGlass, or when you drag-and-drop an image into ImageGlass.

💡 Tip
If the order of the folder changed, you can update the image list by pressing Ctrl+Shift+R, or open Main menu > File > Reload image list.

Limitations

In ImageGlass 7, support for Explorer order is limited, as it is a translation of Explorer sorting to the existing ImageGlass sorting. This primarily means that sorting in Windows Explorer by metadata columns will have no effect in ImageGlass. Most available columns in Explorer are metadata columns, except the default Name, Type, Size and Date modified/created/accessed columns.

Moreover, the folder of the viewing images should remain to be opened. You can minimize it as long as you do not close or change other directory when ImageGlass first loads the image list.

This article is contributed by Kevin Routley — ImageGlass’ collaborator.

In the next story, I will tell you all the unbelievable ways to work with files in ImageGlass!

In this post, I will teach you how to integrate ImageGlass 7 to your website with few simple lines of code.

What is ImageGlass Web-to-App linking?

A special protocol associates to ImageGlass app, allows user to launch ImageGlass with argument in order to view the local image files.

The protocol syntax

imageglass:[path]

• imageglass: is the protocol, this helps to launch ImageGlass app.
• [path] is an optional argument to pass to ImageGlass app when it launches.

How to register the protocol?

Web-to-App linking is also registered when you set ImageGlass as default photo viewer app. If you haven’t done it, you can open Settings dialog, go to File Associations tab, and click on Set as Default photo viewer button.

You also can do it by command line: igtasks.exe reg-uri-scheme

To test the protocol, you can open web browser and type imageglass: to the address bar, it should open ImageGlass app. You can include a folder or image file path as well.

💡 Tip
ImageGlass also supports relative path!

Sample codes

The sample code snippets below are to create 3 hyperlinks:

Open ImageGlass with blank window

<a href="imageglass:">
  Open ImageGlass with blank window
</a>

Open an image file by ImageGlass

<a href="imageglass:%UserProfile%\Downloads\sample.svg">
  Open an image file by ImageGlass
</a>

Open image files in Downloads folder by ImageGlass

<a href="imageglass:%UserProfile%\Downloads">
  Open image files in Downloads folder by ImageGlass
</a>

Most of users do not need this Web-to-App linking feature, but if you are IT administrator or web developer who want to develop an web-based application for your company network, I believe this is really useful to you.

If you have not updated to ImageGlass 7.0, you can always download it at https://imageglass.org, and let me know your feedback by commenting below! 👇🏿

Besides Magick.NET, ImageGlass uses variety of third-party libraries to load particular image formats, such as IconLib for icon file, WIC for RAW formats… This helps the app to be able support more file extensions, but also makes the core library messy and fragmented.

After a month, I have completed the first stage of renovation, and introduced the new core library called ImageGlass.Heart which is already integrated to the latest version of ImageGlass Moon (v6.1.5.12).

So, what are the differences?

• ImageGlass.Heart supports C# asynchronous function that does not freeze the user interface while running.
• ImageGlass.Heart supports changing the number of maximum files can be cached in memory. ImageGlass.Core only supports 3 files.
• In ImageGlass.Heart, ImageBooster is improved with better file position caching and resource releasing.
• In ImageGlass.Heart, the loading functions are unified and easy to develop.

But…

• ImageGlass.Heart consumes a little bit more memory than ImageGlass.Core. But, it’s only about 3%. 😶

And not over yet, with the above pros of ImageGlass.Heart, it’s quite promising to implement multi-page viewing feature for TIFF, ICO,.. format. In the stage 2, I may introduce “hard-disk caching” which I am currently still researching. 😚

If you want to try out ImageGlass.Heart, you can download ImageGlass Moon: https://imageglass.org/moon, which has the latest of the new ImageGlass features.

⚠ Be forewarned: ImageGlass Moon is designed for early adopters, and can contain bugs.

By the way, I’m exploring blockchain world as well. I will post articles about it in the future! 😆

Set up mouse wheel actions

By default, scrolling mouse wheel does zooming in/out the viewing image in ImageGlass. Other editing applications (e.g. Photoshop, Illustrator,…) have awesome combinations of mouse wheel and keyboard that helps people to scroll the image horizontally/vertically.

Since version 5.0, ImageGlass has supported this feature and made it easily configurable in Settings dialog. There totally are 4 combinations, and 5 options for each of them.

Color picker tool

This is an useful tool for designer as well as UI developer. From a mockup image file, you can quickly get the color code of image pixels in variety of formats. To enable it, you can open Main menu > Tools > Color picker, or press Ctrl+Shift+K.

A small window will appear to display picked color in 4 formats: RGB, HEX, CMYK and HSL. If you want to pick alpha channel of the color, you can tick the respective checkboxes in Settings dialog > Color picker. ImageGlass also supports pick color from animating GIF file as well.

💡 Tip!
You can pause GIF animation by Ctrl+Space for more accurate.

Keep window always on top

This small feature is helpful when you want to see the real-time preview of the editing image. You don’t need to split the desktop into 2 parts left-right, or keep on switching between application windows.

To enable it, go to Main menu > Layout > Keep window always on top.

💡 Tip!
You can also hide the toolbar by unchecking Main menu > Layout > Toolbar, or pressing Ctrl+F1.

Summary

Besides being a simple image viewer for common users, ImageGlass has been receiving more attentions from designers/professional people. Those above tips are just some of outstanding features that I think it’s really helpful in designing. I will share more tips in the next posts and hope you enjoy it!

Have a nice day!