diff --git a/package.json b/package.json
index e8567a8..b252dd3 100644
--- a/package.json
+++ b/package.json
@@ -81,6 +81,48 @@
         "command": "memory-inspector.show-variable",
         "title": "Show in Memory Inspector",
         "category": "Memory"
+      },
+      {
+        "command": "memory-inspector.show-variables-column",
+        "title": "Show Variables Column",
+        "category": "Memory",
+        "enablement": "webviewId === memory-inspector.memory"
+      },
+      {
+        "command": "memory-inspector.hide-variables-column",
+        "title": "Hide Variables Column",
+        "category": "Memory",
+        "enablement": "webviewId === memory-inspector.memory"
+      },
+      {
+        "command": "memory-inspector.show-ascii-column",
+        "title": "Show ASCII Column",
+        "category": "Memory",
+        "enablement": "webviewId === memory-inspector.memory"
+      },
+      {
+        "command": "memory-inspector.hide-ascii-column",
+        "title": "Hide ASCII Column",
+        "category": "Memory",
+        "enablement": "webviewId === memory-inspector.memory"
+      },
+      {
+        "command": "memory-inspector.show-radix-prefix",
+        "title": "Show Radix Prefix",
+        "category": "Memory",
+        "enablement": "webviewId === memory-inspector.memory"
+      },
+      {
+        "command": "memory-inspector.hide-radix-prefix",
+        "title": "Hide Radix Prefix",
+        "category": "Memory",
+        "enablement": "webviewId === memory-inspector.memory"
+      },
+      {
+        "command": "memory-inspector.show-advanced-display-options",
+        "title": "Advanced Display Options",
+        "category": "Memory",
+        "enablement": "webviewId === memory-inspector.memory"
       }
     ],
     "menus": {
@@ -105,6 +147,47 @@
           "command": "memory-inspector.show-variable",
           "when": "canViewMemory && memory-inspector.canRead"
         }
