DEV Community: Ritika Das

Fix Firefox's 'Show in Folder' not opening in File Manager

Ritika Das — Tue, 07 Jun 2022 14:21:05 +0000

Introduction

Hey fellow Devs, it's Ritika here.

I recently installed Gnome Shell as my Window Manager on my Linux environment, and some of my default settings got changed as a result. One of them is Firefox not opening the downloaded file location in File Manager, instead trying to open it in FreeCAD, a parametric 3D modeler software.

The problem

Unfortunately, this is not something you can configure in the General settings in Firefox.

Why it happens (MIME types)

There's more to opening a file than just knowing its extension and the default application you've set it to open with.

A MIME type (Multipurpose Internet Mail Extensions type) indicates the nature and format of a document, file, or assortment of bytes. (Source: MDN)

In Linux, these MIME types are commonly defined in a file mimeinfo.cache.
A MIME type has two parts: a type and a subtype, separated by a slash (/). It is accompanied by a value on the right side of the equals (=) sign.

type/subtype=value

Examples:
text/plain=featherpad.desktop;libreoffice-writer.desktop;
video/mp4=vlc.desktop;

As you can see, there can be multiple values after the equals (=) sign, which are separated by semicolons (;).

The values are written in an order of priority: since featherpad.desktop is before libreoffice-writer.desktop, FeatherPad receives more importance and hence if it is installed, files of MIME type "text/plain" will always be opened with FeatherPad.
If someone were to uninstall FeatherPad from their system, Libreoffice Writer will now be given preference to open files of the same MIME type.

Our issue

In our case, we are unable to open Folder location in File Manager, instead it opens in an app called FreeCAD.
Directories have the MIME type of inode/directory, so we'll look for this in our mimeinfo.cache file.

The solution

Open up your terminal, and execute the following commands:

cd /usr/share/applications
sudo nvim mimeinfo.cache

If you do not have nvim installed, you can also use gedit or vi to open the file with:

sudo gedit mimeinfo.cache

Sure enough, the first value for inode/directory is FreeCAD.desktop. We need to remove it, so that pcmanfm-qt.desktop can have the most priority for our folder opening actions.

Save and close the file using :wq if you're using nvim or vim.

Why sudo?

If we don't access the file with root permissions, the file stays read-only for us, hence even if we open the file and make changes, we won't be able to save our changes.
sudo enables us to make changes to mimeinfo.cache and save it.

Finally

After you save the file, the change should take effect even without logging out or restarting your PC. Still it's good to restart and see if our changes stick.

In case you've edited the mimeinfo.cache file and changes still don't take place, remove the MimeType of inode/directory after opening the Application's desktop file from the same directory, for example

sudo nvim FreeCAD.desktop

and saving the changes.

Did you find this useful? Comment below if you did, or if you faced any difficulty, let me know below. Wishing you a productive day ahead!

Using NeoVim as an effortless way to edit code – Installation and Setup Guide for Windows 10

Ritika Das — Wed, 16 Dec 2020 14:53:54 +0000

Hey fellow Devs, it's Ritika here.
I recently tried out NeoVim on my PC to see what it's like. Ever wanted to delete text between tags/braces, save files, switch to a certain line number in your code, undo, search for a word - all without having to touch your mouse? Try this fancy editor with me.

What is NeoVim?

Neovim is a GUI that can help us maintain and contribute more by dividing the work, which can be installed on any platform such as Linux, Windows or macOS. We can replacing the code editors which take up a lot of disk space by installing this effective refactored version of Vim.

Installing NeoVim on Windows 10 and adding it to system PATH variable

From NeoVim’s official repository on GitHub, download the zip file for Windows (64-bit) by clicking here or the zip file for Windows (32-bit) by clicking here, which is of size 23 MB approximately.

Then extract the zip file by clicking on it once and selecting “Extract All”.

After the extraction is completed, copy the location of your extracted folder and add it to system PATH variable.

Right-click on This PC -> Properties -> Advanced system settings on left side of Control Panel -> Environment Variables -> Double-click on Path in System Variables pane -> Add New Path by pressing New and pasting the extracted folder’s location and Click OK on all the three windows simultaneously.

