I’ve purchased my Odroid-N2+ and installed the Ubuntu MATE operating system on an SD card. It works great!
One part of the SBC (Single Board Computer) is the GPIO (General Purpose Input & Output) pins, that can be used for sending and receiving signals to the devices the user develop.
An easy project for begginers can be found in Odroid Wiki wehn you select from the tree on the left side of your browser’s screen:
Start by installing the ‘odroid-wiringpi’ as described at the beggining of the page.
Once you got to the example relevant to your device, you’ll see an image that will help you to locate the relevant pins on your device.
Note: the physical pin number differs from the WiringPi number.
The program you will find for turning the LED on and on is in C. With some changes I’ve made it looks as follows:
#include <stdio.h>
#include <stdlib.h>
#include <wiringPi.h>
#include <signal.h>
#include <unistd.h>
void sig_handler(int signo)
{
if (signo==SIGINT)
{
printf("\n\nExit\n");
digitalWrite(0,LOW);
exit(0);
}
}
int main(void)
{
/* Connect to signal-handler, so the LED will not stay on
* when the user presses <Ctrl>+C */
if(signal(SIGINT, sig_handler)==SIG_ERR)
printf("Cannot catch SIGINT\n");
wiringPiSetup();
pinMode(0, OUTPUT);
for (;;)
{
digitalWrite(0, HIGH);
delay(1000);
digitalWrite(0, LOW);
delay(1000);
}
return 0;
}
You can use the same pin handling functions for other devices such as Raspberry Pi and Arduino.
Now, the hint for translating your program into Bash (GNU Bourne Again SHell) is the command found on the Odroid Wiki page:
gpio readall
The output of that bash commands looks as follows:
In the output you can see the mapping of each physical pin to the corresponding WiringPi(wPi) number to be used in a program, and its mode (for example Input or output). The table can help you decide what WiringPi pin number to choose if you translate a program written for another device into yours. For example, Raspberry PI uses BCM numbering, that does not appear in the table.
While trying to find how to access the pins from a Bash script, I found many examples with files under the ‘/sys’ folder. We don’t need them here. If the command ‘gpio’ takes parameters, then check if you can use others to set the pin mode adn to write to it using the command:
gpio -h
From the output, you can learn that you can set the pin mode, read from the pin or write to the pin using the ‘gpio’ command.
Following is the full script to blink the LED, and turn it off when the user presses
<ctrl>+C:
#!/bin/bash
function brexit () {
gpio write 0 0
exit 0
}
echo "Hello, world"
trap brexit SIGINT
gpio mode 0 out
while
true
do
gpio write 0 1
sleep 1
gpio write 0 0
sleep 1
done
The ‘brexit’ function turns the LED off, and the ‘trap’ command associates it with the signal SIGINT (user break).
Command ‘gpio write <pin-number><value>‘ sets the pin value to
I’ve gotten myself Bluetooth Headphones and a USB Bluetooth dongles, and I want to hear sounds through my new headphones.
Since the headphones are a Bluetooth device, they should be discovered and paired. In the famous manual, FreeBSD Handbook , there are two sections in which to find instructions on Bluetooth and sound:
33.5 Bluetooth – in chapter 33 – Advanced Networking. There is also a useful utility named bluetooth-config you can use to create or modify the files ‘/etc/bluetooth/hcsecd.conf.; and ‘/etc/bluetooth/hosts‘
8.2.3. Setting up Bluetooth Sound Devices – in chapter 8 – Multimedia
Having configured Bluetooth and installed virtual_oss. All you have to do each time you want to listen through your Bluetooth headphones is to run the following commands replacing BT_ADDR by your device name:
Now, if you use VLC to listen to audio, all you have to do is select the ‘dsp’ output device. But, if you want to hear the sounds plyed by Firefox, you should have to add a module to PulseAudio. I haven’t found any Bluetooth modules I can install on my FreeBSD, but have found that module-sndio can do the job for me,, to add it, run the command:
pkg install pulseaudio-module-sndio
And add the following line to ‘/usr/local/etc/pulse/default.pa‘
load-module module-sndio device=snd/0
To start the service sndio at boot time, add the following line to ‘/etc/rc.conf‘:
sndiod_enable="YES"
To hear sounds from the Firefox browser, make sure PulseAudio stream it to ‘/snd/0‘ My display manager is XFCE4, and I use the plugin ‘xfce4-pulseaudio-plugin’ to view my output devices. In the following image, you can see that firefox sounds are streamed to that device:
Now, if everythiing is set correctly, but you cannot hear the sound, type the follwing shell command as a regular user:
A 4D graph can be used for plotting a graph of a complex function, with complex numbers as its input and output. A complex number can be represented as a pair of two real numbers:
A real part and an imaginary part.
A magnitude and an argument.
An image has a width and a height, but you can add an illusion of depth using a linear transform and changes in hue. A common way to add the fourth dimension is to use colors to represent its value. If you use a color for the fourth dimension, you want to add a legend to tell the viewer how to estimate the value of the fourth coordinate.
A good example of one such graph is the graph of the Lambert function found in the Wikipedia.
The Lambert W function is defined as follows:
where is the branch number.
In this post, I will discuss the use of Qt5 modules in creating my version of the graph:
The graph is not perfect and complete, but in this post I will explain how to create the components of the graph.
Combining OpenGL and 2D Painting
In Qt5, the OpenGL widget is a painting device like any other widget. So, you can use a painter of class QPainter to paint 2D shapes on it. The painter is useful if you want to add text to an image. Remember to unbind every GL object (vertex array objects, buffers, textures) before painting with the painter.
Before painting with the GL functions, call the painter’s method beginNativePainting. After finishing the use of GL functions, call endNativePainting
If you want the text rotation, you can use SVG. A simple way to add SVG text is using the QSvgRenderer class, that can create an SVG image from a file or a string.
Single Points
You can draw single points in OpenGL. To do so, you must enable GL_PROGRAM_POINT_SIZE using glEnable in your calling program, and define glPointSize in the vertex shader.
Matrices
The main types of matrices used in my example are:
Frustum – A perspective matrix defined using the minimum and maximum values of coordinates.
Viewport – a matrix that transforms the coordinates used by GL into the coordinates of the input rectangle. That transform will be used for placing the axis ticks snd texts.
The Program
The main window is a Qt Widget, so
The QMake File: qmake.pro:
The following definition will be used for creating the make file.
The fourth coordinate of our graph represents arg(W(z)), an angle. In the graph we’ll use HSV (Hue, Saturation, Value) because the hue is given by the value of an angle. A shader-language function to covert from HSV to RGB is defined in file “shaders.h“:
A call to glEnable( GL_PROGRAM_POINT_SIZE ); enables drawing single points.
The function populatePointBuffer uses the method ‘write‘ of class QOpenGLBuffer to write points to the vertex buffer. I use the buffer this way so I can use functions of complex variables.
void GraphWidget::populatePointBuffer(void){
int vboOffset=0;
graph_point vec[NUM_MAGNS];
for (float magn=0;magn<1.4;magn+=1.4/NUM_MAGNS){
int pos=0;
for (float arg=-1;arg<1;arg+=2./NUM_ARGS){
// The arg of W(Z) divided by pi.
complex<float> iarg;
iarg=complex<float>(0,M_PI*arg);
complex<float> w=magn*exp(iarg);
complex<float> z=w*exp(w);
vec[pos].hue=arg;
vec[pos].coords[0]=imag(z);
vec[pos].coords[1]=magn;
vec[pos].coords[2]=real(z);
pos+=1;
}
m_point_vbo.write(vboOffset,vec,sizeof(vec));
vboOffset+=sizeof(vec);
}
}
Resizing
The function resizeGL is called as a response to a widget resize event. In this function the values that change due to a resize event are set. The properties set here are:
The font size for the painter
The transform matrix
The viewport matrix
void GraphWidget::resizeGL(int w, int h){
m_width=w;
m_height=h;
fontSize=12.* min((float)m_width/MIN_WIDTH,(float)m_height/MIN_HEIGHT);
m_font.setPixelSize(fontSize);
float z_far=0.05;
float z_near=0.01;
float a=2./(m_height-2*fontSize);
float b=1.8-a*m_height;
float y_floor=b-2.*a*fontSize;
// leftInPixels,RightInPixels - left and right boundaries
// of the graph.
float leftInPixels=12*fontSize+7;
float rightInPixels=m_width - 12 - 15*fontSize;
a=2/(rightInPixels-leftInPixels);
b=-1-a*leftInPixels;
float x_left=b;
float x_right=a*m_width+b;
transform.setToIdentity();
transform.frustum(x_left,x_right,y_floor,1.8,z_near,z_far);
transform.translate(0,0,-(z_far+z_near)/2);
transform.scale(1,1,(z_far-z_near)/2);
viewport.setToIdentity();
viewport.viewport(rect());
}
Painting
The function paintGL is called as a response to paint events. Following is the code of paintGL:
The function addAxes uses the painter and the viewport matrix to draw axes and add the ticks. You hove noticed that the matrices are of size 4×4 and the vectors are of length 4; when a matrix is multiplied by 4, you should divide coordinates x,y by coordinate w to find the vector’s location on the 2D window. Special treatment is added to the slanted z-axis, where SVG is used:
The function add_z_text renders the SVG text using an object of call QSvgRendered. It accepts a byte array made from a string. It can also take a file name. The macro SVG_TEXT_STR is defined in file “svg.h” as follows:/code
Adding some items to an OpenGL figure using a vertex buffer is difficult. Text is one example, if you don’t want it just across the screen. You can use the OpenGL widget as a simple 2D canvas, but you might want to rotate it around the y-axis for example and add varying depth to it as in the following figure:
To add texts and other images to surfaces, OpenGL offers the textures. In this post, I will show how to create and use one and apply transforms.
Images and Textures
A texture is another object to bind, which means telling OpenGL to use that texture. When drawing the image, the Fragment Shader will use a sampler to take the pixel color at the coordinates defined by the Vertex Shader.
Qt5 offers an OpenGL texture class named QOpenGLTexture. The texture can be generated from an image passed to the constructor. For example:
m_texture=new QOpenGLTexture(img);
The image is an object of class QImage, if you choose to draw it, instantiate the class QPainter passing the image to the constructor. For example:
QPainter painter(&img);
Note: choose the right size for your image and the text fonts because you create a raster image, and by scaling it you may get an image of poor quality.
Texture Coordinates
The values of each coordinate of the texture is a floating point number between 0 and 1. When passed to the Vertex Shader, each texture vector of coordinates (usually x and y coordinates) should match a vertex coordinate.
For example: (0,0) is the top-left coordinate and (1,1) is the bottom-right.
Transforms
Transforms are done by multiplying a 4X4 matrix by each vertex coordinate vector with a fourth coordinate added. It’s value is usually 1. The reason to add a coordinate is to apply more transforms than just scaling and rotating around the origins.
Interactivity
Sometimes we add an input widget, for example: push button and spin boxes. The input widget should react to operations done by the user, so it emits a signal. Another widget has to react to the signal, so it has a special function known as a slot, and the developer’s job is to connect the signal and the slot. The signal should have at least as many arguments as the slot. And a type in the slot should be implicitly converted to the corresponding one in the signal (for example: short to integer or float.
The connection is done using the static method ‘connect‘ of class QObject.
Here, for example is a connection of the SpinBox’s event ‘valueChanged‘ with the extended OpenGL Widget’s ‘changeVerticalAngle‘:
A class that has a slot method should have the macro Q_OBJECT at the beginning of the private section. After adding that macro, run the command ‘qmake‘.
The Code
Following is the code of a program that draw text with a varying depth. It uses a spin box to change the vertical angle of the perspective transform.
The main function multiplys two transform matrix by the input vector. The global variable names are names of locations defined by the functions setAttributeByffer‘ and ‘setUniformLocation‘.
The name ‘m_texture‘ is not set by the main program; it is just a name associated with the location of the bound texture. You canlearn more about the shading language here; Choose a book according to the version of shading language. You an find the version by printing the value of the string GL_SHADING_LANGUAGE_VERSION using the C++ command:
But it seems that the program links with an earlier version by default, so you better specify your version (if your graphical card supports it) using the directive “#version” at the very beginning of the shader’s code. For example: version 140 for SL version 1.40 Good example of shaders can be found in the Wikibooks OpenGL tutorial.
The extended OpenGL Widget
Following is the class extending QOpenGLWidget. It includes the vertical angle, aspect ratio, he slot function and other members:
The function initializeGL defines the vertex array object, buffers, texture, shaders and shader program. In addition it creates and image, draws the text on it using the class QPainter. A texture is then instantiated using the image and created. Following is the code of the functiom:
The painting is done by the method ‘paintGL‘. In the example, the function draws the textured surface by calling ‘glDrawElemts‘. The function ‘glDrawElements‘ uses an index buffer with the indices to the vertices, so you won’t have to define a vertex twice. Associating the texture with a variable in the shaders – using a function such as ‘setUniformLocation‘ or ‘setAttributeBuffer‘ – is not require, so a function to do it does not exists.
The method ‘resizeGL‘ is an event handler called when the OpenGL widget is resized. In the example it changes the aspect ratio of the widget. Following is the code:
void ExtendedOpenGLWidget::resizeGL(int w, int h){
aspectRatio=(float)w/h;
}
The Slot
The function ‘changedVerticalAngle‘ is a user-defined slot to be connected with the value-change event. It changes the vertical angle of the perspective transform, and calls update.The function ‘update‘ is a slot that accepts no arguments, and its role is to add a repaint event to the event loop. Using ‘repaint‘ might be risky if called by a function called by ‘paintGL‘ because the result of using it may cause endless recursion. So, better avoid using ‘repaint‘.
Now, to check if your image has been added, change the vertical angle to 0. A perspective matrix generated with a vertical angle zero is an identity matrix.
Drawing and painting a 3D image with GL – the Graphic Library – is not as trivial as doing the same on a 2D canvas: no 3D versions of the 2D canvas drawing methods are defined in GL classes. Instead, programs written with GL send data to the GPU (Graphic Processing Unit), and directions for organizing the data in data structures and for the rendition of data to the screen. The data is stored in buffers, and processed by shader programs.
Once you know how to use the OpenGL API, drawing the following image is simple:
The way Qt simplifies the use of GL are as follows:
it offers classes instead of integers to wrap GL resources: buffers, textures, vertex array and more.
the classes include overloaded functions.
the developer can create shaders without specifying the GL version.
Qt manages the main loop.
The following sections will describe the process of painting a 3D surface.
Initializing
To start working with GL, create an object of class QOpenGLWidget. Better create a subclass of QOpenGLWidget, if you work with Qt 5.4 or a later version. Don’t perform any GL operations before the method initializeGL is called. If you extend OpenGLWidget, any GL operation should be performed by one of the following methods: initializeGL, paintGL and resizeGL.
In initializeGL place operation to be performed once only at the initialization time. Some examples of initializeGL can be found in
This function creates the vertex array object(VAO). If the VAO cannot be created, it cannot be bound to the context. Your program can draw with or without it. In my example, I bind the VAO.
What actually does the drawing is the shader program. For it to draw you should link it at run time with the shaders. If you use Qt 5, the class QOpenGLShaderProgram exists with a method addShaderFromSourceCode, so you can create program in separate text files without the need to recompile your GL program when the shader code changes.
The example in Qt Assistant->Qt GUI->C++ Classes->QOpenGLShaderProgram does not complete the example in Qt Assistnat->Qt Widgets->C++ Classes->QOpenGLWidget; Don’t use it if you bind a buffer, because the coordinates and colors defined by setAttributeArray and setUniformValue will not set the correct locations of the colors of coordinates for the drawing method. In addition, only use coordinates specified in pixel if the GL Widget is of fixed size.
Following is an initializeGL method for coordintes whose values are between -1 and 1, and the color RGBA values are floats between 0 and 1:
void ExtendedOpenGLWidget::initializeGL(){
glEnable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
m_vao.create();
if (m_vao.isCreated()){
cout<<"Created"<<endl;
m_vao.bind();
}
m_vbo.create(); m_vbo.bind();
// Allocating buffer memory and populating it
m_vbo.allocate(vertices, sizeof(vertices)); m_fragmentShader=new QOpenGLShader(QOpenGLShader::Fragment);m_fragmentShader->compileSourceFile("../fragmentshader.txt"); m_vertexShader=new QOpenGLShader(QOpenGLShader::Vertex);m_vertexShader->compileSourceFile("../vertexshader.txt"); m_program=new QOpenGLShaderProgram(); m_program->addShader(m_fragmentShader); m_program->addShader(m_vertexShader); m_program->link(); m_program->bind();
// Arguments of setAttributeBuffer in this example:
// 1: A string, the corresponding attribute in the shaders.
// 2: the type of each array element.
// 3: the start point relative to the beginning of the current buffer.
// 4: the number of elements in each vector.
// 5: stride: the difference in bytes between two successive vectors
m_program->setAttributeBuffer("vertex", GL_FLOAT,0,3,sizeof(vertex)); m_program->setAttributeBuffer("color", GL_FLOAT,sizeof(vertices[0].coords),4,sizeof(vertex)); m_program->enableAttributeArray("vertex"); m_program->enableAttributeArray("color"); m_vao.release();
}
Shaders
The program uses two shaders:
a vertex shader – outputs the coordinates of which point
a fragment shader – outputs the color of which point.
The method paintGL draws the image. In this example, it uses the function glDrawArrays with the mode GL_TRIANGLES. In 3D the only 3D polygon type a graphical program always knows how to fill because the vertices are on the same plan.
Following is the paintGL method:
void ExtendedOpenGLWidget::paintGL(){
cout<<"paint"<<endl;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
m_vao.bind();
// Arguments of setAttributeBuffer in this example:
// 1. mode - how the shaders will draw the array
// 2. start - first enabled array
// 3. count - the number of indices.
glDrawArrays(GL_TRIANGLES,0,3);
m_vao.release();
}
The main function
An Open GL Widget may be a top-level window or a widget inside another container. In the following main function, the widget is inside a main window:
Qt allows you to develop a multi-platform application, that you can develop a GUI application on one platform and deploy to many others (if you avoid system-specific extra modules). Qt contains modules for creating widgets from elementary ones to OpenGL 3D, which I will discuss later. In addition it contains module with other functionalities an application may need such as SQL, XML, web channels, web views and web sockets.
Qt can be downloaded from https://www.qt.io/ or installed using the UNIX/Linux package installers.
In addition to the QT libraries and header files, there are 3 useful resources:
Qt Designer – A GUI tool for the generation of Python and C++ headers from a form graphically designed.
Qt Assistant – A reference to the Qt classes, Example, the QMake tutorial, etc.
qmake – an easy-to-use utility that creates the Makefile.
In the following sections, I will show how to create a project using the three tools:
Creating the Main Window
Qt Designer is an editor with which GUI designers and developers can communicate. With the designer you can create, save and edit Designer UI Files (*.ui) and create class files from them for Python and C++ programs. The QMake program discussed later can use the “.ui” file to generate a header file from it. The file can be edited by creating top level windows such as widows and dialog, and dragging and dropping widgets into them. You can also access and modify their properties; if you are a developer and have a Desiger UI file, you can find names of object in your program.
Starting:
As you start the QT Designer, the following dialog pops up:
If you don’t see the dialog, choose File->New from the editor’s menu bar, to make the dialog pop up.
Choose your top-level widget from the “templates/forms” menu, and click Create; a window will be created:
Now, from the right-hand Property Editor, you can change some properties, for example: let us change the window title:
Adding widgets and promoting them
Now, you can choose widgets from the left-hand side of the editors and drag-and-drop them into the window:
For example, let us add a push button, and change its QAbstractButton property “text” to “Push me!”.
One of the other properties we can change is the QObject property “objectName”, which will be the name of the appropriate field of class QPushButton in the created class.
By right-clicking inside the widget and choosing “Promote to..” from the context-menu, you can choose to use a class that inherits from the gadget’s class. Don’t forget to define the new class and its constructor and methods.
Previewing
You can view your design by clicking Form->Preview from the editor’s menu bar.
Saving the created class
If you don’t want the Make program to generate a header file, you can save it from the Qt Designer tool.
Choose Form->View C++ Vode/View Python Code from the editor’s menu bar. a dialog will open.
Click the “save” icon to save the created header file.
Adding Functionality
This section will describe a little Hello World program – in C++ – that uses a header file created wit QtDesigner. The purpose of the program is to print “Hello, world” to the standard output, when the “Push Me” button is clicked. To add the mouse event handling the class QPushButton has been promoted to Extended Button. This section will describe the program, and will help you train yourself using Qt Assistant.
The main function
To learn what a the main function of a Qt Application with widgets should look like:
Start the Qt Assistant if not started yet.
Click the Contents tab
Click Qt Widgets (highlighted in the following image:
You” see a heading reading “Getting Started Programming with Qt Widgets”. Scroll down and see the contents of a main source line.
In the Hello World program the code is as follows:
The main file includes the constructor of the class ExtendedButton. Its role is to call the parent’s constructor. Another function implemented is mouseReleaseEvent, which is an event handler. You can learn from Qt Assistant, that the method mouseReleaseEvent is an event handler by clicking Qt Widget->QWidget in the right-hand Contents tab, and then click the link reading “events” under detailed description in the pages contents.
The class ExtendedButton is defined in “extendedbutton.h”. Following is the definition:
The main object of the application is defined in “ui_example.h”, the file generated by “Qt Designer”, you better avoid changing it manually if you want to modify the “.ui” file from which it was generated. You’ll see a warning at the beginning. The role of the Class Ui_MainWindow is to contain main window (or central widget) and its underlying widgets as public members. The method setupUi binds them.
Creating the qmake file
“qmake” is an easy-to-use utility that generates a Makefile to be used by the make command to generate binaries, objects, libraries. etc. Qt Assistant includes a Qt Manual. Following is the content of the example’s qmake file named ‘qmake.pro’:
If you want the Make program to create the main header file, you can include the “.ui” file generated by Qt Designer in a variable named “FORMS”. The “make” program in turn will generate a header file from it with the prefix “ui_” added to the “.ui” file name. For example, from a file named “example.ui” the “make” program will generate a header file named “ui_example.h”. In this case, don’t add “ui_example.h” to the variable “HEADERS”.
If you want to know what to add to QT, go to the <Class Category>->C++ Classes and click the Detailed Description link.If you want to run qmake without command line arguments, call the qmake file ‘qmake.pro’.
The other day, I participated in a discussion on GimpNet IRC (irc://irc.gimp.org). I saw there a message in which some words were colored. Since my client is Pidgin, I cannot add colors simply by clicking on the Font button, and selecting a color: all the menu options are disabled.
Searching the web for IRC colors, I found that mIRC supports adding colors to the text. If you are not a mIRC user, at least you can find the list of color codes here. The page does not describe how to add colors and other text attributes in other clients, but to learn at least about the sequences to be sent to the server, writing a script is recommended. To find the way to write scripts using the IRC protocol, I recommend using the PERL language. A great place to find PERL modules is the CPAN (Comprehensive PERL Archive Network) site. Search for IRC. A good class to create mIRC color strings is String::IRC – add color codes for mIRC compatible client.
Following is a script I’ve written to print the sequences:
use String::IRC;
use strict;
sub print_char {
my $ch=shift;
my $ord=ord($ch);
if ($ord<32 or $ord>126){
printf "\033[37;1m<%x>\033[0m", $ord;
} else {
print $ch;
}
}
sub print_string {
my $str=shift;
my $len=length($str);
for (my $i=0; $i<$len;$i++){
print_char(substr($str,$i,1));
}
print "\n";
}
my $red=String::IRC->new("Red")->red;
print_string "Red: $red";
my $red_underlined=String::IRC->new("Red Underlined")->red->underline;
print_string "Red Underlined $red_underlined";
my $red_bold=String::IRC->new("Red Bold")->red->bold;
print_string "Red Bold: $red_bold";
my $red_inverse=String::IRC->new("Red Inverse")->red->inverse;
print_string "Red Inverse: $red_inverse";
The output of the script is in the following image:
The hex codes of control characters appear in white. They can be added as Unicode characters.
So,
Unicode character 0x02 begins a bold string or sub-string.
Unicode character 0x1f begins an underlined string or sub-string.
Unicode character 0x03 begins a colored string or sub-string when followed by:
A foreground code
Foreground and background codes separated by a comma.
Unicode character 0x0f resumes to the default text format.
Now, to add a Control Character in Pidgin
First, check that the input method is “System”. To do it, left-click inside the input area and choose the input method:
Use your system’s method to insert a Unicode characterFor example, In Linux/UNIX, type <Ctrl>+<shift>+U followed by the hexadecimal code of the character, and the space or Enter.
The other day, I was invited to a zoom meeting. Zoom is a video conference application also available for computers. It’s address is https://zoom.us.
When the time of our meeting came, I couldn’t hear anything when connecting from my Firefox browser, and saw the following message:
.
After a short IRC conversation on #freebsd@freenode.org, I installed the User-Agent Switcher and Manager add-on on my Firefox.
This add-on adds an icon to the toolbar, Following is the icon as seen in the dark theme:
Now, when you click the icon, you will see the following popup:
Great! Now you can select a browser and operating system using the drop down lists, and then select the browser’s version using one of the radio button. Then, click the “Apply” button to save your changes and enable the add-on. Click the “Test” button to see what browser details will be passed to the remote server.
Having upgraded my FreeBSD system and VirtualBox, I found that VirtualBox does not work when invoked from the window manager’s menu. So, I tried running it from the command line, and got the following message:
/usr/local/lib/virtualbox/VirtualBox.so: Undefined symbol “_ZNK6QColor6darkerEi@Qt_5”
I tried to search the web for the cause, and found a link to a compatibility report including added symbols. My symbol was nott found there, but at least I got a clue about what I had to do: upgrade Qt5.
From some reasons I’m not notified that it’s time to upgrade my Qt5.
I found a great option for command pkg:I
pkg version| grep qt5
The output reveals the current version of a package, and if there are later versions; following is a typical output line:
qt5-printsupport-5.12.2 <
The less-then symbols indicates that there is a more recent version.
I started upgrading Qt5 packages, first qt5-core, then qt5-gui and saw a little progress: new undefined symbols. Finally, VirtualBox started working.
Another application affected by the failure to upgrade Qt5 is VLC , the famous media player from https://www.videolan.org
VLC does not show any error message, and you can run it from the command line with no problems. Specifying the path of the media device or file. For example by typing the command:
vlc cdda:///dev/cd0
if you want to listen to a compact disc.
Now, upgrading Qt5 has made VLC displaying its GUI window.
Matplotlib is a great python library for plotting and graphics. Graphics include formatted text, text paths and tabular data. Mathematical expressions are a good reason to use Matplotlib for rendering text. Matplotlib also supports some widgets one can use for input. If you use Matplotlib widgets, you vetter know how to size and position them unless – for example – you write a program for yourself.
Following is an example of bad code:
from matplotlib import pyplot as plt
from matplotlib.widgets import TextBox
from matplotlib.widgets import Button
fig,ax=plt.subplots()
teextbox=TextBox(ax,"Label:")
button=Button(ax,'Submit')
plt.show()
The code above create to widgets that fill up the same plotting area inside defined Axes object. In the following image, you can see that both the text entered by the user and the button text overlap. In addition. the text entered by the user exceeds the limit of the plotting area.
Get More Control over Your Widgets
For better results, there are 3 things to do:
Use separate plotting area for your widgets.
Set the plotting areas’ positions and sizes.
Using Event Handlers to control the input length in a TextBox and perform operations.
Separate Plotting Areas
The command plt.subplots() creates a figure, and a single plotting area, a uni-dimensional array of plotting areas or a bi-dimensional array of plotting areas. According to the number of rows and columns. The default is one row and one column. For example:
fig,ax=plt.subplots(nrows=2)
Returns a column of two plotting areas, To set the number of columns use the keyword argument ncols.
Let us see what happens if we set the number of colums (not adding widgets. yrt) by the following code:
from matplotlib import pyplot as plt
from matplotlib.widgets import TextBox
from matplotlib.widgets import Button
fig,ax=plt.subplots(nrows=2)
plt.show()
The code generates two Axes rectangles as follows:
Resizing and Positioning a Plotting Area
The Axes rectangle can be resized and positioned using the function matplotlib.axes.Axes.set_position. One of its arguments can be an array whose members are left,bottom,width and height. The position and size is relative to the figure. :
left=0 means that the Axes begin at the left side of the figure
left=1 means that the Axes begin at the right side of the figure (which makes them invisible).
bottom=0 means that the Axes begin at the bottom of the figure
bottom=1 means that the Axes begin at the top of the figure
The following code resizes the Axes rectangles, and adds the widgets:
from matplotlib import pyplot as plt
from matplotlib.widgets import TextBox
from matplotlib.widgets import Button
fig,ax=plt.subplots(nrows=2)
ax[0].set_position([0.2,0.85,0.7,0.08])
ax[1].set_position([0.495,0.6,0.1,0.1])
teextbox=TextBox(ax[0],"Label:",label_pad=0.01,color='cyan',hovercolor='red')
button=Button(ax[1],'Submit')
plt.show()
ax[0] is the rectangle containing the TextBox
ax[1] is the rectangle containing the box. It’s width is 0.1(10% of that of the figure), and its left edge is position at 0.495, which is 0.5+0.1/2. This makes its horizontal alignment centered.
In the following image you’ll see that the background color of the text box is ‘cyan’, and hovercolor defines the background color when the mouse pointer is over the text box.
Setting the Input Text’s Maximal Length and Event Handling
Event handling functions can be attached to widgets. Event handling functions can react to button clicks, text changes, submitions by pressing the Enter key, etc.
If you want to restrict the length of the input text in a TextBox, attach an event handling function as follows:
tb.on_text_change(func)
Where func is a function that gets one argument, the text. In this function, you can restrict the number of character. You better set the cursor position as well, because it increases whenever the user types a character, even if the text is changed by the event handler. Following is an example of how to check that the input matches a pattern all the way:
def tc_func(self,inp):
if (len(inp)>self.maxlen):
self.tb.cursor_index=self.curpos
self.tb.set_val(self.val)
return
if (self.decpoint and inp.find('.')<0 and len(inp)>self.maxlen-1):
self.tb.cursor_index=self.curpos
self.tb.set_val(self.val)
return
if (not self.pattern.match(inp)):
self.tb.cursor_index=self.curpos
self.tb.set_val(self.val)
return
self.val=inp
self.curpos=self.tb.cursor_index
From the argument self you can learn that the above function is a member of a class. Wrapping widgets in objects is recommended.
The member ‘cursor_index‘ is the position of the cursor after the event handler finishes its work. set_val sets a new value (or resets it).
To handle button click events , use the function on_clicked, as follows:
button.on_clicked(click_handler)
The argument passed to the click_handler is an object of type matplotlib.backend_bases.MouseEvent. You can see in the following code how you can learn it:
from matplotlib import pyplot as plt
from matplotlib.widgets import TextBox
from matplotlib.widgets import Button
def click_handler(evt):
print(type(evt))
print("Button clicked with:"+ str(evt.button))
fig,ax=plt.subplots(nrows=2)
ax[0].set_position([0.2,0.85,0.7,0.08])
ax[1].set_position([0.495,0.6,0.1,0.1])
teextbox=TextBox(ax[0],"Label:",label_pad=0.01,color='cyan',hovercolor='red')
button=Button(ax[1],'Submit')
button.on_clicked(click_handler)
plt.show()
The event handler above prints the type of mits argument and the mouse button with which the button widget was clicked. Following is the output:
If you just choose to create a table without specifying loc, the table location in respect to the Axes, chances are you will not be satisfied.
The following code creates such a default table using the factory:
import matplotlib as mpl
from matplotlib import pyplot as plt
from matplotlib.widgets import TextBox
from matplotlib.widgets import Button
fig,ax=plt.subplots()
tab=mpl.table.table(ax,cellColours=[['red','green'],['yellow','blue']])
plt.show()
In the following image generated by the code, you will see that the table is created just under the Axes, and it overlaps the frame x-ticks.
You can create the table somewhere else by setting the loc parameter, you can set a cell’s width and height, set a column width automatically, and align text.
Setting The Table’s Location and Modify Cells
To set a table location in respect to the Axes, pass the parameter loc with one of the valid codes, for example:
A default text alignment in a table cell can be defined by passing the parameter cellLoc when creating a new table. When adding a cell, the argument name is loc. The valid values for loc are: ‘left’, ‘center’ and ‘right’
Accessing a table cell is easy as ABC: access the cells as if the table were a bi-dimensional array whose elements are objects of type matplotlib.table.Cell. For example:
tab[row,col]
You can modify text properties using the function set_text_props of the cell object. And you can change its position and size by modifying properties inherited from class matplotlib.patches.Rectangle.
The following code creates a table near the upper left corner of the Axes, sets the column widths to be automatic, changes the color of text cells, and enlarges one of the cells.
import matplotlib as mpl
from matplotlib import pyplot as plt
fig,ax=plt.subplots()
tab=mpl.table.table(ax,cellText=[['Red','Green'],['Yellow','Blue']],
cellColours=[['red','green'],['yellow','blue']],
loc='upper left',cellLoc='left' )
tab.auto_set_column_width(0)
tab.auto_set_column_width(1)
tab[1,1].set_height(0.5)
for i,j in ((0,0),(0,1),(1,1)):
tab[i,j].set_text_props(color='white')
plt.show()
The code above produces the following image:
Adding a Cell
You can add single cells to a table using the function add_cell of the table.
the function should be called with the row number and column number. The caller has to specify the keyword arguments ‘width’ and ‘height’.
The new cell should be connected to the table, and may influence the heights and widths of celles in the same row or column.
The following code adds a cell in a new column and row:
import matplotlib as mpl
from matplotlib import pyplot as plt
fig,ax=plt.subplots()
tab=mpl.table.table(ax,cellText=[['Red','Green'],['Yellow','Blue']],
cellColours=[['red','green'],['yellow','blue']],
loc='upper left',cellLoc='left')
print ("Table Created")
tab.auto_set_column_width(0)
tab.auto_set_column_width(1)
tab[1,1].set_height(0.5)
for i,j in ((0,0),(0,1),(1,1)):
tab[i,j].set_text_props(color='white')
tab[1,0].set_xy((0,0.8))
tab.AXESPAD=0
cell=tab.add_cell(2,2,height=0.1,width=0.3,text='New Cell',loc='center',facecolor='orange')
plt.show()
In the following image, you can see a new orange cell that has been added to an existing table:
is the branch number.
PHP & More 