+      ],
+      "webview/context": [
+        {
+          "command": "memory-inspector.show-variables-column",
+          "title": "Show Variables Column",
+          "group": "display@1",
+          "when": "webviewId === memory-inspector.memory && !(visibleColumns =~ /\\|variables\\|/)"
+        },
+        {
+          "command": "memory-inspector.hide-variables-column",
+          "title": "Hide Variables Column",
+          "group": "display@1",
+          "when": "webviewId === memory-inspector.memory && visibleColumns =~ /\\|variables\\|/"
+        },
+        {
+          "command": "memory-inspector.show-ascii-column",
+          "title": "Show ASCII Column",
+          "group": "display@2",
+          "when": "webviewId === memory-inspector.memory && !(visibleColumns =~ /\\|ascii\\|/)"
+        },
+        {
+          "command": "memory-inspector.hide-ascii-column",
+          "title": "Hide ASCII Column",
+          "group": "display@2",
+          "when": "webviewId === memory-inspector.memory && visibleColumns =~ /\\|ascii\\|/"
+        },
+        {
+          "command": "memory-inspector.show-radix-prefix",
+          "group": "display@3",
+          "when": "webviewId === memory-inspector.memory && !showRadixPrefix"
+        },
+        {
+          "command": "memory-inspector.hide-radix-prefix",
+          "group": "display@3",
+          "when": "webviewId === memory-inspector.memory && showRadixPrefix"
+        },
+        {
+          "command": "memory-inspector.show-advanced-display-options",
+          "group": "display@4",
+          "when": "webviewId === memory-inspector.memory"
+        }
       ]
     },
     "customEditors": [
diff --git a/src/common/messaging.ts b/src/common/messaging.ts
index a8d9d8d..2eaa96c 100644
--- a/src/common/messaging.ts
+++ b/src/common/messaging.ts
@@ -31,3 +31,14 @@ export const setOptionsType: RequestType<Partial<DebugProtocol.ReadMemoryArgumen
 export const readMemoryType: RequestType<DebugProtocol.ReadMemoryArguments, MemoryReadResult> = { method: 'readMemory' };
 export const writeMemoryType: RequestType<DebugProtocol.WriteMemoryArguments, MemoryWriteResult> = { method: 'writeMemory' };
 export const getVariables: RequestType<DebugProtocol.ReadMemoryArguments, VariableRange[]> = { method: 'getVariables' };
+
+export const showAdvancedDisplayConfigurationType: NotificationType<void> = { method: 'showAdvancedOptions' };
+export const getWebviewSelectionType: RequestType<void, WebviewSelection> = { method: 'getWebviewSelection' };
+
+export interface WebviewSelection {
+    selectedCell?: {
+        column: string
+        value: string
+    }
+    textSelection?: string;
+}
diff --git a/src/plugin/memory-webview-main.ts b/src/plugin/memory-webview-main.ts
index faacb57..0f4363f 100644
--- a/src/plugin/memory-webview-main.ts
+++ b/src/plugin/memory-webview-main.ts
@@ -31,6 +31,9 @@ import {
     setMemoryViewSettingsType,
     resetMemoryViewSettingsType,
     setTitleType,
+    showAdvancedDisplayConfigurationType as showAdvancedOptionsConfigurationType,
+    getWebviewSelectionType,
+    WebviewSelection,
 } from '../common/messaging';
 import { MemoryProvider } from './memory-provider';
 import { outputChannelLogger } from './logger';
@@ -49,6 +52,12 @@ enum RefreshEnum {
     on = 1
 }
 
+export interface WebviewMenuContext {
+    messageParticipant: WebviewIdMessageParticipant,
+    visibleColumns: string,
+    showRadixPrefix: boolean,
+}
+
 const isMemoryVariable = (variable: Variable): variable is Variable => variable && !!(variable as Variable).memoryReference;
 const CONFIGURABLE_COLUMNS = [
     manifest.CONFIG_SHOW_ASCII_COLUMN,
@@ -59,6 +68,14 @@ export class MemoryWebview implements vscode.CustomReadonlyEditorProvider {
     public static ViewType = `${manifest.PACKAGE_NAME}.memory`;
     public static ShowCommandType = `${manifest.PACKAGE_NAME}.show`;
     public static VariableCommandType = `${manifest.PACKAGE_NAME}.show-variable`;
+    public static ShowAsciiColumnCommandType = `${manifest.PACKAGE_NAME}.show-ascii-column`;
+    public static HideAsciiColumnCommandType = `${manifest.PACKAGE_NAME}.hide-ascii-column`;
+    public static ShowVariablesColumnCommandType = `${manifest.PACKAGE_NAME}.show-variables-column`;
+    public static HideVariablesColumnCommandType = `${manifest.PACKAGE_NAME}.hide-variables-column`;
+    public static ShowRadixPrefixCommandType = `${manifest.PACKAGE_NAME}.show-radix-prefix`;
+    public static HideRadixPrefixCommandType = `${manifest.PACKAGE_NAME}.hide-radix-prefix`;
+    public static ShowAdvancedDisplayConfigurationCommandType = `${manifest.PACKAGE_NAME}.show-advanced-display-options`;
+    public static GetWebviewSelectionCommandType = `${manifest.PACKAGE_NAME}.get-webview-selection`;
 
     protected messenger: Messenger;
     protected refreshOnStop: RefreshEnum;
@@ -77,6 +94,10 @@ export class MemoryWebview implements vscode.CustomReadonlyEditorProvider {
     }
 
     public activate(context: vscode.ExtensionContext): void {
+        const getVisibleColumns =
+            (columnContext: string): string[] =>
+                columnContext.substring(1, columnContext.length - 1).split('|');
+
         context.subscriptions.push(
             vscode.window.registerCustomEditorProvider(manifest.EDITOR_NAME, this),
             vscode.commands.registerCommand(MemoryWebview.ShowCommandType, () => this.show()),
@@ -85,7 +106,29 @@ export class MemoryWebview implements vscode.CustomReadonlyEditorProvider {
                 if (isMemoryVariable(variable)) {
                     this.show({ memoryReference: variable.memoryReference.toString() });
                 }
-            })
+            }),
+            vscode.commands.registerCommand(MemoryWebview.ShowVariablesColumnCommandType, (ctx: WebviewMenuContext) => {
+                this.setMemoryViewSettings(ctx.messageParticipant, { visibleColumns: [...getVisibleColumns(ctx.visibleColumns), 'variables'] });
+            }),
+            vscode.commands.registerCommand(MemoryWebview.HideVariablesColumnCommandType, (ctx: WebviewMenuContext) => {
+                this.setMemoryViewSettings(ctx.messageParticipant, { visibleColumns: getVisibleColumns(ctx.visibleColumns).filter(column => column !== 'variables') });
+            }),
+            vscode.commands.registerCommand(MemoryWebview.ShowAsciiColumnCommandType, (ctx: WebviewMenuContext) => {
+                this.setMemoryViewSettings(ctx.messageParticipant, { visibleColumns: [...getVisibleColumns(ctx.visibleColumns), 'ascii'] });
+            }),
+            vscode.commands.registerCommand(MemoryWebview.HideAsciiColumnCommandType, (ctx: WebviewMenuContext) => {
+                this.setMemoryViewSettings(ctx.messageParticipant, { visibleColumns: getVisibleColumns(ctx.visibleColumns).filter(column => column !== 'ascii') });
+            }),
+            vscode.commands.registerCommand(MemoryWebview.ShowRadixPrefixCommandType, (ctx: WebviewMenuContext) => {
+                this.setMemoryViewSettings(ctx.messageParticipant, { showRadixPrefix: true, visibleColumns: getVisibleColumns(ctx.visibleColumns) });
+            }),
+            vscode.commands.registerCommand(MemoryWebview.HideRadixPrefixCommandType, (ctx: WebviewMenuContext) => {
+                this.setMemoryViewSettings(ctx.messageParticipant, { showRadixPrefix: false, visibleColumns: getVisibleColumns(ctx.visibleColumns) });
+            }),
+            vscode.commands.registerCommand(MemoryWebview.ShowAdvancedDisplayConfigurationCommandType, async (ctx: WebviewMenuContext) => {
+                this.messenger.sendNotification(showAdvancedOptionsConfigurationType, ctx.messageParticipant, undefined);
+            }),
+            vscode.commands.registerCommand(MemoryWebview.GetWebviewSelectionCommandType, (ctx: WebviewMenuContext) => this.getWebviewSelection(ctx.messageParticipant))
         );
     };
 