Now go to the extracted nvim-win64 and go into the nested folders Neovim -> bin. You’ll come across an application named nvim-qt.exe which is a GUI NeoVim client not to be confused with the terminal NeoVim - run it.

Neovim (nvim-qt) will open up like the following –

[Note:- The application may be slightly different due to plugins I’ve already installed, but similar dark background will appear with tilde in each line.]

Accessing nvim from anywhere, without opening nvim-qt.exe

Remember how we just added the ~/AppData/Local/nvim folder to our system PATH? Click here to revisit the steps. This time we’ll add the bin folder nested in nvim-win64 extracted folder, whose path looks like ~/nvim-win64/Neovim/bin. This will make Neovim more user-friendly for us, as it displays more options like :help for a walkthrough, :checkhealth for optimization on startup.

Your path will look something like this. Copy it and repeat the steps of right-clicking This PC -> Properties -> Advanced System Settings -> Environment Variables -> System variables’ pane -> Double-click Path -> Paste the bin folder location in a new line -> Click some OKs!

There you go! You can now open Neovim by pressing Windows + R keys (shortcut for Run), typing nvim and clicking OK.

You can also open up Command Prompt, type nvim and press Enter for the same result.

It’ll open up like this in both cases :

Boom! You have installed Neovim successfully. To exit Neovim for now, type :q and press Enter. The colon (:) takes Neovim into command mode, and q is for quit. If you want to have fun, let’s dive into configuring Neovim to make things more usable to you.

Configuring NeoVim – the easiest way

The Neovim configuration file is named init.vim which can be edited for our purpose. It is usually found under the directory ~/AppData/Local/nvim. In case you’re not sure about the exact location, open Neovim from nvim-qt.exe, type :echo stdpath(‘config’) in Neovim and press Enter.

See? It echoes or displays the exact location of your nvim folder on the command line, if it exists.

If not already present, we need to create the directory nvim within ~/AppData/Local i.e. we’ll put our init.vim file in ~/AppData/Local/nvim.
Note :- Don’t get confused between nvim and nvim-data folders. Keep nvim-data folder untouched, and only create a new nvim folder if it doesn’t exist.
The easiest way to do so is to open up a new .txt file inside ~/AppData/Local/nvim, add the first and last lines at least i.e.

call plug#begin('C:/Users/Ritika/AppData/Local/nvim/plugged') 
call plug#end()

Now we’ll add vim-plug for managing the plugins we are going to use in Neovim. For this, enter the Plug lines within the previous two lines. You don’t need to add all the plugins listed below; instead choose some plugins from them like onedark, coc.nvim, vim-airline. If you want cool icons beside folders and files, you can use the command

Plug 'ryanoasis/vim-devicons'

although I haven’t used it in this installation.

call plug#begin('C:/Users/Ritika/AppData/Local/nvim/plugged')
" below are some vim plugins for demonstration purpose.
" add the plugin you want to use here.
Plug 'joshdick/onedark.vim'
Plug 'iCyMind/NeoSolarized'
Plug 'neoclide/coc.nvim'
Plug 'junegunn/vim-easy-align'
Plug 'https://github.com/junegunn/vim-github-dashboard.git'
Plug 'scrooloose/nerdtree', { 'on':  'NERDTreeToggle' }
Plug 'tpope/vim-fireplace', { 'for': 'clojure' }
Plug 'rdnetto/YCM-Generator', { 'branch': 'stable' }
Plug 'fatih/vim-go', { 'tag': '*' }
Plug 'nsf/gocode', { 'tag': 'v.20150303', 'rtp': 'vim' }
Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': './install --all' }
Plug 'vim-airline/vim-airline'
Plug 'vim-airline/vim-airline-themes'
call plug#end()

When you are happy with your list of plugins, save the init configuration file as All Files, and add the .vim extension after filename init. Delete the init.txt file previously saved.

Vim-plug

Vim-plug makes it easy to manage all your plugins on Neovim by downloading plugins into separate directories and loading them correctly. Open Windows PowerShell on your PC.

Then copy the following command, paste it into PowerShell prompt, and hit Enter to execute it.

