self-hosted/joplin
1
0
Fork 0
mirror of https://github.com/laurent22/joplin.git synced 2024-12-12 08:54:00 +02:00
Code Issues Releases Activity
62feb7ff60
joplin/packages/app-desktop/gui/NoteEditor/commands/editorCommandDeclarations.ts

95 lines
1.6 KiB
TypeScript
Raw Normal View History

Tools: Renamed package namespace from @joplinapp to @joplin
2020-11-07 17:59:37 +02:00
import { CommandDeclaration } from '@joplin/lib/services/CommandService';
import { _ } from '@joplin/lib/locale';
Desktop: Refactored command system The goal is to make the command system more modular, so each command can be defined as a single object that includes a declaration (name, label, etc.) and a runtime (to execute the command, test if it should be enabled, etc.) Utility methods are provided to convert a command to a menu item or a toolbar button, thus reducing duplicated and boiler plate code across the codebase (often the menu item logic was duplicated in the toolbar button logic and vice versa). The goal is to make it easier to add new commands (and associated menu item and toolbar buttons) and to call them from anywhere. This is also useful for plugins, which can also easily define new commands. Could also allow creating a command palette.
2020-07-03 23:32:39 +02:00
const declarations:CommandDeclaration[] = [
{
name: 'insertText',
},
All: Add support for application plugins (#3257)
2020-10-09 19:35:46 +02:00
{
name: 'scrollToHash',
},
Desktop: Refactored command system The goal is to make the command system more modular, so each command can be defined as a single object that includes a declaration (name, label, etc.) and a runtime (to execute the command, test if it should be enabled, etc.) Utility methods are provided to convert a command to a menu item or a toolbar button, thus reducing duplicated and boiler plate code across the codebase (often the menu item logic was duplicated in the toolbar button logic and vice versa). The goal is to make it easier to add new commands (and associated menu item and toolbar buttons) and to call them from anywhere. This is also useful for plugins, which can also easily define new commands. Could also allow creating a command palette.
2020-07-03 23:32:39 +02:00
{
name: 'textCopy',
label: () => _('Copy'),
role: 'copy',
},
{
name: 'textCut',
label: () => _('Cut'),
role: 'cut',
},
{
name: 'textPaste',
label: () => _('Paste'),
role: 'paste',
},
{
name: 'textSelectAll',
label: () => _('Select all'),
role: 'selectAll',
},
{
name: 'textBold',
label: () => _('Bold'),
Desktop: UI update (#3586)
2020-09-15 15:01:07 +02:00
iconName: 'icon-bold',
Desktop: Refactored command system The goal is to make the command system more modular, so each command can be defined as a single object that includes a declaration (name, label, etc.) and a runtime (to execute the command, test if it should be enabled, etc.) Utility methods are provided to convert a command to a menu item or a toolbar button, thus reducing duplicated and boiler plate code across the codebase (often the menu item logic was duplicated in the toolbar button logic and vice versa). The goal is to make it easier to add new commands (and associated menu item and toolbar buttons) and to call them from anywhere. This is also useful for plugins, which can also easily define new commands. Could also allow creating a command palette.
2020-07-03 23:32:39 +02:00
},
{
name: 'textItalic',
label: () => _('Italic'),
Desktop: UI update (#3586)
2020-09-15 15:01:07 +02:00
iconName: 'icon-italic',
Desktop: Refactored command system The goal is to make the command system more modular, so each command can be defined as a single object that includes a declaration (name, label, etc.) and a runtime (to execute the command, test if it should be enabled, etc.) Utility methods are provided to convert a command to a menu item or a toolbar button, thus reducing duplicated and boiler plate code across the codebase (often the menu item logic was duplicated in the toolbar button logic and vice versa). The goal is to make it easier to add new commands (and associated menu item and toolbar buttons) and to call them from anywhere. This is also useful for plugins, which can also easily define new commands. Could also allow creating a command palette.
2020-07-03 23:32:39 +02:00
},
{
name: 'textLink',
label: () => _('Hyperlink'),
Desktop: UI update (#3586)
2020-09-15 15:01:07 +02:00
iconName: 'icon-link',
Desktop: Refactored command system The goal is to make the command system more modular, so each command can be defined as a single object that includes a declaration (name, label, etc.) and a runtime (to execute the command, test if it should be enabled, etc.) Utility methods are provided to convert a command to a menu item or a toolbar button, thus reducing duplicated and boiler plate code across the codebase (often the menu item logic was duplicated in the toolbar button logic and vice versa). The goal is to make it easier to add new commands (and associated menu item and toolbar buttons) and to call them from anywhere. This is also useful for plugins, which can also easily define new commands. Could also allow creating a command palette.
2020-07-03 23:32:39 +02:00
},
{
name: 'textCode',
label: () => _('Code'),
Desktop: UI update (#3586)
2020-09-15 15:01:07 +02:00
iconName: 'icon-code',
Desktop: Refactored command system The goal is to make the command system more modular, so each command can be defined as a single object that includes a declaration (name, label, etc.) and a runtime (to execute the command, test if it should be enabled, etc.) Utility methods are provided to convert a command to a menu item or a toolbar button, thus reducing duplicated and boiler plate code across the codebase (often the menu item logic was duplicated in the toolbar button logic and vice versa). The goal is to make it easier to add new commands (and associated menu item and toolbar buttons) and to call them from anywhere. This is also useful for plugins, which can also easily define new commands. Could also allow creating a command palette.
2020-07-03 23:32:39 +02:00
},
{
name: 'attachFile',
label: () => _('Attach file'),
Desktop: UI update (#3586)
2020-09-15 15:01:07 +02:00
iconName: 'icon-attachment',
Desktop: Refactored command system The goal is to make the command system more modular, so each command can be defined as a single object that includes a declaration (name, label, etc.) and a runtime (to execute the command, test if it should be enabled, etc.) Utility methods are provided to convert a command to a menu item or a toolbar button, thus reducing duplicated and boiler plate code across the codebase (often the menu item logic was duplicated in the toolbar button logic and vice versa). The goal is to make it easier to add new commands (and associated menu item and toolbar buttons) and to call them from anywhere. This is also useful for plugins, which can also easily define new commands. Could also allow creating a command palette.
2020-07-03 23:32:39 +02:00
},
{
name: 'textNumberedList',
label: () => _('Numbered List'),
Desktop: UI update (#3586)
2020-09-15 15:01:07 +02:00
iconName: 'icon-numbered-list',
Desktop: Refactored command system The goal is to make the command system more modular, so each command can be defined as a single object that includes a declaration (name, label, etc.) and a runtime (to execute the command, test if it should be enabled, etc.) Utility methods are provided to convert a command to a menu item or a toolbar button, thus reducing duplicated and boiler plate code across the codebase (often the menu item logic was duplicated in the toolbar button logic and vice versa). The goal is to make it easier to add new commands (and associated menu item and toolbar buttons) and to call them from anywhere. This is also useful for plugins, which can also easily define new commands. Could also allow creating a command palette.
2020-07-03 23:32:39 +02:00
},
{
name: 'textBulletedList',
label: () => _('Bulleted List'),
Desktop: UI update (#3586)
2020-09-15 15:01:07 +02:00
iconName: 'icon-bulleted-list',
Desktop: Refactored command system The goal is to make the command system more modular, so each command can be defined as a single object that includes a declaration (name, label, etc.) and a runtime (to execute the command, test if it should be enabled, etc.) Utility methods are provided to convert a command to a menu item or a toolbar button, thus reducing duplicated and boiler plate code across the codebase (often the menu item logic was duplicated in the toolbar button logic and vice versa). The goal is to make it easier to add new commands (and associated menu item and toolbar buttons) and to call them from anywhere. This is also useful for plugins, which can also easily define new commands. Could also allow creating a command palette.
2020-07-03 23:32:39 +02:00
},
{
name: 'textCheckbox',
label: () => _('Checkbox'),
Desktop: UI update (#3586)
2020-09-15 15:01:07 +02:00
iconName: 'icon-to-do-list',
Desktop: Refactored command system The goal is to make the command system more modular, so each command can be defined as a single object that includes a declaration (name, label, etc.) and a runtime (to execute the command, test if it should be enabled, etc.) Utility methods are provided to convert a command to a menu item or a toolbar button, thus reducing duplicated and boiler plate code across the codebase (often the menu item logic was duplicated in the toolbar button logic and vice versa). The goal is to make it easier to add new commands (and associated menu item and toolbar buttons) and to call them from anywhere. This is also useful for plugins, which can also easily define new commands. Could also allow creating a command palette.
2020-07-03 23:32:39 +02:00
},
{
name: 'textHeading',
label: () => _('Heading'),
Desktop: UI update (#3586)
2020-09-15 15:01:07 +02:00
iconName: 'icon-heading',
Desktop: Refactored command system The goal is to make the command system more modular, so each command can be defined as a single object that includes a declaration (name, label, etc.) and a runtime (to execute the command, test if it should be enabled, etc.) Utility methods are provided to convert a command to a menu item or a toolbar button, thus reducing duplicated and boiler plate code across the codebase (often the menu item logic was duplicated in the toolbar button logic and vice versa). The goal is to make it easier to add new commands (and associated menu item and toolbar buttons) and to call them from anywhere. This is also useful for plugins, which can also easily define new commands. Could also allow creating a command palette.
2020-07-03 23:32:39 +02:00
},
{
name: 'textHorizontalRule',
label: () => _('Horizontal Rule'),
Desktop: UI update (#3586)
2020-09-15 15:01:07 +02:00
iconName: 'fas fa-ellipsis-h',
Desktop: Refactored command system The goal is to make the command system more modular, so each command can be defined as a single object that includes a declaration (name, label, etc.) and a runtime (to execute the command, test if it should be enabled, etc.) Utility methods are provided to convert a command to a menu item or a toolbar button, thus reducing duplicated and boiler plate code across the codebase (often the menu item logic was duplicated in the toolbar button logic and vice versa). The goal is to make it easier to add new commands (and associated menu item and toolbar buttons) and to call them from anywhere. This is also useful for plugins, which can also easily define new commands. Could also allow creating a command palette.
2020-07-03 23:32:39 +02:00
},
{
name: 'insertDateTime',
label: () => _('Insert Date Time'),
Desktop: UI update (#3586)
2020-09-15 15:01:07 +02:00
iconName: 'icon-add-date',
Desktop: Refactored command system The goal is to make the command system more modular, so each command can be defined as a single object that includes a declaration (name, label, etc.) and a runtime (to execute the command, test if it should be enabled, etc.) Utility methods are provided to convert a command to a menu item or a toolbar button, thus reducing duplicated and boiler plate code across the codebase (often the menu item logic was duplicated in the toolbar button logic and vice versa). The goal is to make it easier to add new commands (and associated menu item and toolbar buttons) and to call them from anywhere. This is also useful for plugins, which can also easily define new commands. Could also allow creating a command palette.
2020-07-03 23:32:39 +02:00
},
All: Add support for application plugins (#3257)
2020-10-09 19:35:46 +02:00
{
name: 'selectedText',
},
{
name: 'replaceSelection',
},
Desktop: Refactored command system The goal is to make the command system more modular, so each command can be defined as a single object that includes a declaration (name, label, etc.) and a runtime (to execute the command, test if it should be enabled, etc.) Utility methods are provided to convert a command to a menu item or a toolbar button, thus reducing duplicated and boiler plate code across the codebase (often the menu item logic was duplicated in the toolbar button logic and vice versa). The goal is to make it easier to add new commands (and associated menu item and toolbar buttons) and to call them from anywhere. This is also useful for plugins, which can also easily define new commands. Could also allow creating a command palette.
2020-07-03 23:32:39 +02:00
];
export default declarations;
Reference in New Issue Copy Permalink