@@ -213,10 +256,14 @@ export class MemoryWebview implements vscode.CustomReadonlyEditorProvider {
     }
 
     protected setInitialSettings(webviewParticipant: WebviewIdMessageParticipant, title: string): void {
-        this.messenger.sendNotification(setMemoryViewSettingsType, webviewParticipant, this.getMemoryViewSettings(title));
+        this.setMemoryViewSettings(webviewParticipant, this.getMemoryViewSettings(webviewParticipant, title));
     }
 
-    protected getMemoryViewSettings(title: string): MemoryViewSettings {
+    protected setMemoryViewSettings(webviewParticipant: WebviewIdMessageParticipant, settings: Partial<MemoryViewSettings>): void {
+        this.messenger.sendNotification(setMemoryViewSettingsType, webviewParticipant, settings);
+    }
+
+    protected getMemoryViewSettings(messageParticipant: WebviewIdMessageParticipant, title: string): MemoryViewSettings {
         const memoryInspectorConfiguration = vscode.workspace.getConfiguration(manifest.PACKAGE_NAME);
         const bytesPerWord = memoryInspectorConfiguration.get<number>(manifest.CONFIG_BYTES_PER_WORD, manifest.DEFAULT_BYTES_PER_WORD);
         const wordsPerGroup = memoryInspectorConfiguration.get<number>(manifest.CONFIG_WORDS_PER_GROUP, manifest.DEFAULT_WORDS_PER_GROUP);
@@ -227,7 +274,7 @@ export class MemoryWebview implements vscode.CustomReadonlyEditorProvider {
             .map(columnId => columnId.replace('columns.', ''));
         const addressRadix = memoryInspectorConfiguration.get<number>(manifest.CONFIG_ADDRESS_RADIX, manifest.DEFAULT_ADDRESS_RADIX);
         const showRadixPrefix = memoryInspectorConfiguration.get<boolean>(manifest.CONFIG_SHOW_RADIX_PREFIX, manifest.DEFAULT_SHOW_RADIX_PREFIX);
-        return { title, bytesPerWord, wordsPerGroup, groupsPerRow, scrollingBehavior, visibleColumns, addressRadix, showRadixPrefix };
+        return { messageParticipant, title, bytesPerWord, wordsPerGroup, groupsPerRow, scrollingBehavior, visibleColumns, addressRadix, showRadixPrefix };
     }
 
     protected async readMemory(request: DebugProtocol.ReadMemoryArguments): Promise<MemoryReadResult> {
@@ -254,4 +301,8 @@ export class MemoryWebview implements vscode.CustomReadonlyEditorProvider {
             return [];
         }
     }
+
+    protected getWebviewSelection(webviewParticipant: WebviewIdMessageParticipant): Promise<WebviewSelection> {
+        return this.messenger.sendRequest(getWebviewSelectionType, webviewParticipant, undefined);
+    }
 }
diff --git a/src/webview/columns/address-column.tsx b/src/webview/columns/address-column.tsx
index 532c986..040c2fb 100644
--- a/src/webview/columns/address-column.tsx
+++ b/src/webview/columns/address-column.tsx
@@ -16,8 +16,9 @@
 
 import React, { ReactNode } from 'react';
 import { BigIntMemoryRange, getAddressString, getRadixMarker } from '../../common/memory-range';
-import { ColumnContribution } from './column-contribution-service';
+import { createVscodeContext } from '../utils/vscode-contexts';
 import { Memory, MemoryDisplayConfiguration } from '../utils/view-types';
+import { ColumnContribution } from './column-contribution-service';
 
 export class AddressColumn implements ColumnContribution {
     static ID = 'address';
@@ -27,7 +28,12 @@ export class AddressColumn implements ColumnContribution {
     readonly priority = 0;
 
     render(range: BigIntMemoryRange, _: Memory, options: MemoryDisplayConfiguration): ReactNode {
-        return <span className='memory-start-address'>
+        const cellContext = {
+            address: getAddressString(range.startAddress, options.addressRadix),
+            radix: getRadixMarker(options.addressRadix),
+
+        };
+        return <span className='memory-start-address' {...createVscodeContext(cellContext)}>
             {options.showRadixPrefix && <span className='radix-prefix'>{getRadixMarker(options.addressRadix)}</span>}
             <span className='address'>{getAddressString(range.startAddress, options.addressRadix)}</span>
         </span>;
diff --git a/src/webview/components/memory-table.tsx b/src/webview/components/memory-table.tsx
index a9875da..c3d1beb 100644
--- a/src/webview/components/memory-table.tsx
+++ b/src/webview/components/memory-table.tsx
@@ -25,6 +25,8 @@ import { Decoration, Memory, MemoryDisplayConfiguration, ScrollingBehavior, isTr
 import isDeepEqual from 'fast-deep-equal';
 import { AddressColumn } from '../columns/address-column';
 import { classNames } from 'primereact/utils';
+import { createColumnVscodeContext, createSectionVscodeContext } from '../utils/vscode-contexts';
+import { WebviewSelection } from '../../common/messaging';
 
 export interface MoreMemorySelectProps {
     count: number;
@@ -117,8 +119,11 @@ interface MemoryRowData {
     endAddress: bigint;
 }
 
+export interface MemoryTableCellSelection extends DataTableCellSelection<MemoryRowData[]> {
+    textContent: string;
+}
 interface MemoryTableState {
-    selection: DataTableCellSelection<MemoryRowData[]> | null;
+    selection: MemoryTableCellSelection | null;
 }
 
 type MemorySizeOptions = Pick<MemoryTableProps, 'bytesPerWord' | 'wordsPerGroup' | 'groupsPerRow'>;
@@ -136,6 +141,7 @@ namespace MemorySizeOptions {
 export class MemoryTable extends React.PureComponent<MemoryTableProps, MemoryTableState> {
 
     protected datatableRef = React.createRef<DataTable<MemoryRowData[]>>();
+    protected sectionMenuContext = createSectionVscodeContext('memoryTable');
 
     protected get isShowMoreEnabled(): boolean {
         return !!this.props.memory?.bytes.length;
@@ -181,14 +187,16 @@ export class MemoryTable extends React.PureComponent<MemoryTableProps, MemoryTab
         const columnWidth = remainingWidth / (this.props.columnOptions.length);
 
         return (
-            <div className='flex-1 overflow-auto px-4'>
+            <div className='flex-1 overflow-auto px-4' >
                 <DataTable<MemoryRowData[]>
                     ref={this.datatableRef}
+                    onContextMenuCapture={this.onContextMenu}
+                    {...this.sectionMenuContext}
                     {...props}
                 >
                     {this.props.columnOptions.map(({ contribution }) => {
                         const fit = contribution.id === AddressColumn.ID;
-
+                        const pt = { root: createColumnVscodeContext(contribution.id) };
                         return <Column
                             key={contribution.id}
                             field={contribution.id}
@@ -196,6 +204,7 @@ export class MemoryTable extends React.PureComponent<MemoryTableProps, MemoryTab
                             className={classNames({ fit })}
                             headerClassName={classNames({ fit })}
                             style={{ width: fit ? undefined : `${columnWidth}%` }}
+                            pt={pt}
                             body={(row?: MemoryRowData) => row && contribution.render(row, this.props.memory!, this.props)}>
                             {contribution.label}
                         </Column>;
@@ -214,6 +223,8 @@ export class MemoryTable extends React.PureComponent<MemoryTableProps, MemoryTab
             lazy: true,
             metaKeySelection: false,
             onSelectionChange: this.onSelectionChanged,
+            onContextMenuCapture: this.onContextMenu,
+            onCopy: this.onCopy,
             resizableColumns: true,
             scrollable: true,
             scrollHeight: 'flex',
@@ -226,7 +237,49 @@ export class MemoryTable extends React.PureComponent<MemoryTableProps, MemoryTab
     }
 
     protected onSelectionChanged = (event: DataTableSelectionCellChangeEvent<MemoryRowData[]>) => {
-        this.setState(prev => ({ ...prev, selection: event.value }));
+        // eslint-disable-next-line no-null/no-null
+        const value = event.value ? event.value as MemoryTableCellSelection : null;
+        if (value) {
+            value.textContent = event.originalEvent.currentTarget?.textContent ?? '';
+        }
+
+        this.setState(prev => ({ ...prev, selection: value }));
+    };
+
+    protected onCopy = (_event: React.ClipboardEvent) => {
+        // if we don't have a text selection, we copy the textContent of the currently selected cell
+        if (!window.getSelection()?.toString() && this.state.selection) {
+            navigator.clipboard.writeText(this.state.selection.textContent);
+        }
+    };
+
+    protected onContextMenu = (event: React.MouseEvent) => {
+        /* Context menu events for cells are triggered on the root td.
+         * The rendered child content might provide additional vscode context data.
+         * Per default this child context will not be available in the merged vscode context
+         * So we need to handle this case manually and merge the child context into the parent context.
+         */
+        if (!(event.target instanceof HTMLElement)) {
+            return;
+        }
+        const parent = event.target.closest('.p-selectable-cell');
+        if (!parent || !(parent instanceof HTMLTableCellElement)) {
+            return;
+        }
+        let currentElement: Element | undefined = event.target;
+        const childContexts: object[] = [];
+        while (currentElement && currentElement !== parent) {
+            if (currentElement instanceof HTMLElement && currentElement.dataset?.vscodeContext) {
+                childContexts.push(JSON.parse(currentElement.dataset['vscodeContext']));
+            }
+            currentElement = currentElement.parentElement ?? undefined;
+        }
+
+        if (childContexts.length > 0) {
+            const parentContext = JSON.parse(parent.dataset['vscodeContext'] ?? '{}');
+            const mergedContext = childContexts.reduce((acc, cur) => ({ ...acc, ...cur }), parentContext);
+            parent.dataset['vscodeContext'] = JSON.stringify(mergedContext);
+        }
     };
 
     protected renderHeader(): React.ReactNode | undefined {
@@ -316,9 +369,14 @@ export class MemoryTable extends React.PureComponent<MemoryTableProps, MemoryTab
         return {
             rowIndex,
             startAddress,
-            endAddress: startAddress + memoryTableOptions.bigWordsPerRow
+            endAddress: startAddress + memoryTableOptions.bigWordsPerRow,
         };
     }
+
+    public getWebviewSelection(): WebviewSelection {
+        const textSelection = window.getSelection()?.toString() ?? '';
+        return this.state.selection ? { textSelection, selectedCell: { column: this.state.selection.field, value: this.state.selection.textContent } } : { textSelection };
+    }
 }
 
 export namespace MemoryTable {
diff --git a/src/webview/components/memory-widget.tsx b/src/webview/components/memory-widget.tsx
index 4d75877..9350b20 100644
--- a/src/webview/components/memory-widget.tsx
+++ b/src/webview/components/memory-widget.tsx
@@ -17,11 +17,15 @@
 import { DebugProtocol } from '@vscode/debugprotocol';
 import React from 'react';
 import { ColumnStatus } from '../columns/column-contribution-service';
-import { Decoration, Endianness, Memory, MemoryDisplayConfiguration } from '../utils/view-types';
+import { Decoration, Endianness, Memory, MemoryDisplayConfiguration, } from '../utils/view-types';
 import { MemoryTable } from './memory-table';
 import { OptionsWidget } from './options-widget';
+import { WebviewIdMessageParticipant } from 'vscode-messenger-common';
+import { VscodeContext, createAppVscodeContext } from '../utils/vscode-contexts';
+import { WebviewSelection } from '../../common/messaging';
 
 interface MemoryWidgetProps extends MemoryDisplayConfiguration {
+    messageParticipant: WebviewIdMessageParticipant;
     memory?: Memory;
     title: string;
     decorations: Decoration[];
@@ -50,14 +54,27 @@ const defaultOptions: MemoryWidgetState = {
 };
 
 export class MemoryWidget extends React.Component<MemoryWidgetProps, MemoryWidgetState> {
+    protected optionsWidget = React.createRef<OptionsWidget>();
+    protected memoryTable = React.createRef<MemoryTable>();
     constructor(props: MemoryWidgetProps) {
         super(props);
         this.state = { ...defaultOptions };
     }
 
+    protected createVscodeContext(): VscodeContext {
+        const visibleColumns = `|${this.props.columns.filter(candidate => candidate.active).map(column => column.contribution.id).join('|')}|`;
+        return createAppVscodeContext({
+            messageParticipant: this.props.messageParticipant,
+            showRadixPrefix: this.props.showRadixPrefix,
+            visibleColumns
+        });
+
+    }
+
     override render(): React.ReactNode {
-        return (<div className='flex flex-column h-full'>
+        return (<div className='flex flex-column h-full' {...this.createVscodeContext()}>
             <OptionsWidget
+                ref={this.optionsWidget}
                 title={this.props.title}
                 updateTitle={this.props.updateTitle}
                 columnOptions={this.props.columns}
@@ -79,6 +96,7 @@ export class MemoryWidget extends React.Component<MemoryWidgetProps, MemoryWidge
                 isFrozen={this.props.isFrozen}
             />
             <MemoryTable
+                ref={this.memoryTable}
                 decorations={this.props.decorations}
                 columnOptions={this.props.columns.filter(candidate => candidate.active)}
                 memory={this.props.memory}
@@ -95,7 +113,15 @@ export class MemoryWidget extends React.Component<MemoryWidgetProps, MemoryWidge
                 showRadixPrefix={this.props.showRadixPrefix}
                 isFrozen={this.props.isFrozen}
             />
-        </div>);
+        </div >);
+    }
+
+    public showAdvancedOptions(): void {
+        this.optionsWidget.current?.showAdvancedOptions();
+    }
+
+    public getWebviewSelection(): WebviewSelection {
+        return this.memoryTable.current?.getWebviewSelection() ?? {};
     }
 
 }
diff --git a/src/webview/components/options-widget.tsx b/src/webview/components/options-widget.tsx
index b6ef6d3..ef1e742 100644
--- a/src/webview/components/options-widget.tsx
+++ b/src/webview/components/options-widget.tsx
@@ -28,6 +28,7 @@ import {
 } from '../utils/view-types';
 import { MultiSelectWithLabel } from './multi-select';
 import { Checkbox } from 'primereact/checkbox';
+import { createSectionVscodeContext } from '../utils/vscode-contexts';
 
 export interface OptionsWidgetProps
     extends Omit<TableRenderOptions, 'scrollingBehavior'>,
@@ -74,6 +75,9 @@ export class OptionsWidget extends React.Component<OptionsWidgetProps, OptionsWi
     protected formConfig: FormikConfig<OptionsForm>;
     protected extendedOptions = React.createRef<OverlayPanel>();
     protected labelEditInput = React.createRef<HTMLInputElement>();
+    protected coreOptionsDiv = React.createRef<HTMLDivElement>();
+    protected optionsMenuContext = createSectionVscodeContext('optionsWidget');
+    protected advancedOptionsContext = createSectionVscodeContext('advancedOptionsOverlay');
 
     protected get optionsFormValues(): OptionsForm {
         return {
@@ -146,7 +150,7 @@ export class OptionsWidget extends React.Component<OptionsWidgetProps, OptionsWi
         const freezeContentToggleTitle = isFrozen ? 'Unfreeze Memory View' : 'Freeze Memory View';
 
         return (
-            <div className='memory-options-widget px-4'>
+            <div className='memory-options-widget px-4' {...this.optionsMenuContext}>
                 <div className='title-container'>
                     <Button
                         type='button'
@@ -181,8 +185,8 @@ export class OptionsWidget extends React.Component<OptionsWidgetProps, OptionsWi
                         />
                     )}
                 </div>
-                <div className='core-options py-2'>
-                    <Formik {...this.formConfig} >
+                <div className='core-options py-2' ref={this.coreOptionsDiv}>
+                    <Formik {...this.formConfig}>
                         {formik => (
                             <form onSubmit={formik.handleSubmit} className='form-options'>
                                 <span className={'pm-top-label form-texfield-long'}>
@@ -257,7 +261,7 @@ export class OptionsWidget extends React.Component<OptionsWidgetProps, OptionsWi
                         aria-label='Advanced Display Options'
                         aria-haspopup
                     ></Button>
-                    <OverlayPanel ref={this.extendedOptions}>
+                    <OverlayPanel ref={this.extendedOptions} {...this.advancedOptionsContext}>
                         <Button
                             icon='codicon codicon-discard'
                             className='reset-advanced-options-icon'
@@ -471,4 +475,13 @@ export class OptionsWidget extends React.Component<OptionsWidgetProps, OptionsWi
         }
     }
 
+    public showAdvancedOptions(): void {
+        if (this.extendedOptions.current && this.coreOptionsDiv.current) {
+            if (!this.extendedOptions.current.getElement()) {
+                this.coreOptionsDiv.current.querySelector<HTMLButtonElement>('.advanced-options-toggle')?.click();
+            }
+        }
+
+    }
+
 }
diff --git a/src/webview/memory-webview-view.tsx b/src/webview/memory-webview-view.tsx
index 241183f..af68923 100644
--- a/src/webview/memory-webview-view.tsx
+++ b/src/webview/memory-webview-view.tsx
@@ -16,7 +16,7 @@
 
 import React from 'react';
 import { createRoot } from 'react-dom/client';
-import { HOST_EXTENSION } from 'vscode-messenger-common';
+import { HOST_EXTENSION, WebviewIdMessageParticipant } from 'vscode-messenger-common';
 import {
     readyType,
     logMessageType,
@@ -25,6 +25,9 @@ import {
     setTitleType,
     setMemoryViewSettingsType,
     resetMemoryViewSettingsType,
+    showAdvancedDisplayConfigurationType,
+    getWebviewSelectionType,
+    WebviewSelection,
 } from '../common/messaging';
 import type { DebugProtocol } from '@vscode/debugprotocol';
 import { Decoration, Memory, MemoryDisplayConfiguration, MemoryState } from './utils/view-types';
@@ -40,6 +43,7 @@ import { PrimeReactProvider } from 'primereact/api';
 import 'primeflex/primeflex.css';
 
 export interface MemoryAppState extends MemoryState, MemoryDisplayConfiguration {
+    messageParticipant: WebviewIdMessageParticipant;
     title: string;
     decorations: Decoration[];
     columns: ColumnStatus[];
@@ -56,6 +60,7 @@ const MEMORY_DISPLAY_CONFIGURATION_DEFAULTS: MemoryDisplayConfiguration = {
 };
 
 class App extends React.Component<{}, MemoryAppState> {
+    protected memoryWidget = React.createRef<MemoryWidget>();
 
     public constructor(props: {}) {
         super(props);
@@ -65,6 +70,7 @@ class App extends React.Component<{}, MemoryAppState> {
         columnContributionService.register(new AsciiColumn());
         decorationService.register(variableDecorator);
         this.state = {
+            messageParticipant: { type: 'webview', webviewId: '' },
             title: 'Memory',
             memory: undefined,
             memoryReference: '',
@@ -88,12 +94,16 @@ class App extends React.Component<{}, MemoryAppState> {
             }
             this.setState(prevState => ({ ...prevState, ...config, title: config.title ?? prevState.title, }));
         });
+        messenger.onRequest(getWebviewSelectionType, () => this.getWebviewSelection());
+        messenger.onNotification(showAdvancedDisplayConfigurationType, () => this.showAdvancedOptions());
         messenger.sendNotification(readyType, HOST_EXTENSION, undefined);
     }
 
     public render(): React.ReactNode {
         return <PrimeReactProvider>
             <MemoryWidget
+                ref={this.memoryWidget}
+                messageParticipant={this.state.messageParticipant}
                 memory={this.state.memory}
                 decorations={this.state.decorations}
                 columns={this.state.columns}
@@ -190,6 +200,13 @@ class App extends React.Component<{}, MemoryAppState> {
         this.setState(prevState => ({ ...prevState, isFrozen: !prevState.isFrozen }));
     }
 
+    protected showAdvancedOptions(): void {
+        this.memoryWidget.current?.showAdvancedOptions();
+    }
+
+    protected getWebviewSelection(): WebviewSelection {
+        return this.memoryWidget.current?.getWebviewSelection() ?? {};
+    }
 }
 
 const container = document.getElementById('root') as Element;
diff --git a/src/webview/utils/view-types.ts b/src/webview/utils/view-types.ts
index 1c9130b..b109bd0 100644
--- a/src/webview/utils/view-types.ts
+++ b/src/webview/utils/view-types.ts
@@ -18,6 +18,7 @@ import type { DebugProtocol } from '@vscode/debugprotocol';
 import deepequal from 'fast-deep-equal';
 import type * as React from 'react';
 import { areRangesEqual, BigIntMemoryRange, Radix } from '../../common/memory-range';
+import { WebviewIdMessageParticipant } from 'vscode-messenger-common';
 
 export enum Endianness {
     Little = 'Little Endian',
@@ -75,6 +76,7 @@ export interface FullNodeAttributes extends StylableNodeAttributes {
 /** All settings related to memory view that can be specified for the webview from the extension "main". */
 export interface MemoryViewSettings extends ColumnVisibilityStatus, MemoryDisplayConfiguration {
     title: string
+    messageParticipant: WebviewIdMessageParticipant;
 }
 
 /** The memory display configuration that can be specified for the memory widget. */
@@ -97,3 +99,4 @@ export type ReactInteraction<E extends Element = Element> = React.MouseEvent<E>
 export function isTrigger(event: ReactInteraction): boolean {
     return !('code' in event) || event.code === 'Enter' || event.code === 'Space';
 }
+
diff --git a/src/webview/utils/vscode-contexts.ts b/src/webview/utils/vscode-contexts.ts
new file mode 100644
index 0000000..2681a56
--- /dev/null
+++ b/src/webview/utils/vscode-contexts.ts
@@ -0,0 +1,51 @@
+/********************************************************************************
+ * Copyright (C) 2024 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { WebviewIdMessageParticipant } from 'vscode-messenger-common';
+
+/**
+ * Custom data property used by VSCode to provide additional context info when opening a webview context menu
+ * The data property needs to represent a valid JSON object.  Data context properties up the parent chain are merged into the child context.
+ * This context info can be used to in `when` clauses from webview/context menu contributions and is accessible as argument of the corresponding command.
+ */
+export interface VscodeContext {
+    'data-vscode-context': string;
+}
+
+export interface AppVscodeContext {
+    messageParticipant: WebviewIdMessageParticipant;
+    visibleColumns: string;
+    showRadixPrefix: boolean;
+}
+
+export type WebviewSection = 'optionsWidget' | 'advancedOptionsOverlay' | 'memoryTable';
+
+export function createVscodeContext<C extends {}>(context: C): VscodeContext {
+    return { 'data-vscode-context': JSON.stringify(context) };
+}
+
+export function createSectionVscodeContext(webviewSection: WebviewSection): VscodeContext {
+    return createVscodeContext({ webviewSection });
+}
+
+export function createColumnVscodeContext(column: string): VscodeContext {
+    return createVscodeContext({ columnId: column });
+}
+
+export function createAppVscodeContext(appContext: AppVscodeContext): VscodeContext {
+    return createVscodeContext(appContext);
+}
+
diff --git a/src/webview/variables/variable-decorations.ts b/src/webview/variables/variable-decorations.ts
index d03c9cb..66ff4c7 100644
--- a/src/webview/variables/variable-decorations.ts
+++ b/src/webview/variables/variable-decorations.ts
@@ -25,6 +25,7 @@ import { Decorator } from '../decorations/decoration-service';
 import { ReactNode } from 'react';
 import { areVariablesEqual, compareBigInt, BigIntMemoryRange, BigIntVariableRange, doOverlap } from '../../common/memory-range';
 import * as React from 'react';
+import { createVscodeContext } from '../utils/vscode-contexts';
 
 const NON_HC_COLORS = [
     'var(--vscode-terminal-ansiBlue)',
@@ -79,7 +80,8 @@ export class VariableDecorator implements ColumnContribution, Decorator {
     render(range: BigIntMemoryRange): ReactNode {
         return this.getVariablesInRange(range)?.reduce<ReactNode[]>((result, current, index) => {
             if (index > 0) { result.push(', '); }
-            result.push(React.createElement('span', { style: { color: current.color }, key: current.variable.name }, current.variable.name));
+            const vscodeContext = createVscodeContext({ name: current.variable.name, type: current.variable.type, value: current.variable.value });
+            result.push(React.createElement('span', { style: { color: current.color }, key: current.variable.name, ...vscodeContext }, current.variable.name));
             return result;
         }, []);
     }