md ~\AppData\Local\nvim\autoload
$uri = 'https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim'
(New-Object Net.WebClient).DownloadFile(
  $uri,
  $ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath(
    "~\AppData\Local\nvim\autoload\plug.vim"
  )
)

I received the first error because I already have vim-plug installed with the same commands. You don’t have to worry about it. Go ahead and press Enter after you arrive at this.
This automatically creates a folder called autoload inside your ~/AppData/Local/nvim folder and a file called plug.vim inside the autoload folder after the aforementioned command execution.

If you made it till this far, you are ready to install some plugins using vim-plug!

Installing plugins using vim-plug

We included some Plug commands in our init.vim file to install a lot of plugins for Neovim. We can now install them into Neovim using vim-plug. Create a new folder called plugged inside the ~/AppData/Local/nvim as follows. This (plugged folder) is where all your plugins would get installed. Restart nvim if you already have it open.

Open nvim by Run command, type the command :PlugInstall into the Neovim window and press Enter. You’ll notice that all the plugins you desired to get into Neovim by writing those down into init.vim will now start to get installed one-by-one. It takes a few minutes to install new plugins.

You’ll receive a confirmation like this when Neovim is done installing the available plugins using vim-plug. To verify, check if we got any folders of our installed plugins inside plugged folder.

There they are!
You can delete, add new plugins, check status of installed plugins or update existing ones using commands like :PlugStatus for status check and :PlugUpdate for updating existing plugins. Always restart Neovim before you use any vim-plug commands like this, otherwise plugins may not get properly installed.

As in above, the plugins onedark.vim and coc.nvim got updated. You can use :PlugDiff command to examine the changes between the previous version of the plugin and the current update.

You successfully installed these plugins, updated them and compared the differences. If you are feeling adventurous, you can use :help vim-plug to find out more information about how you can use vim-plug to the fullest.

Setting up HTML, CSS, JSON, TypeScript extensions for Neovim using coc.vim

coc.vim is a plugin which can be installed using vim-plug, which helps us in editing generic web development or other language code in a lot of supported languages. Check if you have the coc.vim plugin already installed using :PlugStatus command.
Quick Tip :-
Instead of using certain apps to open .vim files and .json files for viewing contents, you can copy the exact location of the required file, paste it in any browser and hit Enter.

If not installed, open up init.vim for editing like before and include the following Vim command and save it as init.vim again.

Plug 'neoclide/coc.nvim', {'branch': 'release'}

Restart nvim, and install it using :PlugInstall. Then restart nvim again.
Type the command :checkhealth in Neovim and press Enter. It’ll show you if the coc service is already running. If yes, use :CocInfo for details on the service.

To install language extensions, we need to use :CocInstall lang1 lang2 lang3 format command.
We can include as many as we want, with at least one language. For example, if we want to install only the extension for TypeScript, we use
:CocInstall coc-tsserver
else if we want to install extensions for HTML, CSS and JSON all at one go, we use
:CocInstall coc-html coc-css coc-json
You’ll see a message saying it has been installed (here I only installed the one for HTML).

Uninstalling a coc extension

We use :CocUninstall command followed by the extension name to uninstall the particular extension. Example – to uninstall a previously installed CSS extension for coc, we use

:CocUninstall coc-css

Updating a coc extension

We use :CocUpdate command to update a coc extension.

It will update the available coc extensions.

Configuring coc-settings to support not implemented languages and checking existing coc extensions list

The list of all available coc-extensions are listed here.
You can quickly check all the installed extensions available to you by :CocList extensions command.

A plus (+) sign before the extension means that it is loaded. A minus (-) sign before it means that it has been disabled. An asterisk (*) sign indicates that it has been activated. A question (?) mark implies that it is an invalid extension. In the above example, coc-prettier has been activated and the rest have been loaded. Press Esc key to go back after you have checked your extensions.
To edit the configuration file for coc.vim, we use :CocConfig command, which opens up coc-settings.json for us to edit and add other languages. Delete all the pre-existing text using :%d command from Normal Mode to Command Mode, paste the following code into the editor by right-clicking into the empty file and save the configuration file coc-settings.json using :w command.

{
  "suggest.noselect": false,
  "eslint.nodePath": "/home/user/.config/yarn/global/node_modules",
  "coc.preferences.formatOnSaveFiletypes": [
    "javascript",
    "typescript",
    "typescriptreact",
    "json",
    "javascriptreact",
    "typescript.tsx",
    "graphql",
    "html"
  ]
}

Use keys h, j, k and l to navigate left, down, up and right respectively on the file to be edited in Normal Mode, and press i to Insert. Press Esc key to go back to Normal Mode from Insert Mode. In the coc.preferences.formatOnSaveFiletypes array, type in your preferred languages as array elements within double quotation marks such as “html”, and remove any if not required. Save the file again using :w command.

Did you find this useful? Or did you get stuck somewhere in the middle? Comment below to let me know :)

Make your own Music Player "Online" using Arduino Uno, a Buzzer and a Resistor!

Ritika Das — Sat, 17 Oct 2020 04:12:23 +0000

Play_Music_Using_Arduino_Buzzer

Introduction

Welcome dear reader! It's Ritika here.

This will guide you on how to play musical notes of any song on a piezoelectric buzzer, using Arduino Uno R3, a resistor and some connecting wires.
This project can be attempted by complete beginners of Arduino as well as others, so jump into the details!

Overview and Prerequisites

We will be referring to piano notes only (for clarity). You are free to choose any instrument that you are comfortable with, examples - flute, saxophone, guitar, harmonium etc.

An 88-keys piano keyboard has the keys (in order) :

A0, A0#, B0,
C1, C1#, D1, D1#, E1, F1, F1#, G1, G1#, A1, A1#, B1,
C2, C2#, D2, D2#, E2, F2, F2#, G2, G2#, A2, A2#, B2,
C3, C3#, D3, D3#, E3, F3, F3#, G3, G3#, A3, A3#, B3,
C4, C4#, D4, D4#, E4, F4, F4#, G4, G4#, A4, A4#, B4,
C5, C5#, D5, D5#, E5, F5, F5#, G5, G5#, A5, A5#, B5,
C6, C6#, D6, D6#, E6, F6, F6#, G6, G6#, A6, A6#, B6,
C7, C7#, D7, D7#, E7, F7, F7#, G7, G7#, A7, A7#, B7,
C8

where A0 and C8 are the lowest and highest pitches possible respectively.
You can hear the notes of such a piano at https://pianu.com/ (Click on "Full Piano" and click the keys).

Piezoelectric buzzers or simply piezo buzzers are used mainly in alarm circuits to serve as a beeping or security alerting device mechanism. You can generally find them at any electronics shop at a price range from ₹20 to ₹70, i.e. 0.27$ to 0.94$. It is tiny (~ 1.2 cm), available in voltage ratings from 3.3V to 12V (5V is most common), and can produce frequencies from about 31 Hz to 65535 Hz. Good for the "20 Hz to 20000 Hz" hearing beings, we aren't missing out much on frequencies!

Components/Software Required :

Click here to skip to the schematic.

• 1 Arduino Uno R3 (a microcontroller board based on the ATmega328P)

• Arduino Software (open-source IDE) from https://www.arduino.cc/en/Main/Software (Installed Software or Web Editor)

• 1 Piezoelectric Buzzer (preferably 5V rated to be compatible with your Arduino Uno R3)

• 1 kΩ resistor (to reduce noise)

• 3 Jumper Wires (1 Male-to-Female for Arduino pin to buzzer leg, 1 Female-to-Female for resistor to buzzer leg, 1 Male-to-Female for Arduino pin to resistor)

Alternatively, if you want to use a breadboard (highly recommended), your list would be :

• 1 Arduino Uno R3 (a microcontroller board based on the ATmega328P)

• Arduino Software (open-source IDE) from https://www.arduino.cc/en/Main/Software (Installed Software or Web Editor)

• 1 Piezoelectric Buzzer (preferably 5V rated to be compatible with your Arduino Uno R3)

• 1 kΩ resistor (to reduce noise)

• 1 Mini Breadboard

• 2 Jumper Wires (1 Male-to-Male for Arduino pin to buzzer leg's line on breadboard, 1 Male-to-Male for Arduino pin to resistor's line on breadboard)

Extra Applications/Features (Recommended)

• Note Recognizer (Android App) from https://play.google.com/store/apps/details?id=nl.robertloeberdevelopment&hl=en_IN

• Stopwatch feature (Available in the Clock App for most phones)

Getting Started

Chances are that you might have come across a project online where the creator is playing music using an Arduino, and brownie points for you if you have even come across the actual code that went into it. Let me debunk it for you here.

Getting The Notes Right - Sampling

First, you want to make up your mind about the song you are planning to make Arduino "sing" for you. As it's your first time, settle on choosing one which has fairly less melodies, but which you really love. Hints - Jingle Bells, Hallelujah, Fur Elise or even Despacito. Something which has tunes really stuck in your head.
Now you need to get down to the musical notes which will give shape to your code. You can do so using the Note Recognizer App (assuming you might have trouble figuring out musical notes instantly). You just need to hum into the microphone piece of your phone or hands-free and voilà! It tells you what each note is called, and you are ready to hold the humming notes for a while and jot the names down. Even a sneeze or a snore has a note, so don't worry. You'll also see a decimal number being displayed upwards along with your note name; it's not needed right now, so we'll visit that later.
To see the GIF clearly, you may click here.

Getting The Note Durations Right - Approximation

Some notes last longer, some notes last shorter. THIS is the slightly tricky part. Let me give you an example. In the song Despacito, you might notice that the parts DES and PA are longer than the fast CI and TO parts. On average, if you sing it out, DES took 0.27 seconds (270 milliseconds), PA also took 0.27 seconds (270 milliseconds), CI took 0.19 seconds (190 milliseconds) and TO also took 0.19 seconds (190 milliseconds). How did I time these? Using the Stopwatch feature in my phone. You know how the song goes, you have jotted down the notes too; now time each note out and jot down the milliseconds (if you notice a 0M00S.00 format, you'll get something in 0.XY seconds, now multiply that by 1000, there you have your XY0 milliseconds!). We'll be needing all these data in the next section.

To see the GIF clearly, you may click here.

Almost There!

Now it's time to open the file Baianá_by_Bakermat.ino in this repository (or click here for it!). Wanna have a listen? Here is the original song that I have butchered (for educational purposes). Superglued my ears to this song!

Basics

• If we look at lines 10 to 98 - those are the defined notes with frequencies (in Hz). Our Arduino would be connected to a buzzer. A buzzer can't understand code! It is instructed by the microprocessor to play certain frequencies according to our code. Just as humans talk with fundamental frequency from 85 to 180 Hz (average adult male) or from 165 to 255 Hz (average adult female), every musical note is based upon a certain frequency. If you use Arduino IDE to compile your code, you can make it compact by replacing these lines of code with the "pitches.h" library in Arduino #include "pitches.h"

• If we look at lines 99 to 119 - we see int melody[], where melody is an integer array. It consists of all the musical notes we jotted down for our Arduino song. But wait, what are those 0s doing? We didn't jot them down! Well, those are called rest notes. Rest notes are used to denote pauses in between the notes, and indicate the frequency 0 Hz. It might be those parts when you sang the highest note in the climax of the song, then take a few milliseconds of rest to catch up on breath, and proceed to sing the next notes. Don't add the rest notes (0s) to the melody[] now! For now, just type in the jotted notes. Remember - A#4 from the app is typed as NOTE_AS4 and so on.

• If we look at lines 121 to 140 - we see int durations[], where durations is also an integer array. It consists of the durations of all the musical notes in milliseconds, which we have jotted down as well. Line 122 is 400,20, 600,20, 210,20, 210,20, 210,20, 210,20,, which corresponds to the durations for notes in line 101 NOTE_F5,0, NOTE_D5,0, NOTE_A5,0, NOTE_C6,0, NOTE_A5,0, NOTE_D6,0, . See the 20s? Those are the durations for the rest notes. The 400, 600 and the four 210s are the durations of the notes F5, D5, A5, C6, A5, D6 respectively. For now, type in the durations of the notes excluding the rest notes.

Going Deeper

• Now count the number of elements (entries separated by commas) in each array (melody[] and durations[]) and compare them. Are they same? If yes, great job! If not, check the note/duration you missed while typing. Since notes/melodies and durations correspond to each other, both the arrays must have the same number of elements. When you are done, squeeze in the rest notes (0s) in the melody[] array and add appropriate durations to them while timing them on Stopwatch. If there are no rest notes in your song, mark the corresponding duration with 0 milliseconds in the durations[] array.

• If we look at lines 141 to 147 - we see int songLength = sizeof(melody)/sizeof(melody[0]); on line 141. Here sizeof(melody) denotes the size of the entire melody array of notes, i.e.

(integer size) X (total number of notes). ------------(1)
On the other hand, sizeof(melody[0]) denotes the size of the first note element in the array, i.e. simply
(integer size) X (number of notes) = (integer size) X 1 = (integer size). ------------(2)
Dividing (1) by (2), we'll get (total number of notes) as the int songLength.
In the other lines having void setup(), there's nothing to set up. You may leave it as it is.

• If we look at lines 148 to 156 - we encounter the void loop() portion. This function is used when you want your song to loop (definitely try this one for the song to sound catchy!), that is, play over and over. Line 149 has for (int thisNote = 0; thisNote < songLength; thisNote++), which ensures that all your notes from the beginning to the endnote are successfully played. Line 151 has tone(8, melody[thisNote], duration);, where the number "8" indicates the Arduino pin that the negative terminal of the buzzer is connected to. This is also found in line 154 as noTone(8);. If you wish to connect the Buzzer to another Arduino pin (i.e. other than 8), make sure to change the number in these two lines.

Takeaways and Possible Quagmire

The connection can be followed as in this image :

• If you wish to virtually simulate this project due to unavailability of components, go ahead and click on the above picture! It'll take you where you'll have the options of
🅐 "Start Simulation" - if you directly want to see what it's like, and
🅑 "Tinker This" - if you want to create a copy for yourself without altering the original project, tweak the code and then start simulation.

• Did you know that the note recognition range for the Note Recognizer App is E2 - G7? That is, no whistle notes.

• If you think that your final Arduino song sounds a bit low on the pitch, just change all the musical notes in int melody[] up one scale : change NOTE_CS4 to NOTE_CS5, NOTE_G5 to NOTE_G6 and so on, keeping the durations same. Trust me, it will automatically sound better! Or maybe close to this :

• Instead of using note names in the melody array, we could have used the frequencies of the notes instead, save for it may be cumbersome.

• Encountering issues with this project is normal, but issue-solving attempts with no respite may feel like an abyss! Click here to cut yourself some slack, and let me know where you're stuck. You've worked your heads off at this point.

• Fun fact - I've built sandcastles in the air with this project for 2+ years, and I've finally given it a shape. If you have some ideas to improve upon the code, add something new to this project or something that you think I might have missed out on - create a pull request here. If I agree with your changes/additions, I will merge it.

Confident vibes, and bubbling tea ideas from Open Source Contributions - Making the most out of it!

Ritika Das — Sat, 17 Oct 2020 03:38:51 +0000

What I Learned From Hacktoberfest

I'm glad to be a part of the Hacktoberfest 2020, and kudos to the fact that I could learn so much more about GitHub, web development, programming languages, how codes are approved/merged and most importantly how we all could be of help by contributing code and more to amazing repositories. I agree that I have become a lot more confident - looking forward to 2021's edition, thanks DigitalOcean!

I contributed some 8085 Assembly language programs, simple Python and Turtle design codes, Scilab plots, GitHub workflows, a cloud haiku, fixed a broken link for a website and added a term to Dev glossary! This was my first Hacktoberfest. I hope I can strive harder and become a better skilled developer by the next edition.

I used to wonder, can I even contribute something that can be useful "enough"? Then repo issues and alongside ideas came pouring in. And it unleashed the developer side in me. I didn't think I could win a tee, but all I wanted for this fest was that at least my PRs get merged sometime later and if not - that I received some feedback on what I could do better. It's like this fest whispered in my ears, "Never stop believing in what you are capable of."

So my take is - give it your all. Give shape to your ideas by using code in JS/CSS/HTML/PHP, or inhale some inspiration from YouTube videos or W3Schools courses on your favourite framework. But remember, baby steps each day. You have my